Options
All
  • Public
  • Public/Protected
  • All
Menu

Class EmbeddedCollection

An extension of the Collection. Used for the specific task of containing embedded Document instances within a parent Document.

Hierarchy

Index

Constructors

Properties

Methods

Accessors

Constructors

constructor

  • Parameters

    • model: DataModel

      The parent DataModel instance to which this collection belongs

    • sourceArray: any[]

      The source data array for the collection in the parent Document data

    • documentClass: typeof Document

      The Document class contained in the collection

    Returns EmbeddedCollection

Properties

documentClass

documentClass: typeof Document

The Document implementation used to construct instances within this collection.

invalidDocumentIds

invalidDocumentIds: Set<string> = ...

Record the set of document ids where the Document was not initialized because of invalid source data

Private #model

#model: DataModel

The parent DataModel to which this EmbeddedCollection instance belongs.

Private #initialized

#initialized: boolean = false

Has this embedded collection been initialized as a one-time workflow?

Private _source

_source: any[]

The source data array from which the embedded collection is created

Methods

initialize

  • initialize([options]?: { strict: boolean }): void

  • Initialize the EmbeddedCollection object by constructing its contained Document instances

    Parameters

    • [options]: { strict: boolean } = {}

      Initialization options.

      • strict: boolean

    Returns void

set

  • set(key: any, value: any, __namedParameters?: { modifySource: boolean }): EmbeddedCollection
  • inheritdoc

    Parameters

    • key: any
    • value: any
    • __namedParameters: { modifySource: boolean } = {}
      • modifySource: boolean

    Returns EmbeddedCollection

delete

  • delete(key: any, __namedParameters?: { modifySource: boolean }): boolean
  • inheritdoc

    Parameters

    • key: any
    • __namedParameters: { modifySource: boolean } = {}
      • modifySource: boolean

    Returns boolean

update

  • update(changes: DataModel[], options?: any): void

  • Update an EmbeddedCollection using an array of provided document data.

    Parameters

    • changes: DataModel[]

      An array of provided Document data

    • options: any = {}

    Returns void

getInvalid

  • getInvalid(id: string): Document

  • 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.

    Returns Document

    An in-memory instance for the invalid Document

toObject

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

  • Convert the EmbeddedCollection to an array of simple objects.

    Parameters

    • source: boolean = true

    Returns any[]

    The extracted array of primitive objects

find

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

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

    see

    {Array#find}

    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

    Parameters

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

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

        • (arg0: any, arg1: number, arg2: Collection): boolean

        • Parameters

          Returns boolean

    Returns any

    The value, if found, otherwise undefined

filter

  • filter(condition: ((arg0: any, arg1: number, arg2: Collection) => boolean)): any[]

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

    see

    {Array#filter}

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

    Parameters

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

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

        • (arg0: any, arg1: number, arg2: Collection): boolean

        • Parameters

          Returns boolean

    Returns any[]

    An Array of matched values

forEach

  • forEach(fn: ((arg0: any) => void)): void

  • Apply a function to each element of the collection

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

    Parameters

    • fn: ((arg0: any) => void)

      A function to apply to each element

        • (arg0: any): void

        • Parameters

          • arg0: any

          Returns void

    Returns void

get

  • get(key: string, [options]?: { strict: boolean }): any

  • Get an element from the Collection by its key.

    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

    Parameters

    • key: string

      The key of the entry to retrieve

    • [options]: { strict: boolean } = {}

      Additional options that affect how entries are retrieved

      • strict: boolean

    Returns any

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

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.

    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

    Parameters

    • name: string

      The name of the entry to retrieve

    • [options]: { strict: boolean } = {}

      Additional options that affect how entries are retrieved

      • strict: boolean

    Returns any

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

map

  • map(transformer: ((arg0: any, 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: any, 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.

        • Parameters

          Returns any

    Returns any[]

    An Array of transformed values

reduce

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

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

    see

    {Array#reduce}

    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"

    Parameters

    • reducer: ((arg0: any, arg1: any, 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.

        • (arg0: any, arg1: any, arg2: number, arg3: Collection): any

        • Parameters

          Returns any

    • initial: any

      An initial value which accumulates with each iteration

    Returns any

    The accumulated result

some

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

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

    see

    {Array#some}

    Parameters

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

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

        • (arg0: any, arg1: number, arg2: Collection): boolean

        • Parameters

          Returns boolean

    Returns boolean

    Was the test condition passed by at least one entry?

toJSON

  • toJSON(): any[]

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

    Returns any[]

    An array of contained values

[iterator]

  • [iterator](): IterableIterator<any>

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

    Returns IterableIterator<any>

Accessors

contents

  • get contents(): any[]

  • Return an Array of all the entry values in the Collection

    Returns any[]