Class EmbeddedCollectionDelta<TDocument>

_source

documentClass

invalidDocumentIds

model

name

contents

• get contents(): V[]

  Return an Array of all the entry values in the Collection

  Returns V[]

documentName

• get documentName(): string | void

  The Document name of Documents stored in this collection.

  Returns string | void

documentsByType

• get documentsByType(): Record<string, TDocument[]>

  This collection's contents grouped by subtype, lazily (re-)computed as needed. If the document type does not support subtypes, all will be in the "base" group.

  Returns Record<string, TDocument[]>

[iterator]

• "[iterator]"(): MapIterator<string>

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

  Returns MapIterator<string>

filter

• filter(
      condition: (
          value: string,
          index: number,
          collection: Collection<string, string>,
      ) => unknown,
  ): string[]

  Filter the Collection, returning an Array of entries which match a functional condition.

  Parameters

  • condition: (
        value: string,
        index: number,
        collection: Collection<string, string>,
    ) => unknown

    The functional condition to test.

  Returns string[]

  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");
  Copy

find

• find(
      condition: (
          value: string,
          index: number,
          collection: Collection<string, string>,
      ) => unknown,
  ): undefined | string

  Find an entry in the Map using a functional condition.

  Parameters

  • condition: (
        value: string,
        index: number,
        collection: Collection<string, string>,
    ) => unknown

    The functional condition to test.

  Returns undefined | string

  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
  Copy

forEach

• forEach(fn: (value: string) => void): void

  Apply a function to each element of the collection

  Parameters

  • fn: (value: string) => void

    A function to apply to each element

  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);
  Copy

get

• get(id: string, options?: { invalid?: boolean; strict?: boolean }): string

  Get a document from the EmbeddedCollection by its ID.

  Parameters

  • id: string

    The ID of the Embedded Document to retrieve.
  • Optionaloptions: { invalid?: boolean; strict?: boolean } = {}

    Additional options to configure retrieval.

    • Optionalinvalid?: boolean

      Allow retrieving an invalid Embedded Document.

    • Optionalstrict?: boolean

      Throw an Error if the requested Embedded Document does not exist.

  Returns string

  The retrieved document instance, or undefined

  Throws

  If strict is true and the Embedded Document cannot be found.

getInvalid

• getInvalid(id: string, options?: { strict?: boolean }): string | void

  Obtain a temporary Document instance for a document id which currently has invalid source data.

  Parameters

  • id: string

    A document ID with invalid source data.
  • Optionaloptions: { strict?: boolean } = {}

    Additional options to configure retrieval.

    • Optionalstrict?: boolean

      Throw an Error if the requested ID is not in the set of invalid IDs for this collection.

  Returns string | void

  An in-memory instance for the invalid Document

  Throws

  If strict is true and the requested ID is not in the set of invalid IDs for this collection.

getName

• getName(name: string, options?: { strict?: boolean }): undefined | string

  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
  • Optionaloptions: { strict?: boolean } = {}

    Additional options that affect how entries are retrieved

    • Optionalstrict?: boolean

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

  Returns undefined | string

  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
  Copy

map

• map(transformer: (arg0: string, arg1: number, arg2: Collection) => any): any[]

  Transform each element of the Collection into a new form, returning an Array of transformed values

  Parameters

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

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

  Returns any[]

  An Array of transformed values

reduce

• reduce(
      reducer: (
          arg0: any,
          arg1: string,
          arg2: number,
          arg3: Collection,
      ) => any,
      initial: any,
  ): any

  Reduce the Collection by applying an evaluator function and accumulating entries

  Parameters

  • reducer: (arg0: any, arg1: string, arg2: number, arg3: Collection) => 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.
  • 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"
  Copy

some

• some(
      condition: (arg0: string, arg1: number, arg2: Collection) => boolean,
  ): boolean

  Test whether a condition is met by some entry in the Collection.

  Parameters

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

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

  Returns boolean

  Was the test condition passed by at least one entry?

  See

toJSON

• toJSON(): object[]

  Convert the Collection to a primitive array of its contents.

  Returns object[]

  An array of contained values

toObject

• toObject(source?: boolean): object[]

  Convert the EmbeddedCollection to an array of simple objects.

  Parameters

  • Optionalsource: boolean = true

    Draw data for contained Documents from the underlying data source?

  Returns object[]

  The extracted array of primitive objects