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

package/src/foundry/client/pixi/layers/grid/layer.d.mts

@@ -0,0 +1,225 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A CanvasLayer responsible for drawing a square grid
+   */
+  class GridLayer extends CanvasLayer {
+    /**
+     * The Grid container
+     * @defaultValue `undefined`
+     */
+    grid: BaseGrid | undefined;
+
+    /**
+     * The Grid Highlight container
+     * @defaultValue `undefined`
+     */
+    highlight: PIXI.Container | undefined;
+
+    /**
+     * Map named highlight layers
+     * @defaultValue `{}`
+     */
+    highlightLayers: Record<string, GridHighlight>;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["grid"];
+
+    /**
+     * @defaultValue
+     * ```js
+     * foundry.utils.mergeObject(super.layerOptions, {name: "grid"});
+     * ```
+     */
+    static override get layerOptions(): GridLayer.LayerOptions;
+
+    options: GridLayer.LayerOptions;
+
+    /**
+     * The grid type rendered in this Scene
+     */
+    get type(): foundry.CONST.GRID_TYPES;
+
+    /**
+     * A convenient reference to the pixel grid size used throughout this layer
+     */
+    get size(): number;
+
+    /**
+     * Get grid unit width
+     */
+    get w(): BaseGrid["w"];
+
+    /**
+     * Get grid unit height
+     */
+    get h(): BaseGrid["h"];
+
+    /**
+     * A boolean flag for whether the current grid is hexagonal
+     */
+    get isHex(): boolean;
+
+    /**
+     * Draw the grid
+     * @param preview - Override settings used in place of those saved to the Scene data
+     */
+    _draw(preview?: GridLayer.DrawOptions): Promise<void>;
+
+    /**
+     * Given a pair of coordinates (x1,y1), return the grid coordinates (x2,y2) which represent the snapped position
+     * @param x        - The exact target location x
+     * @param y        - The exact target location y
+     * @param interval - An interval of grid spaces at which to snap, default is 1.
+     *                   (defaultValue: `1`)
+     * @param options  - Additional options to configure snapping behaviour.
+     */
+    getSnappedPosition(
+      x: number,
+      y: number,
+      interval?: number,
+      options?: InexactPartial<{
+        /**
+         * The token
+         */
+        token: Token;
+      }>,
+    ): { x: number; y: number };
+
+    /**
+     * Given a pair of coordinates (x, y) - return the top-left of the grid square which contains that point
+     * @param x - Coordinate X.
+     * @param y - Coordinate Y.
+     * @returns An Array [x, y] of the top-left coordinate of the square which contains (x, y)
+     */
+    getTopLeft(x: number, y: number): PointArray;
+
+    /**
+     * Given a pair of coordinates (x, y), return the center of the grid square which contains that point
+     * @param x - Coordinate X.
+     * @param y - Coordinate Y.
+     * @returns An Array [x, y] of the central point of the square which contains (x, y)
+     */
+    getCenter(x: number, y: number): PointArray;
+
+    /**
+     * Measure the distance between two point coordinates.
+     * @param origin  - The origin point
+     * @param target  - The target point
+     * @param options - Additional options which modify the measurement
+     *                  (default: `{}`)
+     * @returns The measured distance between these points
+     *
+     * @example
+     * ```js
+     * let distance = canvas.grid.measureDistance({x: 1000, y: 1000}, {x: 2000, y: 2000});
+     * ```
+     */
+    measureDistance(
+      origin: {
+        x: number;
+        y: number;
+      },
+      target: {
+        x: number;
+        y: number;
+      },
+      options?: GridLayer.MeasureDistancesOptions,
+    ): number;
+
+    /**
+     * Measure the distance traveled over an array of distance segments.
+     * @param segments - An array of measured segments
+     * @param options  - Additional options which modify the measurement
+     *                   (default: `{}`)
+     */
+    measureDistances(segments: GridLayer.Segment[], options?: GridLayer.MeasureDistancesOptions): number[];
+
+    /**
+     * Define a new Highlight graphic
+     * @param name - The name for the referenced highlight layer
+     */
+    addHighlightLayer(name: string): GridHighlight;
+
+    /**
+     * Clear a specific Highlight graphic
+     * @param name - The name for the referenced highlight layer
+     */
+    clearHighlightLayer(name: string): void;
+
+    /**
+     * Destroy a specific Highlight graphic
+     * @param name - The name for the referenced highlight layer
+     */
+    destroyHighlightLayer(name: string): void;
+
+    /**
+     * Obtain the highlight layer graphic by name
+     * @param name - The name for the referenced highlight layer
+     */
+    getHighlightLayer(name: string): GridHighlight | undefined;
+
+    /**
+     * Add highlighting for a specific grid position to a named highlight graphic
+     * @param name    - The name for the referenced highlight layer
+     * @param options - Options for the grid position that should be highlighted
+     */
+    highlightPosition(name: string, options?: Parameters<BaseGrid["highlightGridPosition"]>[1]): false | void;
+
+    /**
+     * Test if a specific row and column position is a neighboring location to another row and column coordinate
+     * @param r0 - The original row position
+     * @param c0 - The original column position
+     * @param r1 - The candidate row position
+     * @param c1 - The candidate column position
+     */
+    isNeighbor(r0: number, c0: number, r1: number, c1: number): boolean;
+  }
+
+  namespace GridLayer {
+    interface LayerOptions extends CanvasLayer.LayerOptions {
+      name: "grid";
+    }
+
+    interface Segment {
+      ray: Ray;
+      label?: Ruler["labels"]["children"][number];
+    }
+
+    type DrawOptions = InexactPartial<{
+      /**
+       * @defaultValue `null`
+       */
+      type?: foundry.CONST.GRID_TYPES | null;
+
+      /**
+       * @defaultValue `null`
+       */
+      dimensions?: Canvas["dimensions"] | null;
+
+      color?: number | string | null;
+
+      alpha?: number | null;
+
+      /**
+       * @deprecated since v10, will be removed in v12
+       * @remarks "You are passing the gridColor parameter to GridLayer#draw which is deprecated in favor of the color parameter."
+       */
+      gridColor?: number | string | null;
+
+      /**
+       * @deprecated since v10, will be removed in v12
+       * @remarks "You are passing the gridAlpha parameter to GridLayer#draw which is deprecated in favor of the alpha parameter."
+       */
+      gridAlpha?: number | null;
+    }>;
+
+    type MeasureDistancesOptions = InexactPartial<{
+      /** Return the distance in grid increments rather than the co-ordinate distance. */
+      gridSpaces?: boolean;
+    }>;
+  }
+}

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

@@ -0,0 +1,6 @@
+import "./base/index.d.mts";
+import "./controls/index.d.mts";
+import "./effects/index.d.mts";
+import "./grid/index.d.mts";
+import "./masks/index.d.mts";
+import "./placeables/index.d.mts";

package/src/foundry/client/pixi/layers/masks/depth.d.mts

@@ -0,0 +1,37 @@
+export {};
+
+declare global {
+  /**
+   * The depth mask which contains a mapping of elevation. Needed to know if we must render objects according to depth.
+   */
+  class CanvasDepthMask extends CachedContainer {
+    /**
+     * Container in which roofs are rendered with depth data.
+     */
+    roofs: PIXI.Container;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *   format: PIXI.FORMATS.RGB
+     * }
+     * ```
+     */
+    static override textureConfiguration: {
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+    };
+
+    /**
+     * @defaultValue `[0, 0, 0, 0]`
+     */
+    override clearColor: [r: number, g: number, b: number, a: number];
+
+    /**
+     * Clear the depth mask.
+     */
+    clear(): void;
+  }
+}

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

@@ -0,0 +1,3 @@
+import "./depth.d.mts";
+import "./occlusion.d.mts";
+import "./vision.d.mts";

package/src/foundry/client/pixi/layers/masks/occlusion.d.mts

@@ -0,0 +1,55 @@
+export {};
+
+declare global {
+  /**
+   * The occlusion mask which contains radial occlusion and vision occlusion from tokens.
+   */
+  class CanvasOcclusionMask extends CachedContainer {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *   format: PIXI.FORMATS.RGB
+     * }
+     * ```
+     */
+    static override textureConfiguration: {
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+    };
+
+    /**
+     * Graphics in which token radial and vision occlusion shapes are drawn.
+     */
+    tokens: PIXI.LegacyGraphics;
+
+    /**
+     * @defaultValue `[1, 1, 1, 1]`
+     */
+    override clearColor: [r: number, g: number, b: number, a: number];
+
+    /**
+     * Clear the occlusion mask.
+     */
+    clear(): void;
+
+    /**
+     * Update the state of occlusion, rendering a new occlusion mask and updating the occluded flag on all Tiles.
+     */
+    updateOcclusion(): void;
+
+    /**
+     * Determine the set of objects which should be currently occluded by a Token.
+     * @param tokens - The set of currently controlled Token objects
+     * @returns The PCO objects which should be currently occluded
+     */
+    protected _identifyOccludedObjects(tokens: Token[]): Set<InstanceType<ReturnType<typeof PrimaryCanvasObjectMixin>>>;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"CanvasOcclusionMask#_identifyOccludedTiles has been deprecated in favor of CanvasOcclusionMask#_identifyOccludedObjects."`
+     */
+    _identifyOccludedTiles(): Set<typeof PrimaryCanvasObjectMixin>;
+  }
+}

package/src/foundry/client/pixi/layers/masks/vision.d.mts

@@ -0,0 +1,85 @@
+export {};
+
+declare global {
+  /**
+   * The vision mask which contains the current line-of-sight texture.
+   */
+  class CanvasVisionMask extends CachedContainer {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *    format: PIXI.FORMATS.RED
+     * }
+     * ```
+     */
+    static override textureConfiguration: {
+      multisample: PIXI.MSAA_QUALITY;
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+    };
+
+    /**
+     * @defaultValue `[0, 0, 0, 0]`
+     */
+    override clearColor: [r: number, g: number, b: number, a: number];
+
+    vision: CanvasVisionContainer;
+
+    /**
+     * The BlurFilter which applies to the vision mask texture.
+     * This filter applies a NORMAL blend mode to the container.
+     */
+    blurFilter: AlphaBlurFilter;
+
+    draw(): Promise<void>;
+
+    /**
+     * Initialize the vision mask with the los and the fov graphics objects.
+     * @param vision - The vision container to attach
+     */
+    attachVision(vision: PIXI.Container): CanvasVisionContainer;
+
+    /**
+     * Detach the vision mask from the cached container.
+     * @returns The detached vision container.
+     */
+    detachVision(): CanvasVisionContainer;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"CanvasVisionMask#filter has been renamed to blurFilter."`
+     */
+    get filter(): this["blurFilter"];
+
+    set filter(f);
+  }
+
+  interface CanvasVisionContainer {
+    /**
+     * LOS polygons
+     */
+    los: PIXI.Graphics;
+
+    /**
+     * Base vision
+     */
+    base: PIXI.Graphics;
+
+    /**
+     * FOV polygons
+     */
+    fov: PIXI.Graphics;
+
+    /**
+     * Alias of los
+     */
+    mask: PIXI.Graphics;
+
+    /**
+     * Does this vision point represent an explored position?
+     */
+    _explored: boolean;
+  }
+}

package/src/foundry/client/pixi/layers/placeables/drawings.d.mts

@@ -0,0 +1,92 @@
+export {};
+
+declare global {
+  /**
+   * The DrawingsLayer subclass of PlaceablesLayer.
+   */
+  class DrawingsLayer extends PlaceablesLayer<"Drawing"> {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["drawings"];
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: DrawingsLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```
+     * mergeObject(super.layerOptions, {
+     *   name: "drawings"
+     *   canDragCreate: true,
+     *   controllableObjects: true,
+     *   rotatableObjects: true,
+     *   zIndex: 20
+     * })
+     * ```
+     */
+    static override get layerOptions(): DrawingsLayer.LayerOptions;
+
+    static override documentName: "Drawing";
+
+    /**
+     * The named game setting which persists default drawing configuration for the User
+     */
+    static DEFAULT_CONFIG_SETTING: "defaultDrawingConfig";
+
+    /**
+     * Use an adaptive precision depending on the size of the grid
+     */
+    get gridPrecision(): 0 | 8 | 16;
+
+    override get hud(): Exclude<Canvas["hud"], undefined>["drawing"];
+
+    override get hookName(): (typeof DrawingsLayer)["name"];
+
+    /**
+     * Render a configuration sheet to configure the default Drawing settings
+     */
+    configureDefault(): void;
+
+    override _deactivate(): this;
+
+    /**
+     * Get initial data for a new drawing.
+     * Start with some global defaults, apply user default config, then apply mandatory overrides per tool.
+     * @param origin - The initial coordinate
+     * @returns The new drawing data
+     * @remarks This is used from DrawingConfig and hence public on purpose.
+     */
+    _getNewDrawingData(origin: Point): foundry.documents.BaseDrawing.ConstructorData;
+
+    protected override _onClickLeft(event: PIXI.FederatedEvent): void;
+
+    protected override _onClickLeft2(event: PIXI.FederatedEvent): void | Promise<void>;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): ReturnType<Drawing["draw"]>;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handling of mouse-up events which conclude a new object creation after dragging
+     */
+    protected _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<void>;
+
+    protected override _onDragLeftCancel(event: PointerEvent): void;
+
+    protected override _onClickRight(event: PIXI.FederatedEvent): void;
+  }
+
+  namespace DrawingsLayer {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Drawing"> {
+      name: "drawings";
+      canDragCreate: true;
+      controllableObjects: true;
+      rotatableObjects: true;
+      elevationSorting: true;
+      zIndex: 20;
+    }
+  }
+}

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

@@ -0,0 +1,8 @@
+import "./drawings.d.mts";
+import "./lighting.d.mts";
+import "./notes.d.mts";
+import "./sounds.d.mts";
+import "./templates.d.mts";
+import "./tiles.d.mts";
+import "./tokens.d.mts";
+import "./walls.d.mts";

package/src/foundry/client/pixi/layers/placeables/lighting.d.mts

@@ -0,0 +1,137 @@
+export {};
+
+/**
+ * The Lighting Layer which ambient light sources as part of the CanvasEffectsGroup.
+ */
+declare global {
+  class LightingLayer extends PlaceablesLayer<"AmbientLight"> {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["lighting"];
+
+    static override documentName: "AmbientLight";
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: LightingLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *  name: "lighting",
+     *  rotatableObjects: true,
+     *  zIndex: 300
+     * })
+     * ```
+     */
+    static override get layerOptions(): LightingLayer.LayerOptions;
+
+    override get hookName(): string;
+
+    override _activate(): void;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): ReturnType<AmbientLight["draw"]>;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): Promise<void>;
+
+    protected override _onDragLeftCancel(event: PointerEvent): Promise<void>;
+
+    protected _onMouseWheel(event: WheelEvent): void;
+
+    /**
+     * Actions to take when the darkness level of the Scene is changed
+     * @param darkness - The new darkness level
+     * @param prior    - The prior darkness level
+     */
+    protected _onDarknessChange(darkness: number, prior: number): void;
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#background has been refactored to EffectsCanvasGroup#background"
+     */
+    get background(): EffectsCanvasGroup["background"];
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#illumination has been refactored to EffectsCanvasGroup#illumination"
+     */
+    get illumination(): EffectsCanvasGroup["illumination"];
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#channels has been refactored to EffectsCanvasGroup#lightingChannelColors"
+     * @remarks lightingChannelColors was removed in v11 without this deprecation being updated
+     */
+    get channels(): undefined;
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#coloration has been refactored to EffectsCanvasGroup#coloration"
+     */
+    get coloration(): EffectsCanvasGroup["coloration"];
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#darknessLevel has been refactored to Canvas#darknessLevel"
+     */
+    get darknessLevel(): Canvas["darknessLevel"];
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#globalLight has been refactored to CanvasIlluminationEffects#globalLight"
+     */
+    get globalLight(): CanvasIlluminationEffects["globalLight"];
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#sources has been refactored to EffectsCanvasGroup#lightSources"
+     */
+    get sources(): EffectsCanvasGroup["lightSources"];
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#version has been refactored to EffectsCanvasGroup#lightingVersion"
+     * @remarks lightingVersion was removed in v11 without this deprecation being updated
+     */
+    get version(): undefined;
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#activateAnimation has been refactored to EffectsCanvasGroup#activateAnimation"
+     */
+    activateAnimation(): void;
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#deactivateAnimation has been refactored to EffectsCanvasGroup#deactivateAnimation"
+     */
+    deactivateAnimation(): void;
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#animateDarkness has been refactored to EffectsCanvasGroup#animateDarkness"
+     */
+    animateDarkness: EffectsCanvasGroup["animateDarkness"];
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#initializeSources has been refactored to EffectsCanvasGroup#initializeLightSources"
+     */
+    initializeSources(): ReturnType<EffectsCanvasGroup["initializeLightSources"]>;
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "LightingLayer#refresh has been refactored to EffectsCanvasGroup#refreshLighting"
+     */
+    refresh: EffectsCanvasGroup["refreshLighting"];
+  }
+
+  namespace LightingLayer {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"AmbientLight"> {
+      name: "lighting";
+    }
+  }
+}