@league-of-foundry-developers/foundry-vtt-types 0.8.9-7 → 0.8.9-8

package/src/foundry/foundry.js/clientDatabaseBackend.d.ts

@@ -0,0 +1,210 @@
+import type { ConfiguredDocumentClassForName } from '../../types/helperTypes';
+import type { Request } from '../common/abstract/backend.mjs';
+import type Document from '../common/abstract/document.mjs';
+
+declare global {
+  /**
+   * The client-side database backend implementation which handles Document modification operations.
+   */
+  class ClientDatabaseBackend extends foundry.abstract.DatabaseBackend {
+    /**
+     * Activate the Socket event listeners used to receive responses from events which modify database documents
+     * @param socket - The active game socket
+     */
+    activateSocketListeners(socket: io.Socket): void;
+
+    /** @override */
+    protected _getDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * @override
+     * @remarks
+     * Get operations for embedded Documents are currently un-supported.
+     * The returned promise always rejects.
+     */
+    protected _getEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<never>;
+
+    /** @override */
+    protected _createDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _createEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-creation workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preCreateDocumentArray<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      {
+        data,
+        options,
+        pack,
+        parent,
+        user
+      }: Pick<Request, 'data' | 'pack' | 'parent' | 'options'> & {
+        user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
+      }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were created
+     * @param response - The provided Socket response
+     * @returns An Array of created Document instances
+     */
+    protected _handleCreateDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were created
+     * @param response - The provided Socket response
+     * @returns An Array of created Document instances
+     */
+    protected _handleCreateEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-creation workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform once every Document is created
+     * @internal
+     */
+    protected _postCreateDocumentCallbacks(
+      type: string,
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId, parent, pack }: Pick<Request, 'options' | 'parent' | 'pack'> & { userId?: string }
+    ): (() => void)[];
+
+    /** @override */
+    protected _updateDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _updateEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-update workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preUpdateDocumentArray<T extends Document<any, any>>(
+      collection: Collection<T>,
+      {
+        updates,
+        options,
+        user
+      }: Pick<Request, 'updates' | 'options'> & {
+        user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
+      }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were updated
+     * @param response - The provided Socket response
+     * @returns An Array of updated Document instances
+     */
+    protected _handleUpdateDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when embedded Documents are updated in a parent Document.
+     * @param response - The provided Socket response
+     * @returns An Array of updated Document instances
+     */
+    protected _handleUpdateEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-update workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform after every Document is updated
+     * @internal
+     */
+    protected _postUpdateDocumentCallbacks(
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId }: Pick<Request, 'options'> & { userId?: string }
+    ): () => void;
+
+    /** @override */
+    protected _deleteDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _deleteEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-delete workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preDeleteDocumentArray<T extends Document<any, any>>(
+      collection: Collection<T>,
+      {
+        ids,
+        options,
+        user
+      }: Pick<Request, 'ids' | 'options'> & { user: InstanceType<ConfiguredDocumentClassForName<'User'>> }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server where Documents are deleted.
+     * @param response - The provided Socket response
+     * @returns An Array of deleted Document instances
+     */
+    protected _handleDeleteDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when embedded Documents are deleted from a parent Document.
+     * @param response - The provided Socket response
+     * @returns An Array of deleted Document instances
+     */
+    protected _handleDeleteEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-deletion workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform after every Document is deleted
+     * @internal
+     */
+    protected _postDeleteDocumentCallbacks(
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId }: Pick<Request, 'options'> & { userId?: string }
+    ): (() => void)[];
+
+    /** @override */
+    getFlagScopes(): string[];
+
+    /** @override */
+    getCompendiumScopes(): string[];
+  }
+}
+
+export {};

package/src/foundry/foundry.js/clientDocuments/canvasDocuments/tokenDocument.d.ts

@@ -204,7 +204,7 @@ declare global {
     /**
      * Inspect the Actor data model and identify the set of attributes which could be used for a Token Bar
      */
-    static getTrackedAttributeChoices(attributes?: TrackedAttributes): Partial<Record<string, string[]>>;
+    static getTrackedAttributeChoices(attributes?: TrackedAttributes): Record<string, string[]>;
   }
 }
 

package/src/foundry/foundry.js/clientDocuments/index.d.ts

@@ -11,6 +11,7 @@ import './journalEntry';
 import './macro';
 import './playlist';
 import './playlistSound';
+import './prototypeToken';
 import './rollTable';
 import './scene';
 import './setting';

package/src/foundry/foundry.js/clientDocuments/prototypeToken.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An extended Document definition used specifically
+ * This ensures that the PrototypeTokenData schema is used instead of the standard TokenData.
+ * This exists specifically for prototype Token configuration in the TokenConfig app and should not be used otherwise.
+ * @internal
+ * @remarks The types for this are incorrect, in particular everything related to the data should use
+ * {@link foundry.data.PrototypeTokenData} instead of {@link foundry.data.TokenData}. However, with the current approach
+ * to type documents, we don't see a way to do this. This class is just added for reference. As the documentation above
+ * says, don't use it (there really shouldn't be a need to do so).
+ */
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+declare class PrototypeTokenDocument extends TokenDocument {
+  static get schema(): typeof foundry.data.PrototypeTokenData;
+}

package/src/foundry/foundry.js/clientSettings.d.ts

@@ -219,7 +219,7 @@ declare namespace ClientSettings {
   }
 
   interface Values {
-    'core.combatTrackerConfig': { resource: string; skipDefeated: boolean };
+    'core.combatTrackerConfig': { resource: string; skipDefeated: boolean } | {};
     'core.compendiumConfiguration': Partial<Record<string, CompendiumCollection.Configuration>>;
     'core.rollMode': foundry.CONST.DiceRollMode;
     'core.animateRollTable': boolean;
@@ -229,6 +229,19 @@ declare namespace ClientSettings {
     'core.globalPlaylistVolume': number;
     'core.globalAmbientVolume': number;
     'core.globalInterfaceVolume': number;
+    'core.moduleConfiguration': Record<string, boolean>;
+    'core.chatBubbles': boolean;
+    'core.chatBubblesPan': boolean;
+    'core.coneTemplateType': 'round' | 'flat';
+    'core.language': string;
+    'core.leftClickRelease': boolean;
+    'core.lightAnimation': boolean;
+    'core.maxFPS': number;
+    'core.mipmap': boolean;
+    'core.noCanvas': boolean;
+    'core.softShadows': boolean;
+    'core.tokenDragPreview': boolean;
+    'core.visionAnimation': boolean;
     [key: string]: unknown;
   }
 }

package/src/foundry/foundry.js/collections/documentCollections/compendiumCollection.d.ts

@@ -1,5 +1,4 @@
 import { ConfiguredDocumentClassForName, ConstructorDataType } from '../../../../types/helperTypes';
-import { IdQuery } from '../../../common/abstract/backend.mjs';
 import { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
 
 declare global {
@@ -25,6 +24,12 @@ declare global {
     /** A debounced function which will clear the contents of the Compendium pack if it is not accessed frequently. */
     _flush: () => void;
 
+    /**
+     * Has this Compendium pack been fully indexed?
+     * @defaultValue `false`
+     */
+    indexed: boolean;
+
     /**
      * 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.
@@ -37,6 +42,32 @@ declare global {
      */
     static CONFIG_SETTING: 'compendiumConfiguration';
 
+    /**
+     * The default index fields which should be retrieved for each Compendium document type
+     */
+    static INDEX_FIELDS: {
+      /** @defaultValue `["name", "img", "type"]` */
+      Actor: (keyof foundry.data.ActorData['_source'])[];
+
+      /** @defaultValue `["name", "img", "type"]` */
+      Item: (keyof foundry.data.ItemData['_source'])[];
+
+      /** @defaultValue `["name", "thumb"]` */
+      Scene: (keyof foundry.data.SceneData['_source'])[];
+
+      /** @defaultValue `["name", "img"]` */
+      JournalEntry: (keyof foundry.data.JournalEntryData['_source'])[];
+
+      /** @defaultValue `["name", "img"]` */
+      Macro: (keyof foundry.data.MacroData['_source'])[];
+
+      /** @defaultValue `["name", "img"]` */
+      RollTable: (keyof foundry.data.RollTableData['_source'])[];
+
+      /** @defaultValue `["name"]` */
+      Playlist: (keyof foundry.data.PlaylistData['_source'])[];
+    };
+
     /** The canonical Compendium name - comprised of the originating package and the pack name */
     get collection(): string;
 
@@ -64,8 +95,11 @@ declare global {
 
     delete: (id: string) => boolean;
 
-    /** Load the Compendium index and cache it as the keys and values of the Collection. */
-    getIndex(): Promise<this['index']>;
+    /**
+     * Load the Compendium index and cache it as the keys and values of the Collection.
+     * @param options - Options which customize how the index is created
+     */
+    getIndex(options?: CompendiumCollection.GetIndexOptions<T>): Promise<this['index']>;
 
     /**
      * Get a single Document from this Compendium by ID.
@@ -81,7 +115,7 @@ declare global {
      *                default: `{}`
      * @returns The retrieved Document instances
      */
-    getDocuments(query?: IdQuery): Promise<StoredDocument<DocumentInstanceForCompendiumMetadata<T>>[]>;
+    getDocuments(query?: Record<string, unknown>): Promise<StoredDocument<DocumentInstanceForCompendiumMetadata<T>>[]>;
 
     /**
      * Import a Document into this Compendium Collection.
@@ -236,6 +270,11 @@ declare global {
       package: string;
       system?: string;
     }
+
+    interface GetIndexOptions<T extends CompendiumCollection.Metadata> {
+      /** An array of fields to return as part of the index */
+      fields?: (keyof DocumentInstanceForCompendiumMetadata<T>['data']['_source'])[];
+    }
   }
 }
 
@@ -266,11 +305,5 @@ type DocumentInstanceForCompendiumMetadata<T extends CompendiumCollection.Metada
 >;
 
 type IndexTypeForMetadata<T extends CompendiumCollection.Metadata> = foundry.utils.Collection<
-  Pick<
-    StoredDocument<DocumentInstanceForCompendiumMetadata<T>>['data'],
-    | '_id'
-    | 'name'
-    | ('img' extends keyof StoredDocument<DocumentInstanceForCompendiumMetadata<T>>['data'] ? 'img' : never)
-    | ('type' extends keyof StoredDocument<DocumentInstanceForCompendiumMetadata<T>>['data'] ? 'type' : never)
-  >
+  { _id: string } & Partial<DocumentInstanceForCompendiumMetadata<T>['data']['_source']>
 >;

package/src/foundry/foundry.js/config.d.ts

@@ -1,5 +1,4 @@
 import { DocumentConstructor, PlaceableObjectConstructor } from '../../types/helperTypes';
-import DatabaseBackend from '../common/abstract/backend.mjs';
 
 type ConfiguredDocumentClassOrDefault<Fallback extends DocumentConstructor> =
   Fallback['metadata']['name'] extends keyof DocumentClassConfig
@@ -230,7 +229,7 @@ declare global {
      * Configure the DatabaseBackend used to perform Document operations
      * @defaultValue `new ClientDatabaseBackend()`
      */
-    DatabaseBackend: DatabaseBackend; // TODO: ClientDatabaseBackend
+    DatabaseBackend: ClientDatabaseBackend;
 
     /**
      * Configuration for the Actor document
@@ -249,7 +248,7 @@ declare global {
       /**
        * @defaultValue `{}`
        */
-      sheetClasses: EntitySheetConfig.SheetClasses;
+      sheetClasses: CONFIG.SheetClasses;
 
       /**
        * @defaultValue `'fas fa-user'`
@@ -444,7 +443,7 @@ declare global {
       /**
        * @defaultValue `{}`
        */
-      sheetClasses: EntitySheetConfig.SheetClasses;
+      sheetClasses: CONFIG.SheetClasses;
 
       /**
        * @defaultValue `'fas fa-suitcase'`
@@ -1983,6 +1982,15 @@ declare global {
         [key: string]: ConstructorOf<CanvasLayer>;
       }
     }
+
+    interface SheetClass {
+      id: string;
+      cls: ConstructorOf<FormApplication>;
+      label: string;
+      default: boolean;
+    }
+
+    type SheetClasses = Record<string, Record<string, SheetClass>>;
   }
 
   const CONFIG: CONFIG;

package/src/foundry/foundry.js/dragDrop.d.ts

@@ -8,7 +8,7 @@
  * const dragDrop = new DragDrop({
  *   dragSelector: ".item",
  *   dropSelector: ".items",
- *   permissions: { dragstart: this._canDragStart.bind(this), drop: this._canDragDrop.bind(this) }
+ *   permissions: { dragstart: this._canDragStart.bind(this), drop: this._canDragDrop.bind(this) },
  *   callbacks: { dragstart: this._onDragStart.bind(this), drop: this._onDragDrop.bind(this) }
  * });
  * dragDrop.bind(html);
@@ -17,9 +17,9 @@
 declare class DragDrop {
   /**
    * @param dragSelector - The CSS selector used to target draggable elements.
-   *                       (default: `null`)
+   *                       (default: `undefined`)
    * @param dropSelector - The CSS selector used to target viable drop targets.
-   *                       (default: `null`)
+   *                       (default: `undefined`)
    * @param permissions  - An object of permission test functions for each action
    *                       (default: `{}`)
    * @param callbacks    - An object of callback functions for each action
@@ -29,27 +29,27 @@ declare class DragDrop {
 
   /**
    * The HTML selector which identifies draggable elements
-   * @defaultValue `null`
+   * @defaultValue `undefined`
    */
-  dragSelector: string | null;
+  dragSelector: string | undefined;
 
   /**
    * The HTML selector which identifies drop targets
-   * @defaultValue `null`
+   * @defaultValue `undefined`
    */
-  dropSelector: string | null;
+  dropSelector: string | undefined;
 
   /**
    * A set of permission checking functions for each action of the Drag and Drop workflow
    * @defaultValue `{}`
    */
-  permissions: Partial<Record<string, (selector: string | null) => boolean>>;
+  permissions: Partial<Record<DragDrop.Action, (selector: string | undefined) => boolean>>;
 
   /**
    * A set of callback functions for each action of the Drag and Drop workflow
    * @defaultValue `{}`
    */
-  callbacks: Partial<Record<string, (event: DragEvent) => unknown>>;
+  callbacks: Partial<Record<DragDrop.Action, (event: DragEvent) => void>>;
 
   /**
    * Bind the DragDrop controller to an HTML application
@@ -62,7 +62,7 @@ declare class DragDrop {
    * @param event  - The drag event being handled
    * @param action - The action being attempted
    */
-  callback(event: DragEvent, action: string): unknown;
+  callback(event: DragEvent, action: DragDrop.Action): void;
 
   /**
    * Test whether the current user has permission to perform a step of the workflow
@@ -70,40 +70,41 @@ declare class DragDrop {
    * @param selector - The selector being targeted
    * @returns Can the action be performed?
    */
-  can(action: string, selector: string | null): boolean;
+  can(action: DragDrop.Action, selector: string | undefined): boolean;
 
   /**
    * Handle the start of a drag workflow
    * @param event - The drag event being handled
+   * @internal
    */
   protected _handleDragStart(event: DragEvent): void;
 
   /**
    * Handle a dragged element over a droppable target
    * @param event - The drag event being handled
+   * @internal
    */
   protected _handleDragOver(event: DragEvent): false;
 
   /**
    * Handle a dragged element dropped on a droppable target
    * @param event - The drag event being handled
+   * @internal
    */
   protected _handleDrop(event: DragEvent): unknown;
 
-  static createDragImage(img: HTMLImageElement, width: number, height: number): HTMLDivElement | HTMLElement;
+  static createDragImage(img: HTMLImageElement, width: number, height: number): HTMLDivElement;
 }
 
 declare namespace DragDrop {
   interface Options {
     /**
      * The CSS selector used to target draggable elements.
-     * @defaultValue `null`
      */
     dragSelector?: DragDrop['dragSelector'];
 
     /**
      * The CSS selector used to target viable drop targets.
-     * @defaultValue `null`
      */
     dropSelector?: DragDrop['dropSelector'];
 
@@ -119,4 +120,6 @@ declare namespace DragDrop {
      */
     callbacks?: DragDrop['callbacks'];
   }
+
+  type Action = 'dragstart' | 'dragover' | 'drop';
 }

package/src/foundry/foundry.js/globalVariables.d.ts

@@ -15,6 +15,7 @@ declare global {
    * The currently supported variables are:
    * - {@link game}
    * - {@link socket}
+   * - {@link ui}
    * - {@link canvas}
    *
    * @example
@@ -64,9 +65,7 @@ declare global {
      * @defaultValue `{}`
      */
     windows: Record<number, Application>;
-  } & {
-    [Key in keyof CONFIG['ui']]?: InstanceType<CONFIG['ui'][Key]>;
-  };
+  } & ('ui' extends keyof LenientGlobalVariableTypes ? UiApplications : Partial<UiApplications>);
 
   /** The client-side console is the default logger  */
   let logger: typeof console;
@@ -115,7 +114,7 @@ declare global {
   let _token: InstanceType<CONFIG['Token']['objectClass']> | null;
 
   /*
-   * Global Vairables
+   * Global Variables
    * The following variables are declared directly in foundry's HTML file (or more concretely, in `main.hbs`)
    */
 
@@ -128,4 +127,8 @@ declare global {
     | null;
 }
 
+type UiApplications = {
+  [Key in keyof CONFIG['ui']]: InstanceType<CONFIG['ui'][Key]>;
+};
+
 export {};