@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.5

package/src/foundry/client-esm/canvas/sources/point-vision-source.d.mts

@@ -1,33 +1,38 @@
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+import type { AnyObject, FixedInstanceType, Identity, IntentionalPartial, RequiredProps } from "#utils";
 
 /**
  * A specialized subclass of RenderedEffectSource which represents a source of point-based vision.
  */
 declare class PointVisionSource<
-  SourceData extends PointVisionSource.VisionSourceData = PointVisionSource.VisionSourceData,
-> extends PointEffectSourceMixin(RenderedEffectSource)<SourceData> {
+  SourceData extends PointVisionSource.SourceData = PointVisionSource.SourceData,
+  SourceShape extends PointSourcePolygon = PointSourcePolygon,
+  RenderingLayers extends RenderedEffectSource.Layers = RenderedEffectSource.Layers,
+> extends PointEffectSourceMixin(RenderedEffectSource)<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"sight"` */
   static override sourceType: string;
 
   /** @defaultValue `["visionMode", "blinded"]` */
-  static override _initializeShaderKeys: string[];
+  protected static override _initializeShaderKeys: string[];
 
   /** @defaultValue `["radius", "color", "attenuation", "brightness", "contrast", "saturation", "visionMode"]` */
-  static override _refreshUniformsKeys: string[];
+  protected static override _refreshUniformsKeys: string[];
 
   /**
    * The corresponding lighting levels for dim light.
-   * @defaultValue `LIGHTING_LEVELS.DIM`
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.DIM`
    */
   protected static _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /**
    * The corresponding lighting levels for bright light.
-   * @defaultValue `LIGHTING_LEVELS.BRIGHT`
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.BRIGHT`
    */
   protected static _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
+  static override EDGE_OFFSET: number;
+
   /** @defaultValue `"visionSources"` */
   static override effectsCollection: string;
 
@@ -35,50 +40,58 @@ declare class PointVisionSource<
    * @defaultValue
    * ```js
    * {
-   * ...super.defaultData,
-   * contrast: 0,
-   * attenuation: 0.5,
-   * saturation: 0,
-   * brightness: 0,
-   * visionMode: "basic",
-   * lightRadius: null
+   *   ...super.defaultData,
+   *   contrast: 0,
+   *   attenuation: 0.5,
+   *   saturation: 0,
+   *   brightness: 0,
+   *   visionMode: "basic",
+   *   lightRadius: null
    * }
    * ```
    */
-  static override defaultData: PointVisionSourceData;
+  static override defaultData: PointVisionSource.SourceData;
 
-  static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+  /** @remarks Overrides `Adaptive*Shader` references with `*VisionShader` ones */
+  protected static get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
   /**
    * The vision mode linked to this VisionSource
+   * @remarks Foundry types this as `| null`, and initializes to `= null` in the class body,
+   * but then sets it to `CONFIG.Canvas.visionModes[this.data.visionMode]` during actual
+   * initialization, so it'll either be a defined `VisionMode` or `undefined`
    */
-  visionMode: VisionMode | null;
+  visionMode: VisionMode | undefined;
 
   /**
    * The vision mode activation flag for handlers
-   * @internal
+   * @remarks Foundry marked `@internal`.
+   *
+   * Read and set externally in {@link VisionMode.activate | `VisionMode#activate`} and {@link VisionMode.deactivate | `VisionMode#deactivate`}
    */
-  _visionModeActivated: boolean;
+  protected _visionModeActivated: boolean;
 
   /**
    * The unconstrained LOS polygon.
+   * @remarks Initialization includes `this.los = this.shape` in `#_createShapes()`
    */
-  los: PointSourcePolygon;
+  los: SourceShape;
 
   /**
    * The polygon of light perception.
+   * @remarks Initialization includes `this.light = this._createLightPolygon()` in `#_createShapes()`
    */
-  light: PointSourcePolygon;
+  light: SourceShape;
 
   /**
    * An alias for the shape of the vision source.
    */
-  get fov(): PIXI.Polygon | PointSourcePolygon;
+  get fov(): SourceShape;
 
   /**
    * If this vision source background is rendered into the lighting container.
    */
-  get preferred(): boolean;
+  get preferred(): boolean | undefined;
 
   /**
    * Is the rendered source animated?
@@ -101,29 +114,29 @@ declare class PointVisionSource<
    * Records of blinding strings with a boolean value.
    * By default, if any of this record is true, the source is blinded.
    */
-  blinded: Record<string, boolean>;
+  blinded: PointVisionSource.BlindedReasons;
 
   /**
    * Data overrides that could happen with blindness vision mode.
+   * @remarks Initialized in the class to `{}`, but filled in during actual initialization (`#_updateVisionMode` via `#_createShapes`)
    */
-  visionModeOverrides: object;
-
-  override _initialize(data: Partial<SourceData>): void;
+  visionModeOverrides: PointVisionSource.VisionModeOverrides;
 
-  override _createShapes(): void;
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
 
-  override shape: PointSourcePolygon;
+  protected override _createShapes(): void;
 
   /**
    * Responsible for assigning the Vision Mode and calling the activation and deactivation handlers.
    */
   protected _updateVisionMode(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected override _configure(changes: AnyObject): void;
 
-  override _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+  protected override _configureLayer(layer: RenderedEffectSource.SourceLayer, layerId: string): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  protected override _getPolygonConfiguration(): PointVisionSource.PolygonConfig;
 
   /**
    * Creates the polygon that represents light perception.
@@ -131,7 +144,7 @@ declare class PointVisionSource<
    * instead the LOS polygon of this vision source is returned.
    * @returns The new polygon or `this.los`.
    */
-  protected _createLightPolygon(): PointSourcePolygon;
+  protected _createLightPolygon(): SourceShape;
 
   /**
    * Create a restricted FOV polygon by limiting the radius of the unrestricted LOS polygon.
@@ -139,74 +152,107 @@ declare class PointVisionSource<
    * instead the LOS polygon of this vision source is returned.
    * @returns The new polygon or `this.los`.
    */
-  protected _createRestrictedPolygon(): PointSourcePolygon;
+  protected _createRestrictedPolygon(): SourceShape;
 
-  override _configureShaders(): {
-    background: AdaptiveLightingShader;
-    coloration: AdaptiveLightingShader;
-    illumination: AdaptiveLightingShader;
-  };
+  protected override _configureShaders(): Record<keyof RenderingLayers, AdaptiveVisionShader.AnyConstructor>;
 
-  override _updateColorationUniforms(): void;
+  protected override _updateColorationUniforms(): void;
 
-  override _updateIlluminationUniforms(): void;
+  protected override _updateIlluminationUniforms(): void;
 
-  override _updateBackgroundUniforms(): void;
+  protected override _updateBackgroundUniforms(): void;
 
-  override _updateCommonUniforms(shader: AbstractBaseShader): void;
+  protected override _updateCommonUniforms(shader: AbstractBaseShader): void;
 
   /**
    * Update layer uniforms according to vision mode uniforms, if any.
    * @param shader     - The shader being updated.
    * @param vmUniforms - The targeted layer.
    */
-  protected _updateVisionModeUniforms(shader: AdaptiveVisionShader, vmUniforms: AbstractBaseShader.Uniforms): void;
+  protected _updateVisionModeUniforms(
+    shader: AdaptiveVisionShader,
+    vmUniforms: Array<[string, AbstractBaseShader.UniformValue]>,
+  ): void;
 }
 
 declare namespace PointVisionSource {
-  type Any = PointVisionSource<VisionSourceData>;
+  interface Any extends AnyPointVisionSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointVisionSource> {}
 
-  interface VisionSourceData
-    extends RenderedEffectSource.RenderedEffectSourceData,
-      PointEffectSourceMixin.PointEffectSourceData {
+  interface SourceData extends RenderedEffectSource.SourceData, PointEffectSourceMixin.SourceData {
     /**
      * The amount of contrast
+     * @defaultValue `0`
      */
     contrast: number;
 
     /**
      * Strength of the attenuation between bright, dim, and dark
+     * @defaultValue `0.5`
      */
     attenuation: number;
 
     /**
      * The amount of color saturation
+     * @defaultValue `0`
      */
     saturation: number;
 
     /**
-     * The vision brightness.
+     * The vision brightness
+     * @defaultValue `0`.
      */
     brightness: number;
 
     /**
      * The vision mode.
+     * @defaultValue `"basic"`
      */
-    visionMode: string;
+    visionMode: VisionMode.ConfiguredModes;
 
     /**
      * The range of light perception.
+     * @defaultValue `null`
+     * @remarks `null` is treated as `0` for `get LightRadius()` purposes, and while this
+     * will be `null` in `.defaultData`, `PointVisionSource#_initialize` will replace it
+     * with `Math.max(canvas.dimensions.maxR, this.data.externalRadius)` if it's not
+     * otherwise specified
      */
-    lightRadius: number;
+    lightRadius: number | null;
 
     /**
      * Is this vision source blinded?
      */
     blinded: boolean;
   }
+
+  /** @privateRemarks Foundry types the property this is for as just `object` */
+  interface VisionModeOverrides {
+    colorRGB: Color.RGBColorVector | null;
+    brightness: number;
+    contrast: number;
+    saturation: number;
+    attenuation: number;
+  }
+
+  /** @privateRemarks Foundry types this as just the Record, but only ever checks the one key */
+  interface BlindedReasons extends Record<string, boolean | undefined> {
+    darkness?: boolean;
+  }
+
+  interface PolygonConfig
+    extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "radius" | "useThreshold" | "includeDarkness"> {}
+
+  type ConfiguredClass = CONFIG["Canvas"]["visionSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 }
 
-type PointVisionSourceData = PointEffectSourceMixin.PointEffectSourceData &
-  RenderedEffectSource.RenderedEffectSourceData;
+declare abstract class AnyPointVisionSource extends PointVisionSource<
+  PointVisionSource.SourceData,
+  PointSourcePolygon,
+  RenderedEffectSource.Layers
+> {
+  constructor(...args: never);
+}
 
 export default PointVisionSource;