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

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

@@ -1,9 +1,6 @@
 /**
  * Handle mouse interaction events for a Canvas object.
  * There are three phases of events: hover, click, and drag
- * @typeParam O - Canvas object this instance handles events for
- * @typeParam T - Target object for mouseinteraction events. Generally a `ControlIcon` or `O`.
- *                (default: `O`)
  *
  * Hover Events:
  * _handleMouseOver
@@ -33,22 +30,24 @@
  * _handleDragCancel
  *  action: dragLeftCancel
  *  action: dragRightCancel
+ *
+ * @typeParam Object - The concrete {@link PIXI.Container} object that for which mouse interactions are being managed
  */
-declare class MouseInteractionManager<O extends PIXI.Container = PIXI.Container, T extends PIXI.Container = O> {
+declare class MouseInteractionManager<Object extends PIXI.Container = PIXI.Container> {
   /**
    * @param permissions - (default: `{}`)
    * @param callbacks   - (default: `{}`)
    * @param options     - (default: `{}`)
    */
   constructor(
-    object: O,
+    object: Object,
     layer: MouseInteractionManager['layer'],
     permissions?: MouseInteractionManager['permissions'],
     callbacks?: MouseInteractionManager['callbacks'],
     options?: MouseInteractionManager['options']
   );
 
-  object: O;
+  object: Object;
 
   layer: PIXI.Container;
 
@@ -56,24 +55,25 @@ declare class MouseInteractionManager<O extends PIXI.Container = PIXI.Container,
    * @defaultValue `{}`
    */
   permissions: Partial<
-    Record<MouseInteractionManager.EventNames, ((user: User, event: PIXI.InteractionEvent) => boolean) | boolean>
+    Record<
+      MouseInteractionManager.PermissionAction,
+      ((user: Game['user'], event: PIXI.InteractionEvent) => boolean) | boolean
+    >
   >;
 
   /**
    * @defaultValue `{}`
    */
-  callbacks: Partial<
-    Record<MouseInteractionManager.EventNames, ((event: Event | PIXI.InteractionEvent) => unknown) | null>
-  >;
+  callbacks: Partial<Record<MouseInteractionManager.Action, ((event: Event | PIXI.InteractionEvent) => void) | null>>;
 
   /**
    * @defaultValue `{}`
    */
-  options: { target?: string[] | string | null };
+  options: MouseInteractionManager.Options;
 
   /**
    * The current interaction state
-   * @defaultValue `0`
+   * @defaultValue `MouseInteractionManager.INTERACTION_STATES.NONE`
    */
   state: ValueOf<typeof MouseInteractionManager['INTERACTION_STATES']>;
 
@@ -82,7 +82,10 @@ declare class MouseInteractionManager<O extends PIXI.Container = PIXI.Container,
    * @defaultValue `{}`
    */
   handlers: Partial<
-    Record<'contextmenu' | 'mousedown' | 'mousemove' | 'mouseout' | 'mouseover' | 'mouseup' | 'rightdown', Function>
+    Record<
+      'contextmenu' | 'mousedown' | 'mousemove' | 'mouseout' | 'mouseover' | 'mouseup' | 'rightdown',
+      (event: PIXI.InteractionEvent | MouseEvent) => void
+    >
   >;
 
   /**
@@ -94,6 +97,7 @@ declare class MouseInteractionManager<O extends PIXI.Container = PIXI.Container,
   /**
    * The throttling time below which a mouse move event will not be handled
    * @defaultValue `Math.ceil(1000 / canvas.app.ticker.maxFPS)`
+   * @internal
    */
   protected _dragThrottleMS: number;
 
@@ -115,11 +119,31 @@ declare class MouseInteractionManager<O extends PIXI.Container = PIXI.Container,
    */
   protected _dragRight: boolean;
 
+  /**
+   * An optional ControlIcon instance for the object
+   */
+  controlIcon: ControlIcon | undefined;
+
+  /**
+   * Enumerate the states of a mouse interaction workflow.
+   * 0: NONE - the object is inactive
+   * 1: HOVER - the mouse is hovered over the object
+   * 2: CLICKED - the object is clicked
+   * 3: DRAG - the object is being dragged
+   * 4: DROP - the object is being dropped
+   */
+  static INTERACTION_STATES: {
+    NONE: 0;
+    HOVER: 1;
+    CLICKED: 2;
+    DRAG: 3;
+    DROP: 4;
+  };
+
   /**
    * Get the target
-   * @returns `this.object` or `this.object[this.options.target]`
    */
-  get target(): T;
+  get target(): PIXI.Container;
 
   /**
    * Activate interactivity for the handled object
@@ -132,14 +156,14 @@ declare class MouseInteractionManager<O extends PIXI.Container = PIXI.Container,
    * @param event  - The event being handled
    * @returns Can the action be performed?
    */
-  can(action: MouseInteractionManager.EventNames, event: Event | PIXI.InteractionEvent): boolean;
+  can(action: MouseInteractionManager.PermissionAction, event: Event | PIXI.InteractionEvent): boolean;
 
   /**
    * Execute a callback function associated with a certain action in the workflow
    * @param action - The action being attempted
    * @param event  - The event being handled
    */
-  callback(action: MouseInteractionManager.EventNames, event: Event | PIXI.InteractionEvent): unknown;
+  callback(action: MouseInteractionManager.Action, event: Event | PIXI.InteractionEvent): unknown;
 
   /**
    * A reference to the possible interaction states which can be observed
@@ -148,132 +172,152 @@ declare class MouseInteractionManager<O extends PIXI.Container = PIXI.Container,
 
   /**
    * Activate a set of listeners which handle hover events on the target object
+   * @internal
    */
   protected _activateHoverEvents(): void;
 
   /**
    * Activate a new set of listeners for click events on the target object
+   * @internal
    */
   protected _activateClickEvents(): void;
 
   /**
    * Deactivate event listeners for click events on the target object
+   * @internal
    */
   protected _deactivateClickEvents(): void;
 
   /**
    * Activate events required for handling a drag-and-drop workflow
+   * @internal
    */
   protected _activateDragEvents(): void;
 
   /**
    * Deactivate events required for handling drag-and-drop workflow.
+   * @internal
    */
   protected _deactivateDragEvents(): void;
 
   /**
    * Handle mouse-over events which activate downstream listeners and do not stop propagation.
+   * @internal
    */
   protected _handleMouseOver(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle mouse-out events which terminate hover workflows and do not stop propagation.
+   * @internal
    */
   protected _handleMouseOut(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle mouse-down events which activate downstream listeners.
    * Stop further propagation only if the event is allowed by either single or double-click.
+   * @internal
    */
   protected _handleMouseDown(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle mouse-down which trigger a single left-click workflow.
+   * @internal
    */
   protected _handleClickLeft(event: PIXI.InteractionEvent): void;
 
   /**
    * Handle mouse-down which trigger a single left-click workflow.
+   * @internal
    */
   protected _handleClickLeft2(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle right-click mouse-down events.
    * Stop further propagation only if the event is allowed by either single or double-click.
+   * @internal
    */
   protected _handleRightDown(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle single right-click actions.
+   * @internal
    */
   protected _handleClickRight(event: PIXI.InteractionEvent): void;
 
   /**
    * Handle double right-click actions.
+   * @internal
    */
   protected _handleClickRight2(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle mouse movement during a drag workflow
+   * @internal
    */
   protected _handleMouseMove(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle the beginning of a new drag start workflow, moving all controlled objects on the layer
+   * @internal
    */
   protected _handleDragStart(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle the continuation of a drag workflow, moving all controlled objects on the layer
+   * @internal
    */
   protected _handleDragMove(event: PIXI.InteractionEvent): unknown;
 
   /**
    * Handle mouse up events which may optionally conclude a drag workflow
+   * @internal
    */
   protected _handleMouseUp(event: PIXI.InteractionEvent): void;
 
   /**
    * Handle the conclusion of a drag workflow, placing all dragged objects back on the layer
+   * @internal
    */
   protected _handleDragDrop(event: PIXI.InteractionEvent): void;
 
   /**
    * Handle the cancellation of a drag workflow, resetting back to the original state
+   * @internal
    */
-  protected _handleDragCancel(event: PointerEvent): void;
+  protected _handleDragCancel(event: MouseEvent): void;
 
   /**
-   * Enumerate the states of a mouse interaction workflow.
-   * 0: NONE - the object is inactive
-   * 1: HOVER - the mouse is hovered over the object
-   * 2: CLICKED - the object is clicked
-   * 3: DRAG - the object is being dragged
-   * 4: DROP - the object is being dropped
+   * A public method to cancel a current interaction workflow from this manager.
+   * @param event - The event that initiates the cancellation
    */
-  static INTERACTION_STATES: {
-    NONE: 0;
-    HOVER: 1;
-    CLICKED: 2;
-    DRAG: 3;
-    DROP: 4;
-  };
+  cancel(event: Event): void;
 }
 
 declare namespace MouseInteractionManager {
-  type EventNames =
+  type PermissionAction =
     | 'clickLeft'
     | 'clickLeft2'
     | 'clickRight'
     | 'clickRight2'
-    | 'dragLeftCancel'
     | 'dragLeftDrop'
     | 'dragLeftMove'
     | 'dragLeftStart'
-    | 'dragRightCancel'
     | 'dragRightDrop'
     | 'dragRightMove'
     | 'dragRightStart'
     | 'hoverIn'
     | 'hoverOut';
+
+  type Action = PermissionAction | 'dragLeftCancel' | 'dragRightCancel';
+
+  interface Options {
+    /**
+     * @remarks If set, this must be the name of a property of the object that is a {@link PIXI.Container}.
+     */
+    target?: string | null;
+
+    dragResistance?: number;
+  }
 }
+
+declare const a: PIXI.Container;

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/canvasLayer.d.ts

@@ -24,8 +24,9 @@ declare abstract class CanvasLayer<Options extends CanvasLayerOptions = CanvasLa
   /**
    * Track whether the canvas layer is currently active for interaction
    * @defaultValue `false`
+   * @remarks This is public because it's checked from outside in foundry and modules sometimes need to do the same.
    */
-  protected _active: boolean;
+  _active: boolean;
 
   /**
    * Customize behaviors of this CanvasLayer by modifying some behaviors at a class level.

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/placeablesLayer.d.ts

@@ -52,8 +52,9 @@ declare global {
     /**
      * Track the set of PlaceableObjects on this layer which are currently controlled by their id
      * @defaultValue `{}`
+     * @remarks This is public because it's used from externally by foundry and modules might need to do the same.
      */
-    protected _controlled: Record<string, InstanceType<ConfiguredObjectClassForName<DocumentName>>>;
+    _controlled: Record<string, InstanceType<ConfiguredObjectClassForName<DocumentName>>>;
 
     /**
      * Keep track of an object copied with CTRL+C which can be pasted later
@@ -114,7 +115,9 @@ declare global {
     /**
      * Obtain an iterable of objects which should be added to this PlaceableLayer
      */
-    getDocuments(): Exclude<this['documentCollection'], null> | [];
+    getDocuments():
+      | Exclude<this['documentCollection'], null>
+      | InstanceType<ConfiguredDocumentClassForName<DocumentName>>[];
 
     /**
      * @override
@@ -270,7 +273,7 @@ declare global {
      * @param event - (unused)
      * @see {@link Canvas#_onClickLeft}
      */
-    protected _onClickLeft(event: PIXI.InteractionEvent): number | void;
+    protected _onClickLeft(event: PIXI.InteractionEvent): void;
 
     /**
      * Handle double left-click events which originate from the Canvas stage and are dispatched to this Layer.
@@ -282,9 +285,8 @@ declare global {
     /**
      * Start a left-click drag workflow originating from the Canvas stage.
      * @see {@link Canvas#_onDragLeftStart}
-     * @remarks This returns Promise<void> but is overridden by some subclasses.
      */
-    protected _onDragLeftStart(event: PIXI.InteractionEvent): Promise<void | PlaceableObject>;
+    protected _onDragLeftStart(event: PIXI.InteractionEvent): void;
 
     /**
      * Continue a left-click drag workflow originating from the Canvas stage.
@@ -295,11 +297,8 @@ declare global {
     /**
      * Conclude a left-click drag workflow originating from the Canvas stage.
      * @see {@link Canvas#_onDragLeftDrop}
-     * @remarks Returns always a promise but is overridden in subclasses.
      */
-    protected _onDragLeftDrop(
-      event: PIXI.InteractionEvent
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<DocumentName>> | void> | void;
+    protected _onDragLeftDrop(event: PIXI.InteractionEvent): void;
 
     /**
      * Cancel a left-click drag workflow originating from the Canvas stage.
@@ -319,23 +318,15 @@ declare global {
      * Handle mouse-wheel events at the PlaceableObjects layer level to rotate multiple objects at once.
      * This handler will rotate all controlled objects by some incremental angle.
      * @param event - The mousewheel event which originated the request
-     * @remarks This methods just returns ReturnType\<this['rotateMany']\>|void but is overridden by subclasses
      */
-    protected _onMouseWheel(
-      event: WheelEvent
-    ):
-      | ReturnType<this['rotateMany']>
-      | ReturnType<InstanceType<ConfiguredObjectClassForName<DocumentName>>['rotate']>
-      | void;
+    protected _onMouseWheel(event: WheelEvent): void;
 
     /**
      * Handle a DELETE keypress while a placeable object is hovered
      * @param event - The delete key press event which triggered the request
      *                (unused)
      */
-    protected _onDeleteKey(
-      event?: any
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<DocumentName>>[] | undefined>;
+    protected _onDeleteKey(event?: any): void;
 
     /**
      * @deprecated since 0.8.0

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

@@ -1,4 +1,8 @@
-import { ConfiguredObjectClassForName, DataSourceForPlaceable } from '../../../../../../../types/helperTypes';
+import {
+  ConfiguredDocumentClassForName,
+  ConfiguredObjectClassForName,
+  DataSourceForPlaceable
+} from '../../../../../../../types/helperTypes';
 
 declare global {
   /**
@@ -27,7 +31,7 @@ declare global {
      */
     protected _drawOutline(): PIXI.Graphics | undefined;
 
-    getDocuments(): Exclude<this['documentCollection'], null>;
+    getDocuments(): Exclude<this['documentCollection'], null> | InstanceType<ConfiguredDocumentClassForName<'Tile'>>[];
 
     getZIndex(): number;
 

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

@@ -1,4 +1,4 @@
-import { ConfiguredObjectClassForName } from '../../../../../../../types/helperTypes';
+import { ConfiguredDocumentClassForName, ConfiguredObjectClassForName } from '../../../../../../../types/helperTypes';
 
 declare global {
   /**
@@ -43,7 +43,7 @@ declare global {
 
     getZIndex(): number;
 
-    getDocuments(): Exclude<this['documentCollection'], null>;
+    getDocuments(): Exclude<this['documentCollection'], null> | InstanceType<ConfiguredDocumentClassForName<'Tile'>>[];
 
     /**
      * Refresh the display of tiles on the Foreground Layer depending on Token occlusion.

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

@@ -189,14 +189,14 @@ 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'];
 
     /** @override */
-    protected _onDragLeftStart(event: PIXI.InteractionEvent): Promise<Wall>;
+    protected _onDragLeftStart(event: PIXI.InteractionEvent): void;
 
     /** @override */
     protected _onDragLeftMove(event: PIXI.InteractionEvent): void;

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;

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

@@ -0,0 +1,29 @@
+/**
+ * A container group which contains visual effects rendered above the primary group.
+ */
+declare class EffectsCanvasGroup extends PIXI.Container {
+  constructor();
+
+  walls: WallsLayer;
+
+  lighting: LightingLayer;
+
+  weather: WeatherLayer;
+
+  sight: SightLayer;
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @defaultValue `"effects"`
+   */
+  static groupName: string;
+
+  /**
+   * Create the member layers of the scene container
+   * @internal
+   */
+  protected _createLayers(): void;
+}