@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

package/src/foundry/client/pixi/perception/detection-mode.d.mts

@@ -1,24 +1,9 @@
-import type { InexactPartial, ValueOf } from "fvtt-types/utils";
-import type { fields } from "../../../common/data/_module.d.mts";
-import type { TokenDetectionMode } from "../../../common/documents/_types.d.mts";
-
-type DataSchema = foundry.data.fields.DataSchema;
+import type { Brand, Identity, NullishProps } from "fvtt-types/utils";
+import type { fields } from "#common/data/_module.d.mts";
+import type { TokenDetectionMode } from "#common/documents/_types.d.mts";
+import type { DataSchema } from "#common/data/fields.d.mts";
 
 declare global {
-  namespace DetectionMode {
-    interface Schema extends DataSchema {
-      id: fields.StringField<{ blank: false }>;
-      label: fields.StringField<{ blank: false }>;
-      tokenConfig: fields.BooleanField<{ initial: true }>;
-      walls: fields.BooleanField<{ initial: true }>;
-      angle: fields.BooleanField<{ initial: true }>;
-      type: fields.NumberField<{
-        initial: typeof DetectionMode.DETECTION_TYPES.SIGHT;
-        choices: ValueOf<typeof DetectionMode.DETECTION_TYPES>[];
-      }>;
-    }
-  }
-
   /**
    * A Detection Mode which can be associated with any kind of sense/vision/perception.
    * A token could have multiple detection modes.
@@ -38,23 +23,15 @@ declare global {
 
     /**
      * The type of the detection mode.
-     * @see CONST.WALL_RESTRICTION_TYPES
+     * @see {@link CONST.WALL_RESTRICTION_TYPES | `CONST.WALL_RESTRICTION_TYPES`}
+     * @remarks Set via `Object.defineProperty` with a frozen object, so `readonly` is justified both here and for the interface properties
      */
-    static DETECTION_TYPES: {
-      /** Sight, and anything depending on light perception */
-      SIGHT: 0;
-      /** What you can hear. Includes echolocation for bats per example */
-      SOUND: 1;
-      /** This is mostly a sense for touch and vibration, like tremorsense, movement detection, etc. */
-      MOVE: 2;
-      /** Can't fit in other types (smell, life sense, trans-dimensional sense, sense of humor...) */
-      OTHER: 3;
-    };
+    static readonly DETECTION_TYPES: DetectionMode.DetectionTypes;
 
     /**
      * The identifier of the basic sight detection mode.
      */
-    static BASIC_MODE_ID: "basicSight";
+    static readonly BASIC_MODE_ID: "basicSight";
 
     /**
      * Test visibility of a target object or array of points for a specific vision source.
@@ -66,7 +43,7 @@ declare global {
     testVisibility(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
       mode: TokenDetectionMode,
-      { object, tests }: InexactPartial<CanvasVisibilityTestConfig>,
+      { object, tests }: DetectionMode.TestConfig, // not:null (destructured)
     ): boolean;
 
     /**
@@ -76,7 +53,10 @@ declare global {
      * @param target       - The target object being tested
      * @returns Can the target object theoretically be detected by this vision source?
      */
-    protected _canDetect(visionSource: foundry.canvas.sources.PointVisionSource.Any, target: PlaceableObject): boolean;
+    protected _canDetect(
+      visionSource: foundry.canvas.sources.PointVisionSource.Any,
+      target: CanvasVisibility.TestObject,
+    ): boolean;
 
     /**
      * Evaluate a single test point to confirm whether it is visible.
@@ -89,8 +69,8 @@ declare global {
     protected _testPoint(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
       mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
+      target: CanvasVisibility.TestObject,
+      test: CanvasVisibility.Test,
     ): boolean;
 
     /**
@@ -106,8 +86,8 @@ declare global {
     protected _testLOS(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
       mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
+      target: CanvasVisibility.TestObject,
+      test: CanvasVisibility.Test,
     ): boolean;
 
     /**
@@ -121,8 +101,8 @@ declare global {
     protected _testAngle(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
       mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
+      target: CanvasVisibility.TestObject,
+      test: CanvasVisibility.Test,
     ): boolean;
 
     /**
@@ -136,11 +116,54 @@ declare global {
     protected _testRange(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
       mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
+      target: CanvasVisibility.TestObject,
+      test: CanvasVisibility.Test,
     ): boolean;
   }
 
+  namespace DetectionMode {
+    interface Any extends AnyDetectionMode {}
+    interface AnyConstructor extends Identity<typeof AnyDetectionMode> {}
+
+    interface Schema extends DataSchema {
+      id: fields.StringField<{ blank: false }>;
+
+      label: fields.StringField<{ blank: false }>;
+
+      /** If this DM is available in Token Config UI */
+      tokenConfig: fields.BooleanField<{ initial: true }>;
+
+      /** If this DM is constrained by walls */
+      walls: fields.BooleanField<{ initial: true }>;
+
+      /** If this DM is constrained by the vision angle */
+      angle: fields.BooleanField<{ initial: true }>;
+
+      type: fields.NumberField<{
+        initial: DetectionMode.DETECTION_TYPES;
+        choices: DetectionMode.DETECTION_TYPES[];
+      }>;
+    }
+
+    /** @see CanvasVisibility.TestConfig */
+    interface TestConfig
+      extends CanvasVisibility._TestConfigRequired,
+        NullishProps<CanvasVisibility._TestConfigOptional> {}
+
+    type DETECTION_TYPES = Brand<number, "DetectionMode.DETECTION_TYPES">;
+
+    interface DetectionTypes {
+      /** Sight, and anything depending on light perception */
+      readonly SIGHT: 0 & DETECTION_TYPES;
+      /** What you can hear. Includes echolocation for bats per example */
+      readonly SOUND: 1 & DETECTION_TYPES;
+      /** This is mostly a sense for touch and vibration, like tremorsense, movement detection, etc. */
+      readonly MOVE: 2 & DETECTION_TYPES;
+      /** Can't fit in other types (smell, life sense, trans-dimensional sense, sense of humor...) */
+      readonly OTHER: 3 & DETECTION_TYPES;
+    }
+  }
+
   /**
    * This detection mode tests whether the target is visible due to being illuminated by a light source.
    * By default tokens have light perception with an infinite range if light perception isn't explicitely
@@ -149,17 +172,22 @@ declare global {
   class DetectionModeLightPerception extends DetectionMode {
     protected override _canDetect(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
+      target: CanvasVisibility.TestObject,
     ): boolean;
 
     protected override _testPoint(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
       mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
+      target: CanvasVisibility.TestObject,
+      test: CanvasVisibility.Test,
     ): boolean;
   }
 
+  namespace DetectionModeLightPerception {
+    interface Any extends AnyDetectionModeLightPerception {}
+    interface AnyConstructor extends Identity<typeof AnyDetectionModeLightPerception> {}
+  }
+
   /**
    * A special detection mode which models a form of darkvision (night vision).
    * This mode is the default case which is tested first when evaluating visibility of objects.
@@ -168,10 +196,15 @@ declare global {
   class DetectionModeBasicSight extends DetectionMode {
     protected override _canDetect(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
+      target: CanvasVisibility.TestObject,
     ): boolean;
   }
 
+  namespace DetectionModeBasicSight {
+    interface Any extends AnyDetectionModeBasicSight {}
+    interface AnyConstructor extends Identity<typeof AnyDetectionModeBasicSight> {}
+  }
+
   /**
    * Detection mode that see invisible creatures.
    * This detection mode allows the source to:
@@ -179,36 +212,75 @@ declare global {
    * - The "See" version needs sight and is affected by blindness
    */
   class DetectionModeInvisibility extends DetectionMode {
-    static override getDetectionFilter(): PIXI.Filter | undefined;
+    static override getDetectionFilter(): PIXI.Filter;
 
     protected override _canDetect(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
+      target: CanvasVisibility.TestObject,
     ): boolean;
   }
 
+  namespace DetectionModeInvisibility {
+    interface Any extends AnyDetectionModeInvisibility {}
+    interface AnyConstructor extends Identity<typeof AnyDetectionModeInvisibility> {}
+  }
+
   /**
    * Detection mode that see creatures in contact with the ground.
    */
   class DetectionModeTremor extends DetectionMode {
-    static override getDetectionFilter(): PIXI.Filter | undefined;
+    static override getDetectionFilter(): PIXI.Filter;
 
     protected override _canDetect(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
+      target: CanvasVisibility.TestObject,
     ): boolean;
   }
 
+  namespace DetectionModeTremor {
+    interface Any extends AnyDetectionModeTremor {}
+    interface AnyConstructor extends Identity<typeof AnyDetectionModeTremor> {}
+  }
+
   /**
    * Detection mode that see ALL creatures (no blockers).
    * If not constrained by walls, see everything within the range.
    */
   class DetectionModeAll extends DetectionMode {
-    static override getDetectionFilter(): PIXI.Filter | undefined;
+    static override getDetectionFilter(): PIXI.Filter;
 
     protected override _canDetect(
       visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
+      target: CanvasVisibility.TestObject,
     ): boolean;
   }
+
+  namespace DetectionModeAll {
+    interface Any extends AnyDetectionModeAll {}
+    interface AnyConstructor extends Identity<typeof AnyDetectionModeAll> {}
+  }
+}
+
+declare abstract class AnyDetectionMode extends DetectionMode {
+  constructor(...args: never);
+}
+
+declare abstract class AnyDetectionModeLightPerception extends DetectionModeLightPerception {
+  constructor(...args: never);
+}
+
+declare abstract class AnyDetectionModeBasicSight extends DetectionModeBasicSight {
+  constructor(...args: never);
+}
+
+declare abstract class AnyDetectionModeInvisibility extends DetectionModeInvisibility {
+  constructor(...args: never);
+}
+
+declare abstract class AnyDetectionModeTremor extends DetectionModeTremor {
+  constructor(...args: never);
+}
+
+declare abstract class AnyDetectionModeAll extends DetectionModeAll {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/perception/fog.d.mts

@@ -1,31 +1,35 @@
-import type { DisplayObject } from "pixi.js";
+import type EventEmitterMixin from "#common/utils/event-emitter.mjs";
+import type { FixedInstanceType, Identity } from "fvtt-types/utils";
 
 declare global {
   /**
    * A fog of war management class which is the singleton canvas.fog instance.
    */
-  class FogManager {
+  class FogManager extends EventEmitterMixin() {
     /**
      * The FogExploration document which applies to this canvas view
      * @defaultValue `null`
      */
-    exploration: FogExploration | null;
+    exploration: FogExploration.Implementation | null;
 
     /**
      * Track whether we have pending fog updates which have not yet been saved to the database
      * @defaultValue `false`
+     * @remarks Foundry marked `@internal`
      */
-    _updated: boolean;
+    protected _updated: boolean;
 
     /**
      * Texture extractor
+     * @remarks Only `undefined` before first `#initialize()`ation. Set to `null` if `TextureExtractor` creation fails, and will not retry from that state.
      */
-    get extractor(): TextureExtractor;
+    get extractor(): TextureExtractor | undefined | null;
 
     /**
      * Define the number of fog refresh needed before the fog texture is extracted and pushed to the server.
+     * @defaultValue `70`
      */
-    static COMMIT_THRESHOLD: 70;
+    static COMMIT_THRESHOLD: number;
 
     /**
      * The exploration SpriteMesh which holds the fog exploration texture.
@@ -34,23 +38,27 @@ declare global {
 
     /**
      * The configured options used for the saved fog-of-war texture.
+     * @remarks Only `undefined` prior to the first time the canvas visibility layer is `#draw()`n
      */
-    get textureConfiguration(): VisibilityTextureConfiguration;
+    get textureConfiguration(): CanvasVisibility.TextureConfiguration | undefined;
 
     /**
      * Does the currently viewed Scene support Token field of vision?
      */
+    // TODO: make `Scene.Implementation["tokenVision"]` when docsv2 is done
     get tokenVision(): boolean;
 
     /**
      * Does the currently viewed Scene support fog of war exploration?
      */
+    // TODO: make `Scene.Implementation["fog"]["exploration"]` when docsv2 is done
     get fogExploration(): boolean;
 
     /**
      * Create the exploration display object with or without a provided texture.
+     * @privateRemarks Despite Foundry only typing this as returning `DisplayObject` in 12.331, it always returns a `SpriteMesh`
      */
-    protected _createExplorationObject(tex?: PIXI.Texture | PIXI.RenderTexture): DisplayObject;
+    protected _createExplorationObject(tex?: PIXI.Texture | PIXI.RenderTexture | null): SpriteMesh;
 
     /**
      * Initialize fog of war - resetting it when switching scenes or re-drawing the canvas
@@ -95,45 +103,52 @@ declare global {
      * @param base64Image - The extracted base64 image data
      * @returns Exploration data to update
      */
-    protected _prepareFogUpdateData(base64Image: string): foundry.documents.BaseFogExploration.UpdateData;
+    protected _prepareFogUpdateData(base64Image: string): FogExploration.UpdateData;
 
     /**
      * If fog of war data is reset from the server, deactivate the current fog and initialize the exploration.
-     * @internal
+     * @remarks Foundry marked `@internal`, called externally in the `fogReset` socket handler
      */
-    _handleReset(): Promise<void>;
+    protected _handleReset(): Promise<void>;
 
     /**
      * @deprecated since v11, will be removed in v13
-     * @remarks pending is deprecated and redirected to the exploration container
+     * @remarks "pending is deprecated and redirected to the exploration container"
      */
     get pending(): CanvasVisibility["explored"];
 
     /**
      * @deprecated since v11, will be removed in v13
-     * @remarks revealed is deprecated and redirected to the exploration container
+     * @remarks "revealed is deprecated and redirected to the exploration container"
      */
     get revealed(): CanvasVisibility["explored"];
 
     /**
      * @deprecated since v11, will be removed in v13
-     * @remarks update is obsolete and always returns true. The fog exploration does not record position anymore.
+     * @remarks "update is obsolete and always returns true. The fog exploration does not record position anymore."
+     *
+     * Both parameters are unused
      */
-    update(source: any, force: boolean): true;
+    update(source: any, force?: boolean | null): true;
 
     /**
      * @deprecated since v11, will be removed in v13
-     * @remarks resolution is deprecated and redirected to CanvasVisibility#textureConfiguration
+     * @remarks "resolution is deprecated and redirected to CanvasVisibility#textureConfiguration"
+     *
+     * Probable Bug Note: Returns the entire `textureConfiguration` object, not just its `resolution` property
      */
     get resolution(): CanvasVisibility["textureConfiguration"];
   }
 
   namespace FogManager {
-    type Any = AnyFogManager;
-    type AnyConstructor = typeof AnyFogManager;
+    interface Any extends AnyFogManager {}
+    interface AnyConstructor extends Identity<typeof AnyFogManager> {}
+
+    type ConfiguredClass = CONFIG["Canvas"]["fogManager"];
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
   }
 }
 
 declare abstract class AnyFogManager extends FogManager {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }