Class CompendiumCollection<TDocument>

A collection of Document objects contained within a specific compendium pack. Each Compendium pack has its own associated instance of the CompendiumCollection class which contains its contents.

Hook Events

hookEvents.updateCompendium

Template: TDocument

See

foundry.Game#packs

Type Parameters

TDocument extends Document

Hierarchy (View Summary)

DocumentCollection<TDocument, this>
- CompendiumCollection

Index

Constructors

constructor

new CompendiumCollection<
TDocument extends Document<object, DocumentConstructionContext>,
>(
metadata: object,
): CompendiumCollection<TDocument>
Type Parameters
- TDocument extends Document<object, DocumentConstructionContext>
Parameters
- metadata: object
  The compendium metadata, an object provided by game.data
Returns CompendiumCollection<TDocument>
Overrides DocumentCollection.constructor

Properties

`Internal`_source

_source: object[]

The source data array from which the Documents in the WorldCollection are created

applicationClass

applicationClass: typeof Application | typeof ApplicationV2 = foundry.applications.sidebar.apps.Compendium

A reference to the Application class which provides an interface to interact with this compendium content.

apps

apps: ApplicationV2<ApplicationConfiguration, ApplicationRenderOptions>[] = []

An Array of application references which will be automatically updated when the collection content changes

index

index: Collection<string, object>

A subsidiary collection which contains the more minimal index of the pack

invalidDocumentIds

invalidDocumentIds: Set<string> = ...

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

metadata

metadata: object

The compendium metadata which defines the compendium content and location

`Static`CACHE_LIFETIME_SECONDS

CACHE_LIFETIME_SECONDS: number = 300

The amount of time that Document instances within this CompendiumCollection are held in memory. Accessing the contents of the Compendium pack extends the duration of this lifetime.

`Static`CONFIG_SETTING

CONFIG_SETTING: string = "compendiumConfiguration"

The named game setting which contains Compendium configurations.

`Static`documentName

documentName: string

The base Document type which is contained within this DocumentCollection

Accessors

get banner(): string | void | null
The banner image for this Compendium pack, or the default image for the pack type if no image is set.

Returns string | void | null

collection

get collection(): string
The canonical Compendium name - comprised of the originating package and the pack name

Returns string

config

get config(): object
Access the compendium configuration data for this pack

Returns object

get contents(): V[]
Return an Array of all the entry values in the Collection

Returns V[]
Inherited from DirectoryCollectionMixin(DocumentCollection).contents

documentClass

get documentClass(): typeof Document
A reference to the Document class definition which is contained within this DocumentCollection.

Returns typeof Document
Inherited from DirectoryCollectionMixin(DocumentCollection).documentClass

documentName

get documentName(): any
Returns any
Inherit Doc
Overrides DocumentCollection.documentName

folder

get folder(): documents.Folder | null
Get the Folder that this Compendium is displayed within

Returns documents.Folder | null

indexed

get indexed(): boolean
Has this compendium pack been fully indexed?

Returns boolean

indexFields

get indexFields(): Set<string>
The index fields which should be loaded for this compendium pack

Returns Set<string>

locked

get locked(): boolean
Track whether the Compendium Collection is locked for editing

Returns boolean

maxFolderDepth

get maxFolderDepth(): number
Returns number

name

get name(): string
The Collection class name

Returns string
Inherited from DocumentCollection.name

ownership

get ownership(): Record<
    "PLAYER"
    | "TRUSTED"
    | "ASSISTANT"
    | "GAMEMASTER",
    "INHERIT" | "NONE" | "LIMITED" | "OBSERVER" | "OWNER",
>
The visibility configuration of this compendium pack.

Returns Record<
    "PLAYER"
    | "TRUSTED"
    | "ASSISTANT"
    | "GAMEMASTER",
    "INHERIT" | "NONE" | "LIMITED" | "OBSERVER" | "OWNER",
>

sort

get sort(): number
Get the sort order for this Compendium

Returns number

title

get title(): string
A convenience reference to the label which should be used as the title for the Compendium pack.

Returns string

visible

get visible(): boolean
Is this Compendium pack visible to the current game User?

Returns boolean

`Static`CONFIG_FIELD

get CONFIG_FIELD(): TypedObjectField
The DataField definition for the configuration Setting

Returns TypedObjectField

Methods

_getVisibleTreeContents

_getVisibleTreeContents(): any
Returns any

_onModifyContents

_onModifyContents(
    action: any,
    documents: any,
    result: any,
    operation: any,
    user: any,
): void
Internal
Follow-up actions to take when a database operation modifies Documents in this DocumentCollection.
Parameters
- action: any
  The database action performed
- documents: any
  The array of modified Documents
- result: any
  The result of the database operation
- operation: any
  Database operation details
- user: any
  The User who performed the operation
Returns void
Overrides DocumentCollection._onModifyContents

_prepareImportDocument

_prepareImportDocument(document: any, options: any): any
Parameters
- document: any
- options: any
Returns any
Overrides DocumentCollection._prepareImportDocument

[iterator]

"[iterator]"(): MapIterator<TDocument>
Then iterating over a Collection, we should iterate over its values instead of over its entries

Returns MapIterator<TDocument>
Inherited from DocumentCollection.[iterator]

clear

clear(): void
Returns void
Inherit Doc
Overrides DirectoryCollectionMixin(DocumentCollection).clear

configure

configure(configuration?: object): Promise<void>
Assign configuration metadata settings to the compendium pack
Parameters
- configuration: object = {}
  The object of compendium settings to define
Returns Promise<void>
A Promise which resolves once the setting is updated

configureOwnershipDialog

configureOwnershipDialog(): Promise<Record<string, string>>
Prompt the gamemaster with a dialog to configure ownership of this Compendium pack.

Returns Promise<Record<string, string>>
The configured ownership for the pack

createDocument

createDocument(data: object, context?: object): TDocument
Instantiate a Document for inclusion in the Collection.
Parameters
- data: object
  The Document data.
- Optionalcontext: object = {}
  Document creation context.
Returns TDocument
Inherited from DocumentCollection.createDocument

delete

delete(id: any): boolean
Parameters
- id: any
Returns boolean
Inherit Doc
Overrides DocumentCollection.delete

deleteCompendium

deleteCompendium(): Promise<CompendiumCollection<any>>
Delete an existing world-level Compendium Collection. This action may only be performed for world-level packs by a Gamemaster User.

Returns Promise<CompendiumCollection<any>>

duplicateCompendium

duplicateCompendium(label?: string): Promise<CompendiumCollection<any>>
Duplicate a compendium pack to the current World.
Parameters
- label: string = {}
  A new Compendium label
Returns Promise<CompendiumCollection<any>>

filter

filter(
    condition: (
        value: TDocument,
        index: number,
        collection: Collection<string, TDocument>,
    ) => unknown,
): TDocument[]
Filter the Collection, returning an Array of entries which match a functional condition.
Parameters
- condition: (
      value: TDocument,
      index: number,
      collection: Collection<string, TDocument>,
  ) => unknown
  The functional condition to test.
Returns TDocument[]
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");
```
Inherited from DocumentCollection.filter

find

find(
    condition: (
        value: TDocument,
        index: number,
        collection: Collection<string, TDocument>,
    ) => unknown,
): TDocument | undefined
Find an entry in the Map using a functional condition.
Parameters
- condition: (
      value: TDocument,
      index: number,
      collection: Collection<string, TDocument>,
  ) => unknown
  The functional condition to test.
Returns TDocument | 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
```
Inherited from DocumentCollection.find

forEach

forEach(fn: (value: TDocument, index: number) => void): void
Apply a function to each element of the collection
Parameters
- fn: (value: TDocument, 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);
```
Inherited from DocumentCollection.forEach

get

get(key: any, options: any): TDocument
Get an element from the DocumentCollection by its ID.
Parameters
- key: any
  The ID of the Document to retrieve.
- options: any
  Additional options to configure retrieval.
Returns TDocument
Throws
If strict is true and the Document cannot be found.

Overrides DocumentCollection.get

getDocument

getDocument(id: string): Promise<TDocument> | undefined
Get a single Document from this Compendium by ID. The document may already be locally cached, otherwise it is retrieved from the server.
Parameters
- id: string
  The requested Document id
Returns Promise<TDocument> | undefined
The retrieved Document instance

getDocuments

getDocuments(query?: object): Promise<TDocument[]>
Load multiple documents from the Compendium pack using a provided query object. The available query options are shown below.
Parameters
- query: object = {}
  A database query used to retrieve documents from the underlying database
Returns Promise<TDocument[]>
The retrieved Document instances
Example: Get Documents that match the given value only.
```
await pack.getDocuments({ type: "weapon" });
```
Example: Get all Documents that do not have the given value.
```
await pack.getDocuments({ type__ne: "weapon" });
```
Example: Get several Documents by their IDs.
```
await pack.getDocuments({ _id__in: arrayOfIds });
```
Example: Get Documents by their sub-types.
```
await pack.getDocuments({ type__in: ["weapon", "armor"] });
```

getIndex

getIndex(options?: { fields?: string[] }): Promise<Collection>
Load the Compendium index and cache it as the keys and values of the Collection.
Parameters
- Optionaloptions: { fields?: string[] } = {}
  Options which customize how the index is created
  - Optionalfields?: string[]
    An array of fields to return as part of the index
Returns Promise<Collection>

getInvalid

getInvalid(id: string, options?: { strict?: boolean }): void | TDocument
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 | TDocument
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.

Inherited from DocumentCollection.getInvalid

getName

getName(name: string, options?: { strict?: boolean }): TDocument | 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 TDocument | 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
```
Inherited from DocumentCollection.getName

getUserLevel

getUserLevel(user?: User): number
Get the ownership level that a User has for this Compendium pack.
Parameters
- user: User = game.user
  The user being tested
Returns number
The ownership level in CONST.DOCUMENT_OWNERSHIP_LEVELS

getUuid

getUuid(id: string): string
Generate a UUID for a given primary document ID within this Compendium pack
Parameters
- id: string
  The document ID to generate a UUID for
Returns string
The generated UUID, in the form of "Compendium..."

importAll

importAll(
options?: { folderId?: string | null; folderName?: string },
): Promise<TDocument[]>
Fully import the contents of a Compendium pack into a World folder.
Parameters
- Optionaloptions: { folderId?: string | null; folderName?: string } = {}
  Options which modify the import operation. Additional options are forwarded to foundry.documents.abstract.WorldCollection#fromCompendium and foundry.abstract.Document.createDocuments
  - OptionalfolderId?: string | null
    An existing Folder _id to use.
  - OptionalfolderName?: string
    A new Folder name to create.
Returns Promise<TDocument[]>
The imported Documents, now existing within the World

importDialog

importDialog(options?: object): Promise<boolean | TDocument[] | null>
Provide a dialog form that prompts the user to import the full contents of a Compendium pack into the World.
Parameters
- Optionaloptions: object = {}
  Additional options passed to the DialogV2.confirm method
Returns Promise<boolean | TDocument[] | null>
A promise which resolves in the following ways: an array of imported Documents if the "yes" button was pressed, false if the "no" button was pressed, or null if the dialog was closed without making a choice.

importDocument

importDocument(
document: any,
options?: {},
): 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: any
  A source Document to be imported. The document will be safely copied.
- options: {} = {}
  Options which modify import behavior
Returns Promise<Document<object, DocumentConstructionContext>>
The imported Document instance

Overrides DocumentCollection.importDocument

importFolder

importFolder(
folder: documents.Folder,
options?: { importParents?: boolean },
): Promise<void>
Import a Folder into this Compendium Collection.
Parameters
- folder: documents.Folder
  The existing Folder you wish to import
- Optionaloptions: { importParents?: boolean } = {}
  Additional options which modify how the data is imported.
  - OptionalimportParents?: boolean
    Import any parent folders which are not already present in the Compendium.
Returns Promise<void>

importFolders

importFolders(
folders: documents.Folder[],
options?: { importParents?: boolean },
): Promise<void>
Import an array of Folders into this Compendium Collection.
Parameters
- folders: documents.Folder[]
  The existing Folders you wish to import
- Optionaloptions: { importParents?: boolean } = {}
  Additional options which modify how the data is imported.
  - OptionalimportParents?: boolean
    Import any parent folders which are not already present in the Compendium.
Returns Promise<void>

indexDocument

indexDocument(document: TDocument): void
Add a Document to the index, capturing its relevant index attributes
Parameters
- document: TDocument
  The document to index
Returns void

map

map<U>(
    transformer: (
        element: TDocument,
        index: number,
        collection: Collection<string, TDocument>,
    ) => U,
): U[]
Transform each element of the Collection into a new form, returning an Array of transformed values
Type Parameters
- U
Parameters
- transformer: (
      element: TDocument,
      index: number,
      collection: Collection<string, TDocument>,
  ) => U
  A transformation function applied to each entry value.
Returns U[]
An Array of transformed values

See
Inherited from DocumentCollection.map

migrate

migrate(options?: { notify?: boolean }): Promise<CompendiumCollection<any>>
Migrate a compendium pack. This operation re-saves all documents within the compendium pack to disk, applying the current data model. If the document type has system data, the latest system data template will also be applied to all documents.
Parameters
- Optionaloptions: { notify?: boolean } = {}
  - Optionalnotify?: boolean
    Display notifications
Returns Promise<CompendiumCollection<any>>

reduce

reduce<U>(
    reducer: (
        accum: U,
        element: T,
        index: number,
        collection: Collection<string, TDocument>,
    ) => 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, TDocument>,
  ) => 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"
```
Inherited from DocumentCollection.reduce

render

render(force: any, options: any): void
Render any Applications associated with this DocumentCollection.
Parameters
- force: any
  Force rendering
- options: any
  Optional options
Returns void
Overrides DocumentCollection.render

search

search(
search: { exclude?: string[]; filters?: FieldFilter[]; query?: string },
): object[] | TDocument[]
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[] | TDocument[]
Inherited from DocumentCollection.search

set

set(
id: any,
document: any,
): CompendiumCollection<TDocument> | CompendiumFolderCollection
Parameters
- id: any
- document: any
Returns CompendiumCollection<TDocument> | CompendiumFolderCollection
Overrides DocumentCollection.set

setFolder

setFolder(folder: string | documents.Folder | null): Promise<void>
Assign this CompendiumCollection to be organized within a specific Folder.
Parameters
- folder: string | documents.Folder | null
  The desired Folder within the World or null to clear the folder
Returns Promise<void>
A promise which resolves once the transaction is complete

some

some(
    condition: (
        element: T,
        index: number,
        set: Collection<string, TDocument>,
    ) => boolean,
): boolean
Test whether a condition is met by some entry in the Collection.
Parameters
- condition: (element: T, index: number, set: Collection<string, TDocument>) => boolean
  The functional condition to test.
Returns boolean
Was the test condition passed by at least one entry?

See
Inherited from DocumentCollection.some

testUserPermission

testUserPermission(
    user: BaseUser,
    permission: string | number,
    options?: { exact?: boolean },
): boolean
Test whether a certain User has a requested permission level (or greater) over the Compendium pack
Parameters
- user: BaseUser
  The User being tested
- permission: string | number
  The permission level from DOCUMENT_OWNERSHIP_LEVELS to test
- options: { exact?: boolean } = {}
  Additional options involved in the permission test
  - Optionalexact?: boolean
    Require the exact permission level requested?
Returns boolean
Does the user have this permission level over the Compendium pack?

toJSON

toJSON(): object[]
Convert the Collection to a primitive array of its contents.

Returns object[]
An array of contained values

Inherited from DocumentCollection.toJSON

updateAll

updateAll(
    transformation: any,
    condition?: null,
    options?: {},
): Promise<TDocument[]>
Update all objects in this DocumentCollection with a provided transformation. Conditionally filter to only apply to Entities which match a certain condition.
Parameters
- transformation: any
  An object of data or function to apply to all matched objects
- condition: null = null
  A function which tests whether to target each object
- options: {} = {}
  Additional options passed to Document.updateDocuments
Returns Promise<TDocument[]>
An array of updated data once the operation is complete

Overrides DocumentCollection.updateAll

`Protected`_initialize

_initialize(): void
Protected
Initialize the DocumentCollection by constructing any initially provided Document instances

Returns void
Inherited from DocumentCollection._initialize

`Static`_activateSocketListeners

_activateSocketListeners(socket: Socket): void
Internal
Activate the Socket event listeners used to receive responses to compendium management events.
Parameters
- socket: Socket
  The active game socket.
Returns void

`Static`_onConfigure

_onConfigure(config: WorldCompendiumConfiguration): void
Handle changes to the world compendium configuration setting.
Parameters
- config: WorldCompendiumConfiguration
Returns void

`Static`createCompendium

createCompendium(
metadata: object,
options?: object,
): Promise<CompendiumCollection<any>>
Create a new Compendium Collection using provided metadata.
Parameters
- metadata: object
  The compendium metadata used to create the new pack
- options: object = {}
  Additional options which modify the Compendium creation request
Returns Promise<CompendiumCollection<any>>

`Static`getSearchableFields

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

Inherited from DocumentCollection.getSearchableFields

Class CompendiumCollection<TDocument>

Hook Events

Template: TDocument

See

Type Parameters

Hierarchy (View Summary)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns CompendiumCollection<TDocument>

Properties

Internal_source

applicationClass

apps

index

invalidDocumentIds

metadata

StaticCACHE_LIFETIME_SECONDS

StaticCONFIG_SETTING

StaticdocumentName

Accessors

banner

Returns string | void | null

collection

Returns string

config

Returns object

contents

Returns V[]

documentClass

Returns typeof Document

documentName

Returns any

Inherit Doc

folder

Returns documents.Folder | null

indexed

Returns boolean

indexFields

Returns Set<string>

locked

Returns boolean

maxFolderDepth

Returns number

name

Returns string

ownership

Returns Record< "PLAYER" | "TRUSTED" | "ASSISTANT" | "GAMEMASTER", "INHERIT" | "NONE" | "LIMITED" | "OBSERVER" | "OWNER",>

sort

Returns number

title

Returns string

visible

Returns boolean

StaticCONFIG_FIELD

Returns TypedObjectField

Methods

_getVisibleTreeContents

Returns any

_onModifyContents

Parameters

Returns void

_prepareImportDocument

Parameters

Returns any

[iterator]

Returns MapIterator<TDocument>

clear

Returns void

Inherit Doc

configure

Parameters

Returns Promise<void>

configureOwnershipDialog

`Internal`_source

`Static`CACHE_LIFETIME_SECONDS

`Static`CONFIG_SETTING

`Static`documentName

Returns Record<
"PLAYER"
| "TRUSTED"
| "ASSISTANT"
| "GAMEMASTER",
"INHERIT" | "NONE" | "LIMITED" | "OBSERVER" | "OWNER",
>

`Static`CONFIG_FIELD

`Optional`fields?: string[]

`Optional`strict?: boolean

`Optional`strict?: boolean

`Optional`folderId?: string | null

`Optional`folderName?: string