Class CompendiumFolderCollection

apps

invalidDocumentIds

StaticdocumentName

contents

• get contents(): V[]

  Return an Array of all the entry values in the Collection

  Returns V[]

documentClass

• get documentClass(): typeof Document

  A reference to the Document class definition which is contained within this DocumentCollection.

  Returns typeof Document

name

• get name(): string

  The Collection class name

  Returns string

[iterator]

• "[iterator]"(): MapIterator<documents.Folder>

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

  Returns MapIterator<documents.Folder>

createDocument

• createDocument(data: object, context?: object): documents.Folder

  Instantiate a Document for inclusion in the Collection.

  Parameters

  • data: object

    The Document data.

  • Optionalcontext: object = {}

    Document creation context.

  Returns documents.Folder

delete

• delete(id: any): boolean

  Parameters

  • id: any

  Returns boolean

  Inherit Doc

filter

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

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

  Parameters

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

    The functional condition to test.

  Returns documents.Folder[]

  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: documents.Folder,
          index: number,
          collection: Collection<string, documents.Folder>,
      ) => unknown,
  ): documents.Folder | undefined

  Find an entry in the Map using a functional condition.

  Parameters

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

    The functional condition to test.

  Returns documents.Folder | undefined

  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: documents.Folder, index: number) => void): void

  Apply a function to each element of the collection

  Parameters

  • fn: (value: documents.Folder, 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 },
  ): documents.Folder

  Get an element from the DocumentCollection by its ID.

  Parameters

  • id: string

    The ID of the Document to retrieve.

  • Optionaloptions: { invalid?: boolean; strict?: boolean } = {}

    Additional options to configure retrieval.

    • Optionalinvalid?: boolean

      Allow retrieving an invalid Document.

    • Optionalstrict?: boolean

      Throw an Error if the requested Document does not exist.

  Returns documents.Folder

  Throws

  If strict is true and the Document cannot be found.

getInvalid

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

  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 void | documents.Folder

  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 },
  ): documents.Folder | undefined

  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 documents.Folder | undefined

  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

importDocument

• importDocument(
      document: Document<object, DocumentConstructionContext>,
      options: FromCompendiumOptions | ToCompendiumOptions,
  ): Promise<Document<object, DocumentConstructionContext>>

  Import a Document into this collection, persisting the result. If the document ID already exists in the collection, it should be replaced with an optional confirmation dialog. If the document ID is undefined or does not already exist, a new Document will be created in the collection.

  Parameters

  • document: Document<object, DocumentConstructionContext>

    A source Document to be imported. The document will be safely copied.

  • options: FromCompendiumOptions | ToCompendiumOptions

    Options which modify import behavior

  Returns Promise<Document<object, DocumentConstructionContext>>

  The imported Document instance

map

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

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

  Type Parameters

  • U

  Parameters

  • transformer: (
        element: documents.Folder,
        index: number,
        collection: Collection<string, documents.Folder>,
    ) => 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, documents.Folder>,
      ) => 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, documents.Folder>,
    ) => 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

search

• search(
      search: { exclude?: string[]; filters?: FieldFilter[]; query?: string },
  ): object[] | documents.Folder[]

  Find all Documents which match a given search term using a full-text search against their indexed HTML fields and their name. If filters are provided, results are filtered to only those that match the provided values.

  Parameters

  • search: { exclude?: string[]; filters?: FieldFilter[]; query?: string }

    An object configuring the search

    • Optionalexclude?: string[]

      An array of document IDs to exclude from search results

    • Optionalfilters?: FieldFilter[]

      An array of filters to apply

    • Optionalquery?: string

      A case-insensitive search string

  Returns object[] | documents.Folder[]

set

• set(id: string, document: documents.Folder): CompendiumFolderCollection

  Parameters

  • id: string
  • document: documents.Folder

  Returns CompendiumFolderCollection

some

• some(
      condition: (
          element: T,
          index: number,
          set: Collection<string, documents.Folder>,
      ) => boolean,
  ): boolean

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

  Parameters

  • condition: (
        element: T,
        index: number,
        set: Collection<string, documents.Folder>,
    ) => 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

StaticgetSearchableFields

• getSearchableFields(
      documentName: string,
      type?: string,
  ): Record<string, SearchableField>

  Get the searchable fields for a given document or index, based on its data model

  Parameters

  • documentName: string

    The document name

  • Optionaltype: string

    A document subtype

  Returns Record<string, SearchableField>

  A record of searchable DataField definitions