A reusable storage concept which blends the functionality of an Array with the efficient key-based lookup of a Map. This concept is reused throughout Foundry VTT where a collection of uniquely identified elements is required.

Type Parameters

  • K
  • V

Hierarchy (view full)

Constructors

  • Type Parameters

    • K extends string
    • V extends unknown

    Parameters

    • entries: any

    Returns Collection<K, V>

Accessors

  • get contents(): V[]
  • Return an Array of all the entry values in the Collection

    Returns V[]

Methods

  • Find an entry in the Map using a functional condition.

    Parameters

    • condition: ((arg0, arg1, arg2) => boolean)

      The functional condition to test. Positional arguments are the value, the index of iteration, and the collection being searched.

        • (arg0, arg1, arg2): boolean
        • Parameters

          Returns boolean

    Returns any

    The value, if found, otherwise undefined

    See

    Example: Create a new Collection and reference its contents

    let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
    c.get("a") === c.find(entry => entry === "A"); // true
  • Filter the Collection, returning an Array of entries which match a functional condition.

    Parameters

    • condition: ((arg0, arg1, arg2) => boolean)

      The functional condition to test. Positional arguments are the value, the index of iteration, and the collection being filtered.

        • (arg0, arg1, arg2): boolean
        • Parameters

          Returns boolean

    Returns any[]

    An Array of matched values

    See

    Example: Filter the Collection for specific entries

    let c = new Collection([["a", "AA"], ["b", "AB"], ["c", "CC"]]);
    let hasA = c.filters(entry => entry.slice(0) === "A");
  • Apply a function to each element of the collection

    Parameters

    • fn: ((arg0) => void)

      A function to apply to each element

        • (arg0): void
        • Parameters

          • arg0: any

          Returns void

    Returns void

    See

    Array#forEach

    Example: Apply a function to each value in the collection

    let c = new Collection([["a", {active: false}], ["b", {active: false}], ["c", {active: false}]]);
    c.forEach(e => e.active = true);
  • Get an element from the Collection by its key.

    Parameters

    • key: string

      The key of the entry to retrieve

    • Optional options: {
          strict: boolean;
      } = {}

      Additional options that affect how entries are retrieved

      • strict: boolean

        Throw an Error if the requested key does not exist. Default false.

    Returns any

    The retrieved entry value, if the key exists, otherwise undefined

    Example: Get an element from the Collection by key

    let c = new Collection([["a", "Alfred"], ["b", "Bob"], ["c", "Cynthia"]]);
    c.get("a"); // "Alfred"
    c.get("d"); // undefined
    c.get("d", {strict: true}); // throws Error
  • Get an entry from the Collection by name. Use of this method assumes that the objects stored in the collection have a "name" attribute.

    Parameters

    • name: string

      The name of the entry to retrieve

    • Optional options: {
          strict: boolean;
      } = {}

      Additional options that affect how entries are retrieved

      • strict: boolean

        Throw an Error if the requested name does not exist. Default false.

    Returns any

    The retrieved entry value, if one was found, otherwise undefined

    Example: Get an element from the Collection by name (if applicable)

    let c = new Collection([["a", "Alfred"], ["b", "Bob"], ["c", "Cynthia"]]);
    c.getName("Alfred"); // "Alfred"
    c.getName("D"); // undefined
    c.getName("D", {strict: true}); // throws Error
  • Transform each element of the Collection into a new form, returning an Array of transformed values

    Parameters

    • transformer: ((arg0, arg1, arg2) => any)

      A transformation function applied to each entry value. Positional arguments are the value, the index of iteration, and the collection being mapped.

        • (arg0, arg1, arg2): any
        • Parameters

          Returns any

    Returns any[]

    An Array of transformed values

  • Reduce the Collection by applying an evaluator function and accumulating entries

    Parameters

    • reducer: ((arg0, arg1, arg2, arg3) => any)

      A reducer function applied to each entry value. Positional arguments are the accumulator, the value, the index of iteration, and the collection being reduced.

        • (arg0, arg1, arg2, arg3): any
        • Parameters

          • arg0: any
          • arg1: any
          • arg2: number
          • arg3: Collection<any, any>

          Returns any

    • initial: any

      An initial value which accumulates with each iteration

    Returns any

    The accumulated result

    See

    Example: Reduce a collection to an array of transformed values

    let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
    let letters = c.reduce((s, l) => {
    return s + l;
    }, ""); // "ABC"
  • Test whether a condition is met by some entry in the Collection.

    Parameters

    • condition: ((arg0, arg1, arg2) => boolean)

      The functional condition to test. Positional arguments are the value, the index of iteration, and the collection being tested.

        • (arg0, arg1, arg2): boolean
        • Parameters

          Returns boolean

    Returns boolean

    Was the test condition passed by at least one entry?

    See

  • Convert the Collection to a primitive array of its contents.

    Returns any[]

    An array of contained values

  • Then iterating over a Collection, we should iterate over its values instead of over its entries

    Returns IterableIterator<V>