@league-of-foundry-developers/foundry-vtt-types 9.255.3 → 9.268.2

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/sightLayer.d.ts → client/pixi/layers/sight.d.ts}

@@ -4,28 +4,42 @@
  * @see PointSource
  *
  * The container structure of this layer is as follows:
- * sight: SightLayer              The SightLayer itself
- *   msk: PIXI.Graphics           A masking rectangle that restricts exploration to the scene background
- *   unexplored: PIXI.Graphics    An unexplored background that spans the entire scene canvas
- *   explored: PIXI.Container     The exploration container
- *      revealed: PIXI.Container  The container of areas which have been previously revealed
- *        saved: PIXI.Sprite      The saved FOW exploration texture from the database
- *        pending: PIXI.Container A container of pending exploration polygons that have not yet been saved
- *        roofs: PIXI.Container   A container of occluded roof sprites which should not be marked as explored
- *      current: PIXI.Container   The current vision container
- *        los: PIXI.Graphics      The current line-of-sight polygon
- *        fov: PIXI.Graphics      The current filed-of-view polygon
- *      msk: PIXI.Graphics        The masking rectangle that limits exploration to the Scene background
+ *
+ * unexplored   The unexplored background which spans the entire canvas
+ * explored     The exploration container which tracks exploration progress
+ * revealed       A container of regions which have previously been revealed
+ * saved          The saved fog exploration texture
+ * pending        Pending exploration which has not yet been committed to the texture
+ * vision         The container of current vision exploration
+ * vision.base      Baseline provided vision
+ * vision.fov       Current light source field-of-view polygons
+ * vision.los       Current vision source line-of-sight polygons
+ * vision.roofs     Roof textures which should temporarily be revealed
  *
  * @example <caption>The sightRefresh hook</caption>
  * ```typescript
  * Hooks.on("sightRefresh", layer => {});
  * ```
  */
-import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
 
 declare global {
   class SightLayer extends CanvasLayer<SightLayer.LayerOptions> {
+    /** The unexplored background which spans the entire canvas */
+    unexplored?: PIXI.Graphics;
+
+    /** The exploration container which tracks exploration progress */
+    explored?: PIXI.Container;
+
+    /** A container of regions which have previously been revealed */
+    revealed?: PIXI.Container;
+
+    /** The saved fog exploration texture */
+    saved?: PIXI.Sprite;
+
+    /** Pending exploration which has not yet been committed to the texture */
+    pending?: PIXI.Container;
+
     constructor();
 
     /**
@@ -39,46 +53,78 @@ declare global {
      */
     sources: foundry.utils.Collection<PointSource>;
 
-    /**
-     * The canonical line-of-sight polygon which defines current Token visibility.
-     */
-    los: PIXI.Graphics;
-
     /**
      * A status flag for whether the layer initialization workflow has succeeded
      * @defaultValue `false`
+     * @internal
      */
     protected _initialized: boolean;
 
     /**
-     * A pool of fog of war exploration containers that can be recycled
-     * @defaultValue `[]`
+     * A debounced function to save fog of war exploration once a stream of updates have stopped
      */
-    protected _visionPool: PIXI.Container[];
+    debounceSaveFog: (...args: Parameters<this['saveFog']>) => void;
 
     /**
-     * Track whether fog of war exploration has been updated and required saving
-     * @defaultValue `false`
+     * The current vision container which provides line-of-sight for vision sources and field-of-view of light sources.
+     * @defaultValue `undefined`
      */
-    protected _fogUpdated: boolean;
+    vision:
+      | (PIXI.Container & {
+          /** Baseline provided vision */
+          base: PIXI.Graphics;
+
+          /** Current light source field-of-view polygons */
+          fov: PIXI.Container;
+
+          /** Current vision source line-of-sight polygons */
+          los: PIXI.Graphics;
+
+          /** Roof textures which should temporarily be revealed */
+          roofs: PIXI.Container;
+        })
+      | undefined;
 
     /**
-     * Track the number of moves which have updated fog of war
-     * @defaultValue `0`
+     * The canonical line-of-sight polygon which defines current Token visibility.
+     * @defaultValue `undefined`
      */
-    protected _fogUpdates: number;
+    los: PIXI.Graphics | undefined;
 
     /**
-     * A debounced function to save fog of war exploration once a stream of updates have stopped
+     * A cached container which creates a render texture used for the LOS mask.
+     * @defaultValue `undefined`
      */
-    debounceSaveFog: (...args: Parameters<this['saveFog']>) => void;
+    losCache: CachedContainer | undefined;
+
+    /**
+     * Track whether we have pending fog updates which have not yet been saved to the database
+     * @defaultValue `false`
+     * @internal
+     */
+    protected _fogUpdated: boolean;
 
     /**
      * The configured resolution used for the saved fog-of-war texture
      * @defaultValue `undefined`
+     * @internal
      */
     protected _fogResolution: { resolution: number; width: number; height: number } | undefined;
 
+    /**
+     * A pool of RenderTexture objects which can be cycled through to save fog exploration progress.
+     * @defaultValue `[]`
+     * @internal
+     */
+    protected _fogTextures: PIXI.RenderTexture[];
+
+    /**
+     * Track whether there is a source of vision within the buffer region outside the primary scene canvas
+     * @defaultValue `false`
+     * @internal
+     */
+    protected _inBuffer: boolean;
+
     /**
      * Define the threshold value for the number of distinct Wall endpoints.
      * Below this threshold, exact vision computation is used by casting a Ray at every endpoint.
@@ -93,13 +139,18 @@ declare global {
      */
     static FOG_COMMIT_THRESHOLD: number;
 
+    /**
+     * The maximum allowable fog of war texture size.
+     * @defaultValue `4096`
+     */
+    static MAXIMUM_FOW_TEXTURE_SIZE: number;
+
     /**
      * @remarks This is not overridden in foundry but reflects the real behavior.
      */
     static get instance(): Canvas['sight'];
 
     /**
-     * @override
      * @defaultValue
      * ```typescript
      * foundry.utils.mergeObject(super.layerOptions, {
@@ -108,7 +159,7 @@ declare global {
      * })
      * ```
      */
-    static get layerOptions(): SightLayer.LayerOptions;
+    static override get layerOptions(): SightLayer.LayerOptions;
 
     /**
      * Does the currently viewed Scene support Token field of vision?
@@ -120,20 +171,7 @@ declare global {
      */
     get fogExploration(): boolean;
 
-    /** @override */
-    tearDown(): Promise<this>;
-
-    /**
-     * Initialize the Sight Layer. Initialization has the following hierarchical workflow:
-     *
-     * Initialize Layer (reset entire layer)
-     *  InitializeLights (used to reset all lights)
-     *    UpdateLight (update a single light)
-     *  InitializeTokens (reset all tokens)
-     *    UpdateToken (update a single token)
-     *  Initialize Fog (reset FOW state)
-     */
-    initialize(): Promise<void>;
+    override tearDown(): Promise<this>;
 
     /**
      * Initialize fog of war - resetting it when switching scenes or re-drawing the canvas
@@ -145,42 +183,44 @@ declare global {
      */
     initializeSources(): Promise<void>;
 
-    /** @override */
-    draw(): Promise<this>;
-
     /**
-     * Construct a vision container that is used to render a single view position.
-     * These containers are placed into the _visionPool and recycled as needed.
+     * Update FoW unexplored and explored colors
      */
-    protected _createVisionContainer(): PIXI.Container;
+    updateFogExplorationColors(): void;
+
+    override draw(): Promise<this>;
 
     /**
-     * Obtain a vision container from the recycling pool, or create one if no container exists.
-     * Assign the container as the current fog exploration and the current LOS polygon.
+     * Create the cached container and sprite used to provide a LOS mask
+     * @internal
      */
-    protected _getVisionContainer(): PIXI.Container;
+    protected _createCachedMask(): void;
 
     /**
-     * Return a vision container back to the pool, recycling it for future use.
-     * @param c - The container to recycle
+     * Construct a vision container that is used to render a single view position.
+     * @internal
      */
-    protected _recycleVisionContainer(c: PIXI.Container): void;
+    protected _createVisionContainer(): PIXI.Container;
 
     /**
      * Update the display of the sight layer.
      * Organize sources into rendering queues and draw lighting containers for each source
-     *
-     * @param forceUpdateFog - Always update the Fog exploration progress for this update
-     *                         (default: `false`)
-     * @param noUpdateFog    - Never update the Fog exploration progress for this update
-     *                         (default: `false`)
      */
     refresh({
       forceUpdateFog,
-      noUpdateFog
+      skipUpdateFog
     }?: {
+      /**
+       * Always update the Fog exploration progress for this update
+       * (default: `false`)
+       */
       forceUpdateFog?: boolean;
-      noUpdateFog?: boolean;
+
+      /**
+       * Never update the Fog exploration progress for this update
+       * (default: `false`)
+       */
+      skipUpdateFog?: boolean;
     }): void | ReturnType<this['restrictVisibility']>;
 
     /**
@@ -192,21 +232,34 @@ declare global {
     /**
      * Test whether a point on the Canvas is visible based on the current vision and LOS polygons
      *
-     * @param point     - The point in space to test, an object with coordinates x and y.
-     * @param tolerance - A numeric radial offset which allows for a non-exact match. For example, if
-     *                    tolerance is 2 then the test will pass if the point is within 2px of a vision
-     *                    polygon.
-     *                    (defaultValue: `2`)
-     * @param object    - An optional reference to the object whose visibility is being tested
-     *                    (defaultValue: `null`)
-     *
+     * @param point - The point in space to test, an object with coordinates x and y.
      * @returns Whether the point is currently visible.
      */
     testVisibility(
       point: Point,
-      { tolerance, object }?: { tolerance?: number; object?: PIXI.DisplayObject | null }
+      {
+        tolerance,
+        object
+      }?: {
+        /**
+         * A numeric radial offset which allows for a non-exact match. For example, if
+         * tolerance is 2 then the test will pass if the point is within 2px of a vision
+         * polygon.
+         * (defaultValue: `2`)
+         */
+        tolerance?: number;
+
+        /**
+         * An optional reference to the object whose visibility is being tested
+         * (defaultValue: `null`)
+         */
+        object?: PIXI.DisplayObject | null;
+      }
     ): boolean;
 
+    /** @internal */
+    protected _getFogTexture(): PIXI.RenderTexture;
+
     /**
      * Once a new Fog of War location is explored, composite the explored container with the current staging sprite
      * Save that staging Sprite as the rendered fog exploration and swap it out for a fresh staging texture
@@ -242,6 +295,7 @@ declare global {
     /**
      * Choose an adaptive fog rendering resolution which downscales the saved fog textures for larger dimension Scenes.
      * It is important that the width and height of the fog texture is evenly divisible by the downscaling resolution.
+     * @internal
      */
     protected _configureFogResolution(): { resolution: number; width: number; height: number };
 
@@ -249,50 +303,11 @@ declare global {
      * If fog of war data is reset from the server, re-draw the canvas
      */
     protected _handleResetFog(): Promise<void>;
-
-    /**
-     * Visualize the sight layer to understand algorithm performance.
-     * @param bounds    - The initial rectangular bounds of the vision check
-     * @param endpoints - The wall endpoints being tested
-     * @param rays      - The array of cast vision Rays
-     * @param los       - The resulting line-of-sight polygon
-     * @param fov       - The resulting field-of-vision polygon
-     */
-    protected static _visualizeSight(
-      bounds: Rectangle,
-      endpoints: PointArray[],
-      rays: Ray[],
-      los: PIXI.Polygon,
-      fov: PIXI.Polygon
-    ): void;
-
-    /**
-     * @deprecated since 0.8.2
-     * @see WallsLayer#computePolygon
-     * Compute line-of-sight and field-of-vision polygons for a given origin position and visibility radius.
-     * The line-of-sight polygon defines the unrestricted area of visibility for the source.
-     * The field-of-vision polygon defines the restricted area of visibility for the source.
-     * @param angle        - (default: `360`)
-     * @param density      - (default: `6`)
-     * @param rotation     - (default: `0`)
-     * @param unrestricted - (default: `false`)
-     */
-    static computeSight(
-      origin: Point,
-      radius: number,
-      {
-        angle,
-        density,
-        rotation,
-        unrestricted
-      }?: { angle?: number; density?: number; rotation?: number; unrestricted?: boolean }
-    ): { rays: Ray[]; los: PIXI.Polygon; fov: PIXI.Polygon };
   }
 
   namespace SightLayer {
     interface LayerOptions extends CanvasLayer.LayerOptions {
       name: 'sight';
-      zIndex: 400;
     }
   }
 }

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/soundsLayer.d.ts → client/pixi/layers/sounds.d.ts}

@@ -9,13 +9,18 @@ declare class SoundsLayer extends PlaceablesLayer<'AmbientSound', SoundsLayer.La
    */
   livePreview: boolean;
 
+  /**
+   * A mapping of ambient audio sources which are active within the rendered Scene
+   * @defaultValue `new foundry.utils.Collection()`
+   */
+  sources: foundry.utils.Collection<SoundSource>;
+
   /**
    * @remarks This is not overridden in foundry but reflects the real behavior.
    */
   static get instance(): Canvas['sounds'];
 
   /**
-   * @override
    * @defaultValue
    * ```
    * foundry.utils.mergeObject(super.layerOptions, {
@@ -24,13 +29,12 @@ declare class SoundsLayer extends PlaceablesLayer<'AmbientSound', SoundsLayer.La
    * })
    * ```
    * */
-  static get layerOptions(): SoundsLayer.LayerOptions;
 
-  /** @override */
-  static documentName: 'AmbientSound';
+  static override get layerOptions(): SoundsLayer.LayerOptions;
+
+  static override documentName: 'AmbientSound';
 
-  /** @override */
-  tearDown(): Promise<this>;
+  override tearDown(): Promise<this>;
 
   /**
    * Initialize all AmbientSound sources which are present on this layer
@@ -84,22 +88,20 @@ declare class SoundsLayer extends PlaceablesLayer<'AmbientSound', SoundsLayer.La
    */
   protected _onMouseMove(event: PIXI.InteractionEvent): void;
 
-  /** @override */
-  protected _onDragLeftStart(event: PIXI.InteractionEvent): ReturnType<AmbientSound['draw']>;
+  protected override _onDragLeftStart(event: PIXI.InteractionEvent): ReturnType<AmbientSound['draw']>;
 
-  /** @override */
-  protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+  protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
-  /** @override */
-  protected _onDragLeftDrop(event: PIXI.InteractionEvent): void;
+  protected override _onDragLeftDrop(event: PIXI.InteractionEvent): void;
 
-  /** @override */
-  protected _onDragLeftCancel(event: PointerEvent): void;
+  protected override _onDragLeftCancel(event: PointerEvent): void;
 
   /**
-   * @deprecated since 0.8.2
+   * Handle PlaylistSound document drop data.
+   * @param event - The drag drop event
+   * @param data  - The dropped transfer data.
    */
-  update(options?: { fade?: number }): ReturnType<this['refresh']>;
+  protected _onDropData(event: DragEvent, data: unknown): Promise<void>;
 }
 
 declare namespace SoundsLayer {

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/templateLayer.d.ts → client/pixi/layers/templates.d.ts}

@@ -9,7 +9,6 @@ declare class TemplateLayer extends PlaceablesLayer<'MeasuredTemplate', Template
   static get instance(): Canvas['templates'];
 
   /**
-   * @override
    * @defaultValue
    * ```
    * mergeObject(super.layerOptions, {
@@ -21,32 +20,24 @@ declare class TemplateLayer extends PlaceablesLayer<'MeasuredTemplate', Template
    * })
    * ```
    */
-  static get layerOptions(): TemplateLayer.LayerOptions;
+  static override get layerOptions(): TemplateLayer.LayerOptions;
 
-  /** @override */
-  static documentName: 'MeasuredTemplate';
+  static override documentName: 'MeasuredTemplate';
 
-  /** @override */
-  activate(): this;
+  override activate(): this;
 
-  /** @override */
-  deactivate(): this;
+  override deactivate(): this;
 
   /**
    * Register game settings used by the TemplatesLayer
    */
   static registerSettings(): void;
 
-  /** @override */
-  protected _onDragLeftStart(event: PIXI.InteractionEvent): Promise<MeasuredTemplate>;
+  protected override _onDragLeftStart(event: PIXI.InteractionEvent): Promise<MeasuredTemplate>;
 
-  /** @override */
-  protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+  protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
-  /**
-   * @override
-   */
-  protected _onMouseWheel(event: WheelEvent): void | ReturnType<MeasuredTemplate['rotate']>;
+  protected override _onMouseWheel(event: WheelEvent): void | ReturnType<MeasuredTemplate['rotate']>;
 }
 
 declare namespace TemplateLayer {

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/tokenLayer.d.ts → client/pixi/layers/tokens.d.ts}

@@ -1,5 +1,5 @@
-import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../../../types/helperTypes';
-import { SelectOptions } from '../placeablesLayer';
+import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../types/helperTypes';
+import { SelectOptions } from '../placeables';
 
 declare global {
   /**
@@ -26,7 +26,6 @@ declare global {
     static get instance(): Canvas['tokens'];
 
     /**
-     * @override
      * @defaultValue
      * ```typescript
      * foundry.utils.mergeObject(super.layerOptions, {
@@ -38,15 +37,11 @@ declare global {
      * })
      * ```
      */
-    static get layerOptions(): TokenLayer.LayerOptions;
+    static override get layerOptions(): TokenLayer.LayerOptions;
 
-    /**
-     * @override
-     */
-    static documentName: 'Token';
+    static override documentName: 'Token';
 
-    /** @override */
-    get gridPrecision(): 1;
+    override get gridPrecision(): 1;
 
     /**
      * Token objects on this layer utilize the TokenHUD
@@ -58,35 +53,49 @@ declare global {
      */
     get ownedTokens(): ReturnType<this['placeables']['filter']>;
 
-    /** @override */
-    tearDown(): Promise<this>;
+    override tearDown(): Promise<this>;
 
-    /** @override */
-    activate(): this;
+    override activate(): this;
 
-    /** @override */
-    deactivate(): this;
+    override deactivate(): this;
 
     /**
-     * @override
      * @param options - (default: `{}`)
      */
-    selectObjects(options?: SelectOptions): boolean;
+    override selectObjects(options?: SelectOptions): boolean;
 
     /**
      * Target all Token instances which fall within a coordinate rectangle.
-     *
-     * @param x             - The top-left x-coordinate of the selection rectangle
-     * @param y             - The top-left y-coordinate of the selection rectangle
-     * @param width         - The width of the selection rectangle
-     * @param height        - The height of the selection rectangle
-     * @param releaseOthers - Whether or not to release other targeted tokens
-     *                        (default: `true`)
      * @returns The number of Token instances which were targeted.
      */
     targetObjects(
-      { x, y, width, height }: { x: number; y: number; width: number; height: number },
-      { releaseOthers }?: { releaseOthers?: boolean }
+      {
+        x,
+        y,
+        width,
+        height
+      }: {
+        /** The top-left x-coordinate of the selection rectangle */
+        x: number;
+
+        /** The top-left y-coordinate of the selection rectangle */
+        y: number;
+
+        /** The width of the selection rectangle */
+        width: number;
+
+        /** The height of the selection rectangle */
+        height: number;
+      },
+      {
+        releaseOthers
+      }?: {
+        /**
+         * Whether or not to release other targeted tokens
+         * @defaultValue `true`
+         */
+        releaseOthers?: boolean;
+      }
     ): number;
 
     /**
@@ -105,21 +114,21 @@ declare global {
      *                  (default: `true`)
      * @param  combat - A Combat encounter from which to add or remove the Token
      *                  (default: `null`)
-     * @param  token  - A specific Token which is the origin of the group toggle request
-     *                  (default: `null`)
-     * @returns The updated Combat encounter
-     * @remarks Returns the created Combatants or undefined if there is no combat and one can't be created
-     *          or the combat if the user is no GM and wants to remove combatants.
+     * @returns The Combatants added or removed
      */
     toggleCombat(
       state?: boolean,
       combat?: InstanceType<ConfiguredDocumentClass<typeof Combat>> | null,
-      { token }?: { token?: InstanceType<ConfiguredObjectClassForName<'Token'>> | null }
-    ): Promise<
-      | InstanceType<ConfiguredDocumentClass<typeof Combat>>
-      | InstanceType<ConfiguredDocumentClass<typeof Combatant>>[]
-      | void
-    >;
+      {
+        token
+      }?: {
+        /**
+         * A specific Token which is the origin of the group toggle request
+         * @defaultValue `null`
+         */
+        token?: InstanceType<ConfiguredObjectClassForName<'Token'>> | null;
+      }
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Combatant>>[]>;
 
     /**
      * Get the tab cycle order for tokens by sorting observable tokens based on their distance from top-left.
@@ -138,6 +147,8 @@ declare global {
       event: DragEvent,
       data: TokenLayer.DropData
     ): Promise<void | false | InstanceType<ConfiguredObjectClassForName<'Token'>>>;
+
+    protected override _onClickLeft(event: PIXI.InteractionEvent): void;
   }
 
   namespace TokenLayer {