Class Playlists

apps

invalidDocumentIds

contents

• get contents(): V[]

  Return an Array of all the entry values in the Collection

  Returns V[]

directory

• get directory(): DocumentDirectory<ClientDocument>

  Return a reference to the SidebarDirectory application for this WorldCollection.

  Returns DocumentDirectory<ClientDocument>

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

  Parameters

  • entry: any

  Returns documents.Playlist[]

[iterator]

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

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

  Returns MapIterator<documents.Playlist>

createDocument

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

  Instantiate a Document for inclusion in the Collection.

  Parameters

  • data: object

    The Document data.
  • Optionalcontext: object = {}

    Document creation context.

  Returns documents.Playlist

delete

• delete(id: any): boolean

  Parameters

  • id: any

  Returns boolean

  Inherit Doc

filter

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

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

  Parameters

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

    The functional condition to test.

  Returns documents.Playlist[]

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

  Find an entry in the Map using a functional condition.

  Parameters

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

    The functional condition to test.

  Returns undefined | documents.Playlist

  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.Playlist) => void): void

  Apply a function to each element of the collection

  Parameters

  • fn: (value: documents.Playlist) => 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.Playlist,
      options?: FromCompendiumOptions,
  ): object

  Apply data transformations when importing a Document from a Compendium pack

  Parameters

  • document: object | documents.Playlist

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

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

  Throws

  If strict is true and the Document cannot be found.

getInvalid

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

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

  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 | documents.Playlist

  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 | documents.Playlist

  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

importFromCompendium

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

  Import a Document from a Compendium collection, adding it to the current World.

  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: object = {}

    Optional arguments passed to the foundry.documents.abstract.WorldCollection#fromCompendium and foundry.abstract.Document.create methods

  Returns Promise<documents.Playlist>

  The imported Document instance

map

• map(
      transformer: (
          arg0: documents.Playlist,
          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: documents.Playlist, 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: documents.Playlist,
          arg2: number,
          arg3: Collection,
      ) => any,
      initial: any,
  ): any

  Reduce the Collection by applying an evaluator function and accumulating entries

  Parameters

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

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

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

set

• set(id: any, document: any): void

  Parameters

  • id: any
  • document: any

  Returns void

  Inherit Doc

some

• some(
      condition: (
          arg0: documents.Playlist,
          arg1: number,
          arg2: Collection,
      ) => boolean,
  ): boolean

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

  Parameters

  • condition: (arg0: documents.Playlist, 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

updateAll

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

  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: null | Function = null

    A function which tests whether to target each object
  • Optionaloptions: object = {}

    Additional options passed to Document.updateDocuments

  Returns Promise<documents.Playlist[]>

  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