@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.2-beta

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

@@ -0,0 +1,7 @@
+import "./effects.d.mts";
+import "./environment.d.mts";
+import "./hidden.d.mts";
+import "./interface.d.mts";
+import "./overlay.d.mts";
+import "./primary.d.mts";
+import "./rendered.d.mts";

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

@@ -0,0 +1,74 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A container group which displays interface elements rendered above other canvas groups.
+   */
+  class InterfaceCanvasGroup extends CanvasGroupMixin(PIXI.Container) {
+    /**
+     * @defaultValue `"interface"`
+     */
+    static override groupName: string;
+
+    /**
+     * Add a PrimaryGraphics to the group.
+     * @param drawing - The Drawing being added
+     * @returns The created Graphics instance
+     */
+    addDrawing(drawing: Drawing): PIXI.Graphics;
+
+    /**
+     * Remove a PrimaryGraphics from the group.
+     * @param drawing - The Drawing being removed
+     */
+    removeDrawing(drawing: Drawing): void;
+
+    protected override _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+
+    /**
+     * Display scrolling status text originating from this ObjectHUD container.
+     * @param origin  - An origin point where the text should first emerge
+     * @param content - The text content to display
+     * @param options - Options which customize the text animation
+     * @returns - The created PreciseText object which is scrolling
+     */
+    createScrollingText(
+      origin: Canvas.Point,
+      content: string,
+      options?: {
+        /**
+         * The duration of the scrolling effect in milliseconds
+         * @defaultValue `2000`
+         */
+        duration?: number;
+
+        /**
+         * The distance in pixels that the scrolling text should travel
+         * @defaultValue (2 * text.width)
+         */
+        distance?: number;
+
+        /**
+         * The original anchor point where the text appears
+         */
+        anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
+
+        /**
+         * The direction in which the text scrolls
+         */
+        direction: foundry.CONST.TEXT_ANCHOR_POINTS;
+
+        /**
+         * An amount of randomization between [0, 1] applied to the initial position
+         * @defaultValue `0`
+         */
+        jitter: number;
+
+        /**
+         * Additional parameters of PIXI.TextStyle which are applied to the text
+         */
+        textStyle: InexactPartial<PIXI.ITextStyle>;
+      },
+    ): Promise<PreciseText | null>;
+  }
+}

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

@@ -0,0 +1,18 @@
+export {};
+
+declare global {
+  /**
+   * A container group which is not bound to the stage world transform.
+   */
+  class OverlayCanvasGroup extends CanvasGroupMixin(UnboundContainer) {
+    /**
+     * @defaultValue `"overlay"`
+     */
+    static override groupName: string;
+
+    /**
+     * @defaultValue `false`
+     */
+    static override tearDownChildren: boolean;
+  }
+}

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

@@ -0,0 +1,200 @@
+import type { Renderer } from "pixi.js";
+
+// Included to match Foundry's documented types
+type PrimaryCanvasObject = ReturnType<typeof PrimaryCanvasObjectMixin>;
+
+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<PrimaryGraphics>;
+
+    /**
+     * The collection of SpriteMesh objects which are rendered in the Scene.
+     */
+    tokens: Collection<PrimarySpriteMesh>;
+
+    /**
+     * The collection of SpriteMesh objects which are rendered in the Scene.
+     */
+    tiles: Collection<PrimarySpriteMesh>;
+
+    /**
+     * 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,95 @@
+export {};
+
+declare global {
+  /**
+   * An abstract pattern for primary layers of the game canvas to implement
+   */
+  abstract class CanvasLayer<
+    DrawOptions extends CanvasLayer.DrawOptions = CanvasLayer.DrawOptions,
+    TearDownOptions extends CanvasLayer.TearDownOptions = CanvasLayer.TearDownOptions,
+  > 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?: DrawOptions): 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?: DrawOptions): 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?: TearDownOptions): 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?: TearDownOptions): Promise<void>;
+  }
+
+  namespace CanvasLayer {
+    type AnyConstructor = typeof AnyCanvasLayer;
+
+    interface LayerOptions {
+      /**
+       * The layer name by which the instance is referenced within the Canvas
+       */
+      name: string;
+
+      baseClass: typeof CanvasLayer;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface DrawOptions {}
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface TearDownOptions {}
+  }
+}
+
+declare abstract class AnyCanvasLayer extends CanvasLayer {
+  constructor(arg0: never, ...args: never[]);
+}

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,162 @@
+import type { NullishProps } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A subclass of CanvasLayer which provides support for user interaction with its contained objects.
+   */
+  class InteractionLayer<
+    DrawOptions extends InteractionLayer.DrawOptions = InteractionLayer.DrawOptions,
+    TearDownOptions extends CanvasLayer.TearDownOptions = CanvasLayer.TearDownOptions,
+  > extends CanvasLayer<DrawOptions, TearDownOptions> {
+    /**
+     * Is this layer currently active
+     */
+    get active(): boolean;
+
+    /**
+     * @privateRemarks Override not in foundry docs but implicit from layerOptions
+     */
+    override options: InteractionLayer.LayerOptions;
+
+    /**
+     * @defaultValue `"passive"`
+     */
+    override eventMode: PIXI.EventMode;
+
+    /**
+     * Customize behaviors of this CanvasLayer by modifying some behaviors at a class level.
+     * @defaultValue
+     * ```js
+     * {
+     *   baseClass: InteractionLayer,
+     *   zIndex: 0,
+     * }
+     * ```
+     */
+    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?: NullishProps<{
+        /**
+         * 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?: DrawOptions): 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 {
+    type AnyConstructor = typeof AnyInteractionLayer;
+
+    interface LayerOptions extends CanvasLayer.LayerOptions {
+      zIndex: number;
+
+      baseClass: typeof InteractionLayer;
+    }
+
+    interface DrawOptions extends CanvasLayer.DrawOptions {}
+  }
+}
+
+declare abstract class AnyInteractionLayer extends InteractionLayer {
+  constructor(arg0: never, ...args: never[]);
+}