@league-of-foundry-developers/foundry-vtt-types 9.280.0 → 12.331.1-beta

package/src/foundry/client/pixi/groups/primary.d.mts

@@ -0,0 +1,207 @@
+import type { Renderer } from "pixi.js";
+
+// Included to match Foundry's documented types
+type PrimaryCanvasObject = ReturnType<typeof PrimaryCanvasObjectMixin>;
+
+// TODO: remove after #2855
+type PrimarySpriteMesh = unknown;
+type PrimaryGraphics = unknown;
+
+// TODO: remove after #2570
+type PrimaryCanvasGroupAmbienceFilter = unknown;
+
+declare global {
+  /**
+   * The primary Canvas group which generally contains tangible physical objects which exist within the Scene.
+   * This group is a {@link CachedContainer} which is rendered to the Scene as a {@link SpriteMesh}.
+   * This allows the rendered result of the Primary Canvas Group to be affected by a {@link BaseSamplerShader}.
+   */
+  class PrimaryCanvasGroup extends CanvasGroupMixin(CachedContainer) {
+    /**
+     * @param sprite - (default: `new SpriteMesh(undefined, BaseSamplerShader)`)
+     */
+    constructor(sprite?: SpriteMesh);
+
+    /**
+     * Sort order to break ties on the group/layer level.
+     */
+    static readonly SORT_LAYERS: {
+      SCENE: number;
+      TILES: number;
+      DRAWINGS: number;
+      TOKENS: number;
+      WEATHER: number;
+    };
+
+    /**
+     * @defaultValue `"primary"`
+     */
+    static override groupName: string;
+
+    static override textureConfiguration: {
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+      multisample: PIXI.MSAA_QUALITY;
+    };
+
+    /**
+     * @defaultValue `"none"`
+     */
+    override eventMode: PIXI.EventMode;
+
+    /**
+     * @defaultValue `[0, 0, 0, 0]`
+     */
+    override clearColor: [r: number, g: number, b: number, a: number];
+
+    /**
+     * The background color in RGB.
+     */
+    _backgroundColor?: [red: number, green: number, blue: number];
+
+    /**
+     * Track the set of HTMLVideoElements which are currently playing as part of this group.
+     */
+    videoMeshes: Set<SpriteMesh>;
+
+    /**
+     * Occludable objects above this elevation are faded on hover.
+     */
+    hoverFadeElevation: number;
+
+    /**
+     * Allow API users to override the default elevation of the background layer.
+     * This is a temporary solution until more formal support for scene levels is added in a future release.
+     */
+    static BACKGROUND_ELEVATION: number;
+
+    /**
+     * The primary background image configured for the Scene, rendered as a SpriteMesh.
+     */
+    background: SpriteMesh;
+
+    /**
+     * The primary foreground image configured for the Scene, rendered as a SpriteMesh.
+     */
+    foreground: SpriteMesh;
+
+    /**
+     * A Quadtree which partitions and organizes primary canvas objects.
+     */
+    quadtree: CanvasQuadtree;
+
+    /**
+     * The collection of PrimaryDrawingContainer objects which are rendered in the Scene.
+     */
+    drawings: Collection<DrawingShape>;
+
+    /**
+     * The collection of SpriteMesh objects which are rendered in the Scene.
+     */
+    tokens: Collection<TokenMesh>;
+
+    /**
+     * The collection of SpriteMesh objects which are rendered in the Scene.
+     */
+    tiles: Collection<PrimarySpriteMesh | TileSprite>;
+
+    /**
+     * The ambience filter which is applying post-processing effects.
+     */
+    _ambienceFilter: PrimaryCanvasGroupAmbienceFilter;
+
+    /**
+     * Render all tokens in their own render texture.
+     * @param renderer - The renderer to use.
+     */
+    _renderTokens(renderer: PIXI.Renderer): void;
+
+    /**
+     * Return the base HTML image or video element which provides the background texture.
+     */
+    get backgroundSource(): HTMLImageElement | HTMLVideoElement;
+
+    /**
+     * Return the base HTML image or video element which provides the foreground texture.
+     */
+    get foregroundSource(): HTMLImageElement | HTMLVideoElement;
+
+    /**
+     * Refresh the primary mesh.
+     */
+    refreshPrimarySpriteMesh(): void;
+
+    /**
+     * Update this group. Calculates the canvas transform and bounds of all its children and updates the quadtree.
+     */
+    update(): void;
+
+    protected override _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+
+    protected override _render(_renderer: Renderer): void;
+
+    protected override _tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+
+    /**
+     * Draw the SpriteMesh for a specific Token object.
+     * @param token - The Token being added
+     * @returns The added PrimarySpriteMesh
+     */
+    addToken(token: Token): PrimarySpriteMesh;
+
+    /**
+     * Remove a TokenMesh from the group.
+     * @param token - The Token being removed
+     */
+    removeToken(token: Token): void;
+
+    /**
+     * Draw the SpriteMesh for a specific Token object.
+     * @param tile - The Tile being added
+     * @returns The added PrimarySpriteMesh
+     */
+    addTile(tile: Tile): PrimarySpriteMesh;
+
+    /**
+     * Remove a TokenMesh from the group.
+     * @param tile - The Tile being removed
+     */
+    removeTile(tile: Tile): void;
+
+    /**
+     * Add a PrimaryGraphics to the group.
+     * @param drawing - The Drawing being added
+     * @returns The created PrimaryGraphics instance
+     */
+    addDrawing(drawing: Drawing): PrimaryGraphics;
+
+    /**
+     * Remove a PrimaryGraphics from the group.
+     * @param drawing - The Drawing being removed
+     */
+    removeDrawing(drawing: Drawing): void;
+
+    /**
+     * Override the default PIXI.Container behavior for how objects in this container are sorted.
+     * @override
+     */
+    sortChildren(): void;
+
+    /**
+     * Handle mousemove events on the primary group to update the hovered state of its children.
+     */
+    protected _onMouseMove(): void;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"PrimaryCanvasGroup#mapElevationAlpha is deprecated. Use canvas.masks.depth.mapElevation(elevation) instead."`
+     */
+    mapElevationToDepth(elevation: number): number;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "PrimaryCanvasGroup#mapElevationAlpha is deprecated in favor of PrimaryCanvasGroup#mapElevationToDepth"
+     */
+    mapElevationAlpha(elevation: number): number;
+  }
+}

package/src/foundry/client/pixi/groups/rendered.d.mts

@@ -0,0 +1,18 @@
+export {};
+
+declare global {
+  /**
+   * A container group which contains the environment canvas group and the interface canvas group.
+   */
+  class RenderedCanvasGroup extends CanvasGroupMixin(PIXI.Container) {
+    /**
+     * @defaultValue `"rendered"`
+     */
+    static override groupName: string;
+
+    /**
+     * @defaultValue `false`
+     */
+    static override tearDownChildren: boolean;
+  }
+}

package/src/foundry/client/pixi/index.d.mts

@@ -0,0 +1,10 @@
+import "./board.d.mts";
+import "./core/index.d.mts";
+import "./extensions/index.d.mts";
+import "./groups/index.d.mts";
+import "./layers/index.d.mts";
+import "./perception/index.d.mts";
+import "./placeable.d.mts";
+import "./placeables/index.d.mts";
+import "./webgl/index.d.mts";
+import "./workers/index.d.mts";

package/src/foundry/client/pixi/layers/base/canvas-layer.d.mts

@@ -0,0 +1,79 @@
+export {};
+
+declare global {
+  /**
+   * An abstract pattern for primary layers of the game canvas to implement
+   */
+  abstract class CanvasLayer extends PIXI.Container {
+    constructor();
+
+    /**
+     * Options for this layer instance.
+     * @defaultValue `this.constructor.layerOptions`
+     */
+    options: CanvasLayer.LayerOptions;
+
+    /**
+     * @defaultValue `false`
+     */
+    interactiveChildren: boolean;
+
+    /**
+     * Customize behaviors of this CanvasLayer by modifying some behaviors at a class level.
+     */
+    static get layerOptions(): CanvasLayer.LayerOptions;
+
+    /**
+     * Return a reference to the active instance of this canvas layer
+     */
+    static get instance(): CanvasLayer | PIXI.Container | undefined;
+
+    /**
+     * The canonical name of the CanvasLayer is the name of the constructor that is the immediate child of the defined baseClass for the layer type.
+     * @remarks Foundry defines this as a getter, but since CanvasLayer extends PIXI.Container, it has to be a property.
+     */
+    readonly name: string;
+
+    /**
+     * The name used by hooks to construct their hook string.
+     * Note: You should override this getter if hookName should not return the class constructor name.
+     */
+    get hookName(): string;
+
+    /**
+     * Draw the canvas layer, rendering its internal components and returning a Promise
+     * The Promise resolves to the drawn layer once its contents are successfully rendered.
+     * @param options - Options which configure how the layer is drawn
+     */
+    draw(options?: Record<string, unknown>): Promise<this>;
+
+    /**
+     * The inner _draw method which must be defined by each CanvasLayer subclass.
+     * @param options - Options which configure how the layer is drawn
+     */
+    protected abstract _draw(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Deconstruct data used in the current layer in preparation to re-draw the canvas
+     * @param options - Options which configure how the layer is deconstructed
+     * @remarks ControlsLayer returns void. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6939
+     */
+    tearDown(options?: Record<string, unknown>): Promise<this | void>;
+
+    /**
+     * The inner _tearDown method which may be customized by each CanvasLayer subclass.
+     * @param options - Options which configure how the layer is deconstructed
+     */
+    protected _tearDown(options?: Record<string, unknown>): Promise<void>;
+  }
+  namespace CanvasLayer {
+    interface LayerOptions {
+      /**
+       * The layer name by which the instance is referenced within the Canvas
+       */
+      name: string;
+
+      baseClass: typeof CanvasLayer;
+    }
+  }
+}

package/src/foundry/client/pixi/layers/base/index.d.mts

@@ -0,0 +1,3 @@
+import "./canvas-layer.d.mts";
+import "./interaction-layer.d.mts";
+import "./placeables-layer.d.mts";

package/src/foundry/client/pixi/layers/base/interaction-layer.d.mts

@@ -0,0 +1,139 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A subclass of CanvasLayer which provides support for user interaction with its contained objects.
+   */
+  class InteractionLayer extends CanvasLayer {
+    /**
+     * Is this layer currently active
+     */
+    get active(): boolean;
+
+    /**
+     * @privateRemarks Override not in foundry docs but implicit from layerOptions
+     */
+    override options: InteractionLayer.LayerOptions;
+
+    /**
+     * Customize behaviors of this CanvasLayer by modifying some behaviors at a class level.
+     */
+    static get layerOptions(): InteractionLayer.LayerOptions;
+
+    /**
+     * Activate the InteractionLayer, deactivating other layers and marking this layer's children as interactive.
+     * @param options - Options which configure layer activation
+     * @returns - The layer instance, now activated
+     */
+    activate(
+      options?: InexactPartial<{
+        /**
+         * A specific tool in the control palette to set as active
+         */
+        tool: string;
+      }>,
+    ): this;
+
+    /**
+     * The inner _activate method which may be defined by each InteractionLayer subclass.
+     */
+    protected _activate(): void;
+
+    /**
+     * Deactivate the InteractionLayer, removing interactivity from its children.
+     * @returns - The layer instance, now inactive
+     */
+    deactivate(): this;
+
+    /**
+     * The inner _deactivate method which may be defined by each InteractionLayer subclass.
+     */
+    protected _deactivate(): void;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Get the zIndex that should be used for ordering this layer vertically relative to others in the same Container.
+     */
+    getZIndex(): number;
+
+    /**
+     * Handle left mouse-click events which originate from the Canvas stage.
+     * @see {@link Canvas._onClickLeft}
+     * @param event - The PIXI InteractionEvent which wraps a PointerEvent
+     */
+    protected _onClickLeft(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle double left-click events which originate from the Canvas stage.
+     * @see {@link Canvas.#onClickLeft2}
+     * @param event - The PIXI InteractionEvent which wraps a PointerEvent
+     */
+    protected _onClickLeft2(event: PIXI.FederatedEvent): void;
+
+  /**
+   * Does the User have permission to left-click drag on the Canvas?
+   * @param user  - The User performing the action.
+   * @param event - The event object.
+   */
+  protected _canDragLeftStart(user: User.ConfiguredInstance, event: PIXI.FederatedEvent): boolean;
+
+    /**
+     * Start a left-click drag workflow originating from the Canvas stage.
+     * @see {@link Canvas.#onDragLeftStart}
+     * @param event - The PIXI InteractionEvent which wraps a PointerEvent
+     * @remarks Current implementation always returns undefined
+     */
+    protected _onDragLeftStart(event: PIXI.FederatedEvent): unknown;
+
+    /**
+     * Continue a left-click drag workflow originating from the Canvas stage.
+     * @see {@link Canvas.#onDragLeftMove}
+     * @param event - The PIXI InteractionEvent which wraps a PointerEvent
+     */
+    protected _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Conclude a left-click drag workflow originating from the Canvas stage.
+     * @see {@link Canvas.#onDragLeftDrop}
+     * @param vent - The PIXI InteractionEvent which wraps a PointerEvent
+     */
+    protected _onDragLeftDrop(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Cancel a left-click drag workflow originating from the Canvas stage.
+     * @see {@link Canvas.#onDragLeftDrop}
+     * @param event - A right-click pointer event on the document.
+     */
+    protected _onDragLeftCancel(event: PointerEvent): void;
+
+    /**
+     * Handle right mouse-click events which originate from the Canvas stage.
+     * @see {@link Canvas._onClickRight}
+     * @param event - The PIXI InteractionEvent which wraps a PointerEvent
+     */
+    protected _onClickRight(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mouse-wheel events which occur for this active layer.
+     * @see {@link MouseManager._onWheel}
+     * @param event - The WheelEvent initiated on the document
+     */
+    protected _onMouseWheel(event: WheelEvent): void;
+
+    /**
+     * Handle a DELETE keypress while this layer is active.
+     * @see {@link ClientKeybindings._onDelete}
+     * @param event - The delete key press event
+     */
+    protected _onDeleteKey(event: KeyboardEvent): Promise<void>;
+  }
+
+  namespace InteractionLayer {
+    interface LayerOptions extends CanvasLayer.LayerOptions {
+      zIndex: number;
+
+      baseClass: typeof InteractionLayer;
+    }
+  }
+}