Class CombatEncounters

apps

invalidDocumentIds

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

documentName

• get documentName(): any

  Returns any

  Inherit Doc

folders

• get folders(): Collection<string, documents.Folder>

  Reference the set of Folders which contain documents in this collection

  Returns Collection<string, documents.Folder>

name

• get name(): string

  The Collection class name

  Returns string

Staticinstance

• get instance(): WorldCollection<any>

  Return a reference to the singleton instance of this WorldCollection, or null if it has not yet been created.

  Returns WorldCollection<any>

StaticregisteredSheets

• get registeredSheets(): DocumentSheet[]

  Return an array of currently registered sheet classes for this Document type.

  Returns DocumentSheet[]

_getVisibleTreeContents

• _getVisibleTreeContents(entry: any): documents.Combat[]

  Parameters

  • entry: any

  Returns documents.Combat[]

_prepareImportDocument

• _prepareImportDocument(document: any, options: any): object

  Parameters

  • document: any
  • options: any

  Returns object

[iterator]

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

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

  Returns MapIterator<documents.Combat>

createDocument

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

  Instantiate a Document for inclusion in the Collection.

  Parameters

  • data: object

    The Document data.

  • Optionalcontext: object = {}

    Document creation context.

  Returns documents.Combat

delete

• delete(id: any): boolean

  Parameters

  • id: any

  Returns boolean

  Inherit Doc

filter

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

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

  Parameters

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

    The functional condition to test.

  Returns documents.Combat[]

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

  Find an entry in the Map using a functional condition.

  Parameters

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

    The functional condition to test.

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

  Apply a function to each element of the collection

  Parameters

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

fromCompendium

• fromCompendium(
      document: object | documents.Combat,
      options?: FromCompendiumOptions,
  ): object

  Apply data transformations when importing a Document from a Compendium pack

  Parameters

  • document: object | documents.Combat

    The source Document, or a plain data object

  • Optionaloptions: FromCompendiumOptions = {}

    Additional options which modify how the document is imported

  Returns object

  The processed data ready for world Document creation

get

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

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

  Throws

  If strict is true and the Document cannot be found.

getInvalid

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

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

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

importFromCompendium

• importFromCompendium(
      pack: CompendiumCollection<any>,
      id: string,
      updateData?: object,
      options?: any,
  ): Promise<documents.Combat>

  Import a Document from a Compendium collection, adding it to the current World. This method is a convenience wrapper around the underlying WorldCollection#importDocument workflow.

  Parameters

  • pack: CompendiumCollection<any>

    The CompendiumCollection instance from which to import

  • id: string

    The ID of the compendium entry to import

  • OptionalupdateData: object = {}

    Optional additional data used to modify the imported Document before it is created

  • Optionaloptions: any = {}

    Options passed to WorldCollection#importDocument

  Returns Promise<documents.Combat>

  The imported Document instance

map

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

render

• render(force?: boolean, options?: object): void

  Render any Applications associated with this DocumentCollection.

  Parameters

  • Optionalforce: boolean = false

    Force rendering

  • Optionaloptions: object = {}

    Optional options

  Returns void

search

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

  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.Combat[]

set

• set(id: string, document: documents.Combat): CombatEncounters

  Parameters

  • id: string
  • document: documents.Combat

  Returns CombatEncounters

some

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

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

  Parameters

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

updateAll

• updateAll(
      transformation: object | Function,
      condition?: Function | null,
      options?: object,
  ): Promise<documents.Combat[]>

  Update all objects in this DocumentCollection with a provided transformation. Conditionally filter to only apply to Entities which match a certain condition.

  Parameters

  • transformation: object | Function

    An object of data or function to apply to all matched objects

  • condition: Function | null = null

    A function which tests whether to target each object

  • Optionaloptions: object = {}

    Additional options passed to Document.updateDocuments

  Returns Promise<documents.Combat[]>

  An array of updated data once the operation is complete

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

StaticregisterSheet

• registerSheet(...args: any[]): void

  Register a Document sheet class as a candidate which can be used to display Documents of a given type. See foundry.applications.apps.DocumentSheetConfig.registerSheet for details.

  Parameters

  • ...args: any[]

    Arguments forwarded to the DocumentSheetConfig.registerSheet method

  Returns void

  Example: Register a new ActorSheet subclass for use with certain Actor types.

  foundry.documents.collections.Actors.registerSheet("dnd5e", ActorSheet5eCharacter, {
    types: ["character],
    makeDefault: true
  });
  Copy

StaticunregisterSheet

• unregisterSheet(...args: any[]): void

  Unregister a Document sheet class, removing it from the list of available sheet Applications to use. See foundry.applications.apps.DocumentSheetConfig.unregisterSheet for detauls.

  Parameters

  • ...args: any[]

    Arguments forwarded to the DocumentSheetConfig.unregisterSheet method

  Returns void

  Example: Deregister the default ActorSheet subclass to replace it with others.

  foundry.documents.collections.Actors.unregisterSheet("core", ActorSheet);
  Copy