@league-of-foundry-developers/foundry-vtt-types 0.8.9-6 → 9.238.0

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

@@ -1,13 +1,23 @@
-import { ConfiguredDocumentClass, ConstructorDataType, PropertiesToSource } from '../../../types/helperTypes';
+import { ConfiguredDocumentClass, PropertiesToSource } from '../../../types/helperTypes';
 import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
-import { AmbientLightDataProperties } from '../../common/data/data.mjs/ambientLightData';
-import { AmbientSoundDataProperties } from '../../common/data/data.mjs/ambientSoundData';
-import { DrawingDataProperties } from '../../common/data/data.mjs/drawingData';
-import { MeasuredTemplateDataProperties } from '../../common/data/data.mjs/measuredTemplateData';
-import { NoteDataProperties } from '../../common/data/data.mjs/noteData';
-import { TileDataProperties } from '../../common/data/data.mjs/tileData';
-import { TokenDataProperties } from '../../common/data/data.mjs/tokenData';
-import { WallDataProperties } from '../../common/data/data.mjs/wallData';
+import {
+  AmbientLightDataConstructorData,
+  AmbientLightDataProperties
+} from '../../common/data/data.mjs/ambientLightData';
+import {
+  AmbientSoundDataConstructorData,
+  AmbientSoundDataProperties
+} from '../../common/data/data.mjs/ambientSoundData';
+import { DrawingDataConstructorData, DrawingDataProperties } from '../../common/data/data.mjs/drawingData';
+import {
+  MeasuredTemplateDataConstructorData,
+  MeasuredTemplateDataProperties
+} from '../../common/data/data.mjs/measuredTemplateData';
+import { NoteDataConstructorData, NoteDataProperties } from '../../common/data/data.mjs/noteData';
+import type { SceneDataConstructorData } from '../../common/data/data.mjs/sceneData.js';
+import { TileDataConstructorData, TileDataProperties } from '../../common/data/data.mjs/tileData';
+import { TokenDataConstructorData, TokenDataProperties } from '../../common/data/data.mjs/tokenData';
+import { WallDataConstructorData, WallDataProperties } from '../../common/data/data.mjs/wallData';
 
 declare global {
   /**
@@ -94,10 +104,7 @@ declare global {
      * @param options    - (default: `{}`)
      */
     clone(
-      createData?: DeepPartial<
-        | ConstructorDataType<foundry.data.SceneData>
-        | (ConstructorDataType<foundry.data.SceneData> & Record<string, unknown>)
-      >,
+      createData?: DeepPartial<SceneDataConstructorData | (SceneDataConstructorData & Record<string, unknown>)>,
       options?: { save?: boolean; keepId?: boolean }
     ): TemporaryDocument<this> | Promise<TemporaryDocument<this | undefined>>;
 
@@ -106,7 +113,7 @@ declare global {
 
     /** @override */
     protected _preCreate(
-      data: ConstructorDataType<foundry.data.SceneData>,
+      data: SceneDataConstructorData,
       options: DocumentModificationOptions,
       user: foundry.documents.BaseUser
     ): Promise<void>;
@@ -120,7 +127,7 @@ declare global {
 
     /** @override */
     protected _preUpdate(
-      changed: DeepPartial<ConstructorDataType<foundry.data.SceneData>>,
+      changed: DeepPartial<SceneDataConstructorData>,
       options: DocumentModificationOptions,
       user: foundry.documents.BaseUser
     ): Promise<void>;
@@ -147,49 +154,49 @@ declare global {
     /** @override */
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.DrawingData>[],
+      result: DrawingDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.TokenData>[],
+      result: TokenDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.AmbientLightData>[],
+      result: AmbientLightDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.NoteData>[],
+      result: NoteDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.AmbientSoundData>[],
+      result: AmbientSoundDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.MeasuredTemplateData>[],
+      result: MeasuredTemplateDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.TileData>[],
+      result: TileDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;
     _preCreateEmbeddedDocuments(
       embeddedName: string,
-      result: ConstructorDataType<foundry.data.WallData>[],
+      result: WallDataConstructorData[],
       options: DocumentModificationOptions,
       userId: string
     ): void;

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

@@ -0,0 +1,299 @@
+/**
+ * A class responsible for managing defined game keybinding.
+ * Each keybinding is a string key/value pair belonging to a certain namespace and a certain store scope.
+ *
+ * When Foundry Virtual Tabletop is initialized, a singleton instance of this class is constructed within the global
+ * Game object as as game.keybindings.
+ *
+ * @see {@link Game#keybindings}
+ * @see {@link SettingKeybindingConfig}
+ * @see {@link KeybindingsConfig}
+ */
+declare class ClientKeybindings {
+  constructor();
+
+  /** Registered Keybinding actions */
+  actions: Map<string, KeybindingActionConfig>;
+
+  /** A mapping of a string key to possible Actions that might execute off it */
+  activeKeys: Map<string, KeybindingAction[]>;
+
+  /**
+   * A stored cache of Keybind Actions Ids to Bindings
+   * @remarks This is only undefined before the "ready" hook.
+   */
+  bindings: Map<string, KeybindingActionBinding[]> | undefined;
+
+  /**
+   * A count of how many registered keybindings there are
+   * @internal
+   * @defaultValue `0`
+   */
+  protected _registered: number;
+
+  /**
+   * A timestamp which tracks the last time a pan operation was performed
+   * @internal
+   * @defaultValue `0`
+   */
+  protected _moveTime: number;
+
+  static MOVEMENT_DIRECTIONS: ClientKeybindings.MovementDirections;
+
+  static ZOOM_DIRECTIONS: ClientKeybindings.ZoomDirections;
+
+  /**
+   * An alias of the movement key set tracked by the keyboard
+   */
+  get moveKeys(): Set<string>;
+
+  /** Initializes the keybinding values for all registered actions */
+  initialize(): void;
+
+  /**
+   * Register a new keybinding
+   *
+   * @param namespace - The namespace the Keybinding Action belongs to
+   * @param action    - A unique machine-readable id for the Keybinding Action
+   * @param data      - Configuration for keybinding data
+   *
+   * @example <caption>Define a keybinding which shows a notification</caption>
+   * ```typescript
+   * game.keybindings.register("myModule", "showNotification", {
+   *   name: "My Settings Keybinding",
+   *   hint: "A description of what will occur when the Keybinding is executed.",
+   *   uneditable: [
+   *     {
+   *       key: "Digit1",
+   *       modifiers: ["Control"]
+   *     }
+   *   ],
+   *   editable: [
+   *     {
+   *       key: "F1"
+   *     }
+   *   ],
+   *   onDown: () => { ui.notifications.info("Pressed!") },
+   *   onUp: () => {},
+   *   restricted: true,                         // Restrict this Keybinding to gamemaster only?
+   *   reservedModifiers: ["Alt""],              // If the ALT modifier is pressed, the notification is permanent instead of temporary
+   *   precedence: CONST.KEYBINDING_PRECEDENCE.NORMAL
+   * }
+   * ```
+   * @throws if called after `this.bindings` has been initialized.
+   */
+  register(namespace: string, action: string, data: KeybindingActionConfig): void;
+
+  /**
+   * Get the current Bindings of a given namespace's Keybinding Action
+   *
+   * @param namespace - The namespace under which the setting is registered
+   * @param action    - The keybind action to retrieve
+   *
+   * @example <caption>Retrieve the current Keybinding Action Bindings</caption>
+   * ```typescript
+   * game.keybindings.get("myModule", "showNotification");
+   * ```
+   */
+  get(namespace: string, action: string): KeybindingActionBinding[];
+
+  /**
+   * Set the editable Bindings of a Keybinding Action for a certain namespace and Action
+   *
+   * @param namespace - The namespace under which the Keybinding is registered
+   * @param action    - The Keybinding action to set
+   * @param bindings  - The Bindings to assign to the Keybinding
+   *
+   * @example <caption>Update the current value of a keybinding</caption>
+   * ```typescript
+   * game.keybindings.set("myModule", "showNotification", [
+   *     {
+   *       key: "F2",
+   *       modifiers: [ "CONTROL" ]
+   *     }
+   * ]);
+   * ```
+   * @remarks Passing `undefined` or nothing as `bindings` resets to the default.
+   */
+  set(namespace: string, action: string, bindings?: KeybindingActionBinding[] | undefined): Promise<void>;
+
+  /** Reset all client keybindings back to their default configuration. */
+  resetDefaults(): Promise<void>;
+
+  /**
+   * A helper method that, when given a value, ensures that the returned value is a standardized Binding array
+   * @param values - An array of keybinding assignments to be validated
+   * @returns An array of keybinding assignments confirmed as valid
+   * @internal
+   */
+  protected static _validateBindings(values: Array<KeybindingActionBinding>): Array<Required<KeybindingActionBinding>>;
+
+  /**
+   * Validate that assigned modifiers are allowed
+   * @param keys - An array of modifiers which may be valid
+   * @returns An array of modifiers which are confirmed as valid
+   * @internal
+   */
+  protected static _validateModifiers(keys: string[]): string[];
+
+  /**
+   * Compares two Keybinding Actions based on their Order
+   * @param a - The first Keybinding Action
+   * @param b - the second Keybinding Action
+   */
+  protected static _compareActions(a: KeybindingAction, b: KeybindingAction): number;
+
+  /** Register core keybindings */
+  protected _registerCoreKeybindings(): void;
+
+  /**
+   * Handle Select all action
+   * @param event   - The originating keyboard event
+   *                  (unused)
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onSelectAllObjects(event?: KeyboardEvent, context?: KeyboardEventContext): boolean;
+
+  /**
+   * Handle Cycle View actions
+   * @param context - The context data of the event
+   * @internal
+   */
+  protected static _onCycleView(context: KeyboardEventContext): boolean;
+
+  /**
+   * Handle Dismiss actions
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onDismiss(context?: KeyboardEventContext): boolean;
+
+  /**
+   * Open Character sheet for current token or controlled actor
+   * @param event   - (unused)
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onToggleCharacterSheet(event?: KeyboardEvent, context?: KeyboardEventContext): ActorSheet | null;
+
+  /**
+   * Handle action to target the currently hovered token.
+   * @param context - The context data of the event
+   * @internal
+   */
+  protected static _onTarget(context: KeyboardEventContext): boolean;
+
+  /**
+   * Handle DELETE Keypress Events
+   * @param event   - The originating keyboard event
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onDelete(event: KeyboardEvent, context?: KeyboardEventContext): boolean;
+
+  /**
+   * Handle keyboard movement once a small delay has elapsed to allow for multiple simultaneous key-presses.
+   * @param context - The context data of the event
+   * @param layer   - The Placeables layer
+   * @internal
+   */
+  protected _handleMovement(context: KeyboardEventContext, layer: TokenLayer | BackgroundLayer): void;
+
+  /** Handle panning the canvas using CTRL + directional keys */
+  protected _handleCanvasPan(): ReturnType<Canvas['animatePan']>;
+
+  /**
+   * Handle Measured Ruler Movement Action
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onMeasuredRulerMovement(context?: KeyboardEventContext): boolean | void;
+
+  /**
+   * Handle Pause Action
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onPause(context?: KeyboardEventContext): true;
+
+  /**
+   * Handle Highlight action
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onHighlight(context?: KeyboardEventContext): boolean;
+
+  /**
+   * Handle Pan action
+   * @param context            - The context data of the event
+   * @param movementDirections - The Directions being panned in
+   * @internal
+   */
+  protected _onPan(context: KeyboardEventContext, movementDirections: ClientKeybindings.MovementDirection[]): boolean;
+
+  /**
+   * Handle number key presses
+   * @param context - The context data of the event
+   * @internal
+   */
+  protected static _onMacro(context: KeyboardEventContext): true;
+
+  /**
+   * Handle action to copy data to clipboard
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onCopy(context?: KeyboardEventContext): boolean;
+
+  /**
+   * Handle Paste action
+   * @param context - The context data of the event
+   * @internal
+   */
+  protected static _onPaste(context: KeyboardEventContext): boolean;
+
+  /**
+   * Handle Undo action
+   * @param context - The context data of the event
+   *                  (unused)
+   * @internal
+   */
+  protected static _onUndo(context?: KeyboardEventContext): boolean;
+
+  /**
+   * Handle presses to keyboard zoom keys
+   * @param context       - The context data of the event
+   *                        (unused)
+   * @param zoomDirection - The direction to zoom
+   * @internal
+   */
+  protected static _onZoom(
+    context: KeyboardEventContext | unknown,
+    zoomDirection: ClientKeybindings.ZoomDirection
+  ): boolean;
+}
+
+declare namespace ClientKeybindings {
+  type MovementDirections = {
+    UP: 'up';
+    LEFT: 'left';
+    DOWN: 'down';
+    RIGHT: 'right';
+  };
+  type MovementDirection = ValueOf<MovementDirections>;
+
+  type ZoomDirections = {
+    IN: 'in';
+    OUT: 'out';
+  };
+  type ZoomDirection = ValueOf<ZoomDirections>;
+}

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

@@ -219,16 +219,31 @@ declare namespace ClientSettings {
   }
 
   interface Values {
-    'core.combatTrackerConfig': { resource: string; skipDefeated: boolean };
-    'core.compendiumConfiguration': Partial<Record<string, CompendiumCollection.Configuration>>;
-    'core.rollMode': foundry.CONST.DiceRollMode;
     'core.animateRollTable': boolean;
-    'core.permissions': Game.Permissions;
+    'core.chatBubbles': boolean;
+    'core.chatBubblesPan': boolean;
+    'core.combatTrackerConfig': { resource: string; skipDefeated: boolean } | {};
+    'core.compendiumConfiguration': Partial<Record<string, CompendiumCollection.Configuration>>;
+    'core.coneTemplateType': 'round' | 'flat';
     'core.defaultDrawingConfig': foundry.data.DrawingData['_source'] | {};
-    'core.time': number;
-    'core.globalPlaylistVolume': number;
     'core.globalAmbientVolume': number;
     'core.globalInterfaceVolume': number;
+    'core.globalPlaylistVolume': number;
+    'core.keybindings': Record<string, KeybindingActionBinding[]>;
+    'core.language': string;
+    'core.leftClickRelease': boolean;
+    'core.lightAnimation': boolean;
+    'core.maxFPS': number;
+    'core.mipmap': boolean;
+    'core.moduleConfiguration': Record<string, boolean>;
+    'core.nue.shownTips': boolean;
+    'core.noCanvas': boolean;
+    'core.permissions': Game.Permissions;
+    'core.rollMode': foundry.CONST.DICE_ROLL_MODES;
+    'core.softShadows': boolean;
+    'core.time': number;
+    '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'])[];
+    }
   }
 }
 
@@ -247,7 +286,7 @@ interface ImportAllOptions {
   folderId?: string | null;
   /**
    * A new Folder name to create.
-   * @defaultValue `''`
+   * @defaultValue `""`
    * */
   folderName?: string;
   /**
@@ -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/collections/documentCollections/worldCollections/cardStacks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The collection of Cards documents which exist within the active World.
+ * This Collection is accessible within the Game object as game.cards.
+ * @see {@link Cards} The Cards document
+ */
+declare class CardStacks extends WorldCollection<typeof foundry.documents.BaseCards, 'Cards'> {
+  /** @override */
+  static documentName: 'Cards';
+}

package/src/foundry/foundry.js/collections/documentCollections/worldCollections/index.d.ts

@@ -1,4 +1,5 @@
 import './actors';
+import './cardStacks';
 import './combatEncounters';
 import './fogExplorations';
 import './folders';

package/src/foundry/foundry.js/collections/documentCollections/worldCollections/playlists.d.ts

@@ -1,4 +1,5 @@
-import { ConfiguredDocumentClass, ConstructorDataType } from '../../../../../types/helperTypes';
+import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { SceneDataConstructorData } from '../../../../common/data/data.mjs/sceneData.js';
 
 declare global {
   /**
@@ -35,7 +36,7 @@ declare global {
      */
     protected _onChangeScene(
       scene: StoredDocument<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseScene>>>,
-      data: DeepPartial<ConstructorDataType<foundry.documents.BaseScene['data']>>
+      data: DeepPartial<SceneDataConstructorData>
     ): Promise<void>;
   }
 }