Class SingletonEmbeddedCollection

_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<any>

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

  Returns MapIterator<any>

createDocument

• createDocument(data: object, context?: DocumentConstructionContext): any

  Instantiate a Document for inclusion in the Collection.

  Parameters

  • data: object

    The Document data.

  • Optionalcontext: DocumentConstructionContext = {}

    Document creation context.

  Returns any

delete

• delete(key: string, options?: { modifySource?: boolean }): boolean

  Remove a document from the collection.

  Parameters

  • key: string

    The embedded Document ID.

  • Optionaloptions: { modifySource?: boolean } = {}

    Additional options to the delete operation.

    • OptionalmodifySource?: boolean

      Whether to modify the collection's source as part of the operation.

  Returns boolean

filter

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

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

  Parameters

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

    The functional condition to test.

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

find

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

  Find an entry in the Map using a functional condition.

  Parameters

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

    The functional condition to test.

  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
  Copy

forEach

• forEach(fn: (value: any, index: number) => void): void

  Apply a function to each element of the collection

  Parameters

  • fn: (value: any, index: number) => 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 }): any

  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 any

  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 }): any

  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 any

  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 }): any

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

initialize

• initialize(options?: DocumentConstructionContext): void

  Initialize the EmbeddedCollection by synchronizing its Document instances with existing _source data. Importantly, this method does not make any modifications to the _source array. It is responsible for creating, updating, or removing Documents from the Collection.

  Parameters

  • Optionaloptions: DocumentConstructionContext = {}

    Initialization options.

  Returns void

map

• map<U>(
      transformer: (
          element: any,
          index: number,
          collection: Collection<string, any>,
      ) => U,
  ): U[]

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

  Type Parameters

  • U

  Parameters

  • transformer: (element: any, index: number, collection: Collection<string, any>) => U

    A transformation function applied to each entry value.

  Returns U[]

  An Array of transformed values

  See

reduce

• reduce<U>(
      reducer: (
          accum: U,
          element: T,
          index: number,
          collection: Collection<string, any>,
      ) => U,
      initial: U,
  ): U

  Reduce the Collection by applying an evaluator function and accumulating entries

  Type Parameters

  • U

  Parameters

  • reducer: (accum: U, element: T, index: number, collection: Collection<string, any>) => U

    A reducer function applied to each entry value.

  • initial: U

    An initial value which accumulates with each iteration

  Returns U

  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: (
          element: T,
          index: number,
          set: Collection<string, any>,
      ) => boolean,
  ): boolean

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

  Parameters

  • condition: (element: T, index: number, set: Collection<string, any>) => boolean

    The functional condition to test.

  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