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

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

@@ -8,144 +8,174 @@ declare class KeyboardManager {
   /**
    * The set of key codes which are currently depressed (down)
    */
-  protected _downKeys: Set<string>;
+  downKeys: Set<string>;
 
   /**
-   * The set of key codes which have been already handled per workflow
+   * The set of movement keys which were recently pressed
    */
-  protected _handled: Set<string>;
+  moveKeys: Set<string>;
 
   /**
-   * A mapping of movement keys which are pending
+   * Allowed modifier keys
    */
-  protected _moveKeys: Set<string>;
-
-  /**
-   * @defaultValue `null`
-   */
-  protected _moveTime: number | null;
-
-  /**
-   * @defaultValue `0`
-   */
-  protected _tabState: 0 | 1;
+  static MODIFIER_KEYS: {
+    CONTROL: 'Control';
+    SHIFT: 'Shift';
+    ALT: 'Alt';
+  };
 
   /**
-   * @defaultValue `0`
+   * Track which KeyboardEvent#code presses associate with each modifier
    */
-  protected _wheelTime: number;
+  static MODIFIER_CODES: {
+    Alt: ['AltLeft', 'AltRight'];
+    Control: ['ControlLeft', 'ControlRight', 'MetaLeft', 'MetaRight'];
+    Shift: ['ShiftLeft', 'ShiftRight'];
+  };
 
   /**
-   * Specify a rate limit for mouse wheel to gate repeated scrolling.
-   * This is especially important for continuous scrolling mice which emit hundreds of events per second.
-   * This designates a minimum number of milliseconds which must pass before another wheel event is handled
-   */
-  static MOUSE_WHEEL_RATE_LIMIT: 50;
+   * Key codes which are "protected" and should not be used because they are reserved for browser-level actions.
+   */
+  static PROTECTED_KEYS: ['F5', 'F11', 'F12', 'PrintScreen', 'ScrollLock', 'NumLock', 'CapsLock'];
+
+  /** The OS-specific string display for what their Command key is */
+  static CONTROL_KEY_STRING: '⌘' | 'Control';
+
+  /**
+   * An special mapping of how special KeyboardEvent#code values should map to displayed strings or symbols.
+   * Values in this configuration object override any other display formatting rules which may be applied.
+   */
+  static KEYCODE_DISPLAY_MAPPING: {
+    ArrowLeft: '🡸';
+    ArrowRight: '🡺';
+    ArrowUp: '🡹';
+    ArrowDown: '🡻';
+    Backquote: '`';
+    Backslash: '\\';
+    BracketLeft: '[';
+    BracketRight: ']';
+    Comma: ',';
+    Equal: '=';
+    MetaLeft: '⌘' | '⊞';
+    Minus: '-';
+    NumpadAdd: 'Numpad+';
+    NumpadSubtract: 'Numpad-';
+    Period: '.';
+    Quote: "'";
+    Semicolon: ';';
+    Slash: '/';
+  };
 
   /**
-   * Enumerate the "digit keys"
+   * Test whether a Form Element currently has focus
    */
-  static DIGIT_KEYS: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'];
+  get hasFocus(): boolean;
 
   /**
-   * Map keys used for movement
+   * Emulates a key being pressed, triggering the Keyboard event workflow.
+   * @param up       - If True, emulates the `keyup` Event. Else, the `keydown` event
+   * @param code     - The KeyboardEvent#code which is being pressed
+   * @param altKey   - Emulate the ALT modifier as pressed
+   *                   (default: `false`)
+   * @param ctrlKey  - Emulate the CONTROL modifier as pressed
+   *                   (default: `false`)
+   * @param shiftKey - Emulate the SHIFT modifier as pressed
+   *                   (default: `false`)
+   * @param repeat   - Emulate this as a repeat event
+   *                   (default: `false`)
    */
-  static MOVEMENT_KEYS: {
-    w: ['up'];
-    a: ['left'];
-    s: ['down'];
-    d: ['right'];
-    W: ['up'];
-    A: ['left'];
-    S: ['down'];
-    D: ['right'];
-    ArrowUp: ['up'];
-    ArrowRight: ['right'];
-    ArrowDown: ['down'];
-    ArrowLeft: ['left'];
-    Numpad1: ['down', 'left'];
-    Numpad2: ['down'];
-    Numpad3: ['down', 'right'];
-    Numpad4: ['left'];
-    Numpad6: ['right'];
-    Numpad7: ['up', 'left'];
-    Numpad8: ['up'];
-    Numpad9: ['up', 'right'];
-  };
+  static emulateKeypress(
+    up: boolean,
+    key: string,
+    {
+      altKey,
+      ctrlKey,
+      shiftKey,
+      repeat
+    }?: { altKey?: boolean; ctrlKey?: boolean; shiftKey?: boolean; repeat?: boolean }
+  ): KeyboardEventContext;
 
   /**
-   * Map keys used for canvas zooming
+   * Format a KeyboardEvent#code into a displayed string.
+   * @param code - The input code
+   * @returns The displayed string for this code
    */
-  static ZOOM_KEYS: {
-    PageUp: 'in';
-    PageDown: 'out';
-    NumpadAdd: 'in';
-    NumpadSubtract: 'out';
-  };
+  static getKeycodeDisplayString(code: string): string;
 
   /**
-   * Reset tracking for which keys are in the down and released states
+   * Get a standardized keyboard context for a given event.
+   * Every individual keypress is uniquely identified using the KeyboardEvent#code property.
+   * A list of possible key codes is documented here: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code/code_values
+   *
+   * @param event - The originating keypress event
+   * @param up    - A flag for whether the key is down or up
+   *                (default: `false`)
+   * @returns The standardized context of the event
    */
-  protected _reset(): void;
+  static getKeyboardEventContext(event: KeyboardEvent, up: boolean): KeyboardEventContext;
 
   /**
-   * Return whether the key code is currently in the DOWN state
-   * @param code - The key code to test
+   * Report whether a modifier in KeyboardManager.MODIFIER_KEYS is currently actively depressed.
+   * @param modifier - A modifier in MODIFIER_KEYS
+   * @returns Is this modifier key currently down (active)?
    */
-  isDown(code: string): boolean;
+  isModifierActive(modifier: string): boolean;
 
   /**
-   * A helper method to test whether, given an Event, the CTRL (or CMD) keys are pressed
-   * @param event - The originating event or canvas interaction
+   * Converts a Keyboard Context event into a string representation, such as "C" or "Control+C"
+   * @param context          - The standardized context of the event
+   * @param includeModifiers - If True, includes modifiers in the string representation
+   *                           (default: `true`)
+   * @internal
    */
-  isCtrl(event: Event | PIXI.InteractionEvent): boolean;
+  protected static _getContextDisplayString(context: KeyboardEventContext, includeModifiers?: boolean): string;
 
   /**
-   * Get a standardized keyboard code for a given event
-   * @param event - The originating keypress event
-   * @returns The standardized string code to use
+   * Given a standardized pressed key, find all matching registered Keybind Actions.
+   * @param context - A standardized keyboard event context
+   * @returns The matched Keybind Actions. May be empty.
    */
-  getKey(event: KeyboardEvent): string;
+  protected static _getMatchingActions(context: KeyboardEventContext): KeybindingAction[];
 
   /**
-   * The key codes which represent a possible movement key
+   * Test whether a keypress context matches the registration for a keybinding action
+   * @param action  - The keybinding action
+   * @param context - The keyboard event context
+   * @returns Does the context match the action requirements?
+   * @internal
    */
-  get moveKeys(): typeof KeyboardManager.MOVEMENT_KEYS;
+  protected static _testContext(action: KeybindingAction, context: KeyboardEventContext): boolean;
 
   /**
-   * The key codes which represent a digit key
+   * Given a registered Keybinding Action, executes the action with a given event and context
+   *
+   * @param keybind - The registered Keybinding action to execute
+   * @param context - The gathered context of the event
+   * @returns Returns true if the keybind was consumed
+   * @internal
    */
-  get digitKeys(): typeof KeyboardManager.DIGIT_KEYS;
+  protected static _executeKeybind(keybind: KeybindingAction, context: KeyboardEventContext): boolean;
 
   /**
-   * Return the key codes used for zooming the canvas
+   * Processes a keyboard event context, checking it against registered keybinding actions
+   * @param context - The keyboard event context
+   * @internal
    */
-  get zoomKeys(): typeof KeyboardManager.ZOOM_KEYS;
+  protected _processKeyboardContext(context: KeyboardEventContext): void;
 
   /**
-   * Test whether an input currently has focus
+   * Reset tracking for which keys are in the down and released states
+   * @internal
    */
-  get hasFocus(): boolean;
+  protected _reset(): void;
 
   /**
    * Handle a key press into the down position
    * @param event - The originating keyboard event
-   */
-  protected _onKeyDown(event: KeyboardEvent): void;
-
-  /**
-   * Handle a key release into the up position
-   * @param event - The originating keyboard event
-   */
-  protected _onKeyUp(event: KeyboardEvent): void;
-
-  /**
-   * Delegate tracked key codes by dispatching to their various handlers
-   * @param event - The keydown or keyup event
-   * @param key   - The key being depressed
    * @param up    - A flag for whether the key is down or up
+   * @internal
    */
-  protected _handleKeys(event: KeyboardEvent, key: string, up: boolean): void;
+  protected _handleKeyboardEvent(event: KeyboardEvent, up: boolean): void;
 
   /**
    * Input events do not fire with isComposing = false at the end of a composition event in Chrome
@@ -153,143 +183,65 @@ declare class KeyboardManager {
    */
   protected _onCompositionEnd(event: CompositionEvent): void;
 
-  /**
-   * Master mouse-wheel event keyboard handler
-   */
-  protected _onWheel(event: WheelEvent): void;
-
-  /**
-   * Handle TAB keypress events
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onTab(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
+  /** @deprecated since v9, will be removed in v10 */
+  static get MOUSE_WHEEL_RATE_LIMIT(): number;
 
   /**
-   * Handle ESC keypress events
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onEscape(
-    event: KeyboardEvent,
-    up: boolean,
-    modifiers: KeyboardManager.MetaModifiers
-  ): void | Promise<void>;
-
-  /**
-   * Handle SPACE keypress events
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onSpace(
-    event: KeyboardEvent,
-    up: boolean,
-    modifiers: KeyboardManager.MetaModifiers
-  ): void | ReturnType<Set<string>['add']>;
-
-  /**
-   * Handle ALT keypress events
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onAlt(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
-
-  /**
-   * Handle movement keypress events
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onMovement(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
-
-  /**
-   * Handle keyboard movement once a small delay has elapsed to allow for multiple simultaneous key-presses.
+   * @deprecated since V9, will be removed in V10
+   * Return whether the key code is currently in the DOWN state
+   * @param code - The key code to test
    */
-  protected _handleMovement(event: KeyboardEvent, layer: PlaceablesLayer<any>): void;
+  isDown(code: string): boolean;
 
-  /**
-   * Handle panning the canvas using CTRL + directional keys
-   */
-  protected _handleCanvasPan(): ReturnType<Canvas['animatePan']>;
+  /** @deprecated since v9, will be removed in v10 */
+  static isControl(event: KeyboardEvent | PIXI.InteractionEvent): boolean;
 
   /**
-   * Handle number key presses
-   * @param event     - The original digit key press
-   *                    (unused)
-   * @param up        - Is it a keyup?
-   * @param modifiers - What modifiers affect the keypress?
+   * @deprecated since v9, will be removed in v10
+   * @see KeyboardManager.isControl
    */
-  protected _onDigit(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
+  isCtrl(event: Event | PIXI.InteractionEvent): boolean;
 
-  /**
-   * Handle "A" keypress events (CTRL only) to select all objects
-   * @param event     - The originating keyboard event
-   *                    (unused)
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onKeyA(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
+  /** @deprecated since v9, will be removed in v10 */
+  get _downKeys(): Set<string>;
 
-  /**
-   * Handle "C" keypress events to copy data to clipboard
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onKeyC(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
+  /** @deprecated since v9, will be removed in v10 */
+  static DIGIT_KEYS: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'];
 
-  /**
-   * Handle "V" keypress events to paste data from clipboard
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onKeyV(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
+  /** @deprecated since v9, will be removed in v10 */
+  static MOVEMENT_KEYS: {
+    W: ['up'];
+    A: ['left'];
+    S: ['down'];
+    D: ['right'];
+    ARROWUP: ['up'];
+    ARROWRIGHT: ['right'];
+    ARROWDOWN: ['down'];
+    ARROWLEFT: ['left'];
+    NUMPAD1: ['down', 'left'];
+    NUMPAD2: ['down'];
+    NUMPAD3: ['down', 'right'];
+    NUMPAD4: ['left'];
+    NUMPAD6: ['right'];
+    NUMPAD7: ['up', 'left'];
+    NUMPAD8: ['up'];
+    NUMPAD9: ['up', 'right'];
+  };
 
-  /**
-   * Handle Z Keypress Events to generally undo previous actions
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onKeyZ(event: KeyboardEvent, up: boolean, modifiers: KeyboardManager.MetaModifiers): void;
+  /** @deprecated since v9, will be removed in v10 */
+  static ZOOM_KEYS: {
+    PAGEUP: 'in';
+    PAGEDOWN: 'out';
+    NUMPADADD: 'in';
+    NUMPADSUBTRACT: 'out';
+  };
 
-  /**
-   * Handle presses to keyboard zoom keys
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onKeyZoom(
-    event: KeyboardEvent,
-    up: boolean,
-    modifiers: KeyboardManager.MetaModifiers
-  ): void | ReturnType<Canvas['animatePan']>;
+  /** @deprecated since v9, will be removed in v10 */
+  static standardizeKey(key: string): string;
 
-  /**
-   * Handle DELETE Keypress Events
-   * @param event     - The originating keyboard event
-   * @param up        - Is the key being released?
-   * @param modifiers - The identified modifiers attached to this keypress
-   */
-  protected _onDelete(
-    event: KeyboardEvent,
-    up: boolean,
-    modifiers: KeyboardManager.MetaModifiers
-  ): void | Promise<foundry.abstract.Document<any, any>[] | undefined>;
-}
+  /** @deprecated since v9, will be removed in v10 */
+  get digitKeys(): typeof KeyboardManager.DIGIT_KEYS;
 
-declare namespace KeyboardManager {
-  interface MetaModifiers {
-    key: string;
-    isShift: boolean;
-    isCtrl: boolean;
-    isAlt: boolean;
-    hasFocus: boolean;
-    hasModifier: boolean;
-  }
+  /** @deprecated since v9, will be removed in v10 */
+  get zoomKeys(): KeybindingActionBinding[];
 }

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

@@ -0,0 +1,18 @@
+/** Management class for Mouse events */
+declare class MouseManager {
+  constructor();
+
+  /**
+   * Specify a rate limit for mouse wheel to gate repeated scrolling.
+   * This is especially important for continuous scrolling mice which emit hundreds of events per second.
+   * This designates a minimum number of milliseconds which must pass before another wheel event is handled
+   * @defaultValue `50`
+   */
+  static MOUSE_WHEEL_RATE_LIMIT: number;
+
+  /**
+   * Master mouse-wheel event handler
+   * @internal
+   */
+  protected _onWheel(event: MouseEvent): void;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Responsible for managing the New User Experience workflows.
+ */
+declare class NewUserExperience {
+  constructor();
+
+  /**
+   * Initialize the new user experience.
+   * Currently, this generates some chat messages with hints for getting started if we detect this is a new world.
+   */
+  initialize(): void;
+
+  /**
+   * Add event listeners to the chat card links.
+   * @param msg  - The ChatMessage being rendered.
+   * @param html - The HTML content of the message.
+   * @internal
+   */
+  protected _activateListeners(msg: ChatMessage, html: JQuery): void;
+
+  /**
+   * Perform some special action triggered by clicking on a link in a NUE chat card.
+   * @param event - The click event.
+   * @internal
+   */
+  protected _onActionLink(event: Event): void;
+
+  /**
+   * Switch to the appropriate tab when a user clicks on a link in the chat message.
+   * @param event - The click event.
+   * @internal
+   */
+  protected _onTabLink(event: Event): void;
+}

package/src/foundry/foundry.js/pixi/containers/cachedContainer.d.ts

@@ -33,6 +33,14 @@ declare class CachedContainer extends PIXI.Container {
    */
   displayed: boolean;
 
+  /**
+   * A bound Sprite which uses this container's render texture
+   */
+  get sprite(): PIXI.Sprite;
+
+  /** @internal */
+  protected _sprite: PIXI.Sprite | undefined;
+
   destroy(options?: Parameters<PIXI.Container['destroy']>[0]): ReturnType<PIXI.Container['destroy']>;
 
   render(renderer: Parameters<PIXI.Container['render']>[0]): void;

package/src/foundry/foundry.js/pixi/containers/cachedContainers/index.d.ts

@@ -0,0 +1 @@
+import './primaryCanvasGroup';

package/src/foundry/foundry.js/pixi/containers/cachedContainers/primaryCanvasGroup.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A cached container group which renders the primary visible contents of a Scene.
+ */
+declare class PrimaryCanvasGroup extends CachedContainer {
+  constructor();
+
+  background: BackgroundLayer;
+
+  drawings: DrawingsLayer;
+
+  grid: GridLayer;
+
+  templates: TemplateLayer;
+
+  tokens: TokenLayer;
+
+  foreground: ForegroundLayer;
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @defaultValue `"primary"`
+   */
+  static groupName: string;
+
+  /**
+   * @override
+   * @defaultValue `[0, 0, 0, 0]`
+   */
+  clearColor: [r: number, g: number, b: number, a: number];
+
+  /**
+   * Create the member layers of the scene container
+   * @internal
+   */
+  protected _createLayers(): void;
+
+  /** @override */
+  render(renderer: Parameters<PIXI.Container['render']>[0]): void;
+}

package/src/foundry/foundry.js/pixi/containers/canvasLayers/gridLayer.d.ts

@@ -42,7 +42,7 @@ declare class GridLayer extends CanvasLayer<GridLayer.LayerOptions> {
   /**
    * The grid type rendered in this Scene
    */
-  get type(): foundry.CONST.GridType;
+  get type(): foundry.CONST.GRID_TYPES;
 
   /**
    * A convenient reference to the pixel grid size used throughout this layer
@@ -177,7 +177,7 @@ interface DrawOptions {
   /**
    * @defaultValue `null`
    */
-  type?: foundry.CONST.GridType | null;
+  type?: foundry.CONST.GRID_TYPES | null;
 
   /**
    * @defaultValue `null`

package/src/foundry/foundry.js/pixi/containers/canvasLayers/index.d.ts

@@ -1,6 +1,6 @@
 import './controlsLayer';
-import './effectsLayer';
 import './gridLayer';
 import './placeablesLayer';
 import './placeablesLayers';
 import './sightLayer';
+import './weatherLayer';

package/src/foundry/foundry.js/pixi/containers/canvasLayers/placeablesLayers/wallsLayer.d.ts

@@ -189,9 +189,9 @@ declare global {
      */
     protected _getWallDataFromActiveTool(tool: string):
       | {
-          move: foundry.CONST.WallMovementType;
-          sense: foundry.CONST.WallSenseType;
-          door?: foundry.CONST.WallDoorType;
+          move: foundry.CONST.WALL_MOVEMENT_TYPES;
+          sense: foundry.CONST.WALL_SENSE_TYPES;
+          door?: foundry.CONST.WALL_DOOR_TYPES;
         }
       | this['_cloneType'];
 

package/src/foundry/foundry.js/pixi/containers/canvasLayers/{effectsLayer.d.ts → weatherLayer.d.ts}

@@ -1,7 +1,7 @@
 /**
  * A CanvasLayer for displaying visual effects like weather, transitions, flashes, or more
  */
-declare class EffectsLayer extends CanvasLayer<EffectsLayer.LayerOptions> {
+declare class WeatherLayer extends CanvasLayer<WeatherLayer.LayerOptions> {
   /**
    * The weather overlay container
    * @defaultValue `undefined`
@@ -15,7 +15,7 @@ declare class EffectsLayer extends CanvasLayer<EffectsLayer.LayerOptions> {
   weatherEffect: SpecialEffect | undefined;
 
   /**
-   * Track any active emitters within this Scene
+   * Track the set of particle Emitter instances which are active within this Scene.
    * @defaultValue `[]`
    */
   emitters: PIXI.particles.Emitter[];
@@ -29,18 +29,18 @@ declare class EffectsLayer extends CanvasLayer<EffectsLayer.LayerOptions> {
   /**
    * @remarks This is not overridden in foundry but reflects the real behavior.
    */
-  static get instance(): Canvas['effects'];
+  static get instance(): Canvas['weather'];
 
   /**
    * @defaultValue
    * ```typescript
    * foundry.utils.mergeObject(super.layerOptions, {
-   *  name: "effects",
-   *  zIndex: 700
+   *   name: "effects",
+   *   zIndex: 700
    * })
    * ```
    */
-  static get layerOptions(): EffectsLayer.LayerOptions;
+  static get layerOptions(): WeatherLayer.LayerOptions;
 
   /** @override */
   tearDown(): Promise<this>;
@@ -55,7 +55,7 @@ declare class EffectsLayer extends CanvasLayer<EffectsLayer.LayerOptions> {
   drawWeather(): Exclude<this['weather'], undefined> | null;
 }
 
-declare namespace EffectsLayer {
+declare namespace WeatherLayer {
   interface LayerOptions extends CanvasLayer.LayerOptions {
     name: 'effects';
     zIndex: 700;