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

package/src/foundry/client-esm/canvas/sources/base-light-source.d.mts

@@ -1,13 +1,13 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial, IntentionalPartial } from "fvtt-types/utils";
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
 /**
  * A specialized subclass of BaseEffectSource which deals with the rendering of light or darkness.
  */
-declare class BaseLightSource<
-  SourceData extends BaseLightSource.LightSourceData = BaseLightSource.LightSourceData,
+declare abstract class BaseLightSource<
+  SourceData extends BaseLightSource.SourceData = BaseLightSource.SourceData,
   SourceShape extends PIXI.Polygon = PIXI.Polygon,
-  RenderingLayers extends Record<string, RenderedEffectSource.RenderedEffectSourceLayer> = RenderedEffectSource.Layers,
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
 > extends RenderedEffectSource<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"light"` */
   static override sourceType: string;
@@ -20,18 +20,22 @@ declare class BaseLightSource<
 
   /**
    * The corresponding lighting levels for dim light.
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.DIM`
    */
   protected static _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /**
    * The corresponding lighting levels for bright light.
+   * @defaultValue `foundry.CONST.LIGHTING_LEVELS.BRIGHT`
    */
   protected static _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /**
    * The corresponding animation config.
+   * @remarks More broad than it should be to accomodate {@link foundry.canvas.sources.PointDarknessSource}
+   * TODO: Reevaluate after CONFIG has been gone over
    */
-  protected static get ANIMATIONS(): CONFIG.Canvas.LightSourceAnimationConfig;
+  protected static get ANIMATIONS(): typeof CONFIG.Canvas.lightAnimations | typeof CONFIG.Canvas.darknessAnimations;
 
   /**
    * @defaultValue
@@ -52,14 +56,14 @@ declare class BaseLightSource<
    * }
    * ```
    */
-  static override defaultData: RenderedEffectSource.RenderedEffectSourceData;
+  static override defaultData: BaseLightSource.SourceData;
 
   /**
    * A ratio of dim:bright as part of the source radius
    */
   ratio: number;
 
-  override _initialize(data: Partial<SourceData>): void;
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   override _updateColorationUniforms(): void;
 
@@ -69,12 +73,18 @@ declare class BaseLightSource<
 
   override _updateCommonUniforms(shader: AbstractBaseShader): void;
 
+  /** @remarks This property is undocumented, and only defined during `_updateCommonUniforms` */
+  cachededAttentuation?: number;
+
+  /** @remarks This property is undocumented, and only defined during `_updateCommonUniforms` */
+  computedAttentuation?: number;
+
   /**
    * An animation with flickering ratio and light intensity.
    * @param dt      - Delta time
    * @param options - Additional options which modify the torch animation
    */
-  animateTorch(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+  animateTorch(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
    * An animation with flickering ratio and light intensity
@@ -83,72 +93,96 @@ declare class BaseLightSource<
    */
   animateFlickering(
     dt: number,
-    options?: InexactPartial<
-      RenderedEffectSource.AnimationOptions & {
+    options?: RenderedEffectSource.AnimationFunctionOptions &
+      InexactPartial<{
         /**
          * Noise amplification (\>1) or dampening (\<1)
          * @defaultValue `1`
          */
         amplification: number;
-      }
-    >,
+      }>,
   ): void;
 
+  /**
+   * @remarks This property will be generated on any class that is `animateFlickering`'s `this` when it is called.
+   * Foundry does not document it.
+   */
+  _noise?: SmoothNoise;
+
   /**
    * A basic "pulse" animation which expands and contracts.
    * @param dt      - Delta time
    * @param options - Additional options which modify the pulse animation
    */
-  animatePulse(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+  animatePulse(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
-   * @deprecated since v12
+   * @deprecated since v12, until v14
+   * @remarks "BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."
    */
   get isDarkness(): boolean;
 }
 
 declare namespace BaseLightSource {
-  interface LightSourceData extends RenderedEffectSource.RenderedEffectSourceData {
+  type AnyConstructor = typeof AnyBaseLightSource;
+
+  type LightAnimationFunction = (
+    this: BaseLightSource,
+    dt: number,
+    options?: RenderedEffectSource.AnimationFunctionOptions,
+  ) => void;
+
+  interface SourceData extends RenderedEffectSource.SourceData {
     /**
      * An opacity for the emitted light, if any
      */
     alpha: number;
+
     /**
      * The allowed radius of bright vision or illumination
      */
     bright: number;
+
     /**
      * The coloration technique applied in the shader
      */
     coloration: number;
+
     /**
      * The amount of contrast this light applies to the background texture
      */
     contrast: number;
+
     /**
      * The allowed radius of dim vision or illumination
      */
     dim: number;
+
     /**
      * Strength of the attenuation between bright, dim, and dark
      */
     attenuation: number;
+
     /**
      * The luminosity applied in the shader
      */
     luminosity: number;
+
     /**
      * The amount of color saturation this light applies to the background texture
      */
     saturation: number;
+
     /**
      * The depth of shadows this light applies to the background texture
      */
     shadows: number;
+
     /**
      * Whether or not this source provides a source of vision
      */
     vision: boolean;
+
     /**
      * Strength of this source to beat or not negative/positive sources
      */
@@ -156,4 +190,8 @@ declare namespace BaseLightSource {
   }
 }
 
+declare abstract class AnyBaseLightSource extends BaseLightSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default BaseLightSource;

package/src/foundry/client-esm/canvas/sources/global-light-source.d.mts

@@ -3,7 +3,7 @@ import type BaseLightSource from "./base-light-source.d.mts";
 /**
  * A specialized subclass of the BaseLightSource which is used to render global light source linked to the scene.
  */
-export default class GlobalLightSource extends BaseLightSource {
+declare class GlobalLightSource extends BaseLightSource {
   /** @defaultValue `"GlobalLight"` */
   static override sourceType: string;
 
@@ -26,16 +26,18 @@ export default class GlobalLightSource extends BaseLightSource {
    * }
    * ```
    */
-  static override defaultData: BaseLightSource.LightSourceData;
+  static override defaultData: BaseLightSource.SourceData;
 
   /**
    * Name of this global light source.
-   * @defaultValue GlobalLightSource.sourceType
+   * @defaultValue `GlobalLightSource.sourceType`
    */
   name: string;
 
   /**
    * A custom polygon placeholder.
+   * @defaultValue `null`
+   * @remarks This is not set anywhere in Foundry code, so will always be null barring system/module/user action
    */
   customPolygon: PIXI.Polygon | number[] | null;
 
@@ -44,4 +46,17 @@ export default class GlobalLightSource extends BaseLightSource {
   override _initializeSoftEdges(): void;
 
   override _updateGeometry(): void;
+
+  override _updateCommonUniforms(shader: AbstractBaseShader): void;
+}
+
+declare namespace GlobalLightSource {
+  type Any = AnyGlobalLightSource;
+  type AnyConstructor = typeof AnyGlobalLightSource;
 }
+
+declare abstract class AnyGlobalLightSource extends GlobalLightSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
+export default GlobalLightSource;

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

@@ -1,48 +1,48 @@
+import type { IntentionalPartial } from "fvtt-types/utils";
 import type BaseLightSource from "./base-light-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
-// TODO: Adjust after client/config.js is updated
-type LightSourceAnimationConfig = unknown;
-
-type DarknessSourceData = BaseLightSource.LightSourceData & PointEffectSourceMixin.PointEffectSourceData;
-
-// Interface causes errors
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-type DarknessLayers = {
-  darkness: RenderedEffectSource.RenderedEffectSourceLayer;
-};
-
 /**
  * A specialized subclass of the BaseLightSource which renders a source of darkness as a point-based effect.
  */
-export default class PointDarknessSource<
-  SourceData extends DarknessSourceData = DarknessSourceData,
+declare class PointDarknessSource<
+  SourceData extends PointDarknessSource.SourceData = PointDarknessSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
-> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, DarknessLayers> {
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, PointDarknessSource.Layers> {
   /** @defaultValue `"darknessSources"` */
   static override effectsCollection: string;
 
-  /** @defaultValue `LIGHTING_LEVELS.HALFDARK` */
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.HALFDARK` */
   static override _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
-  /** @defaultValue `LIGHTING_LEVELS.DARKNESS` */
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.DARKNESS` */
   static override _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /** @defaultValue `CONFIG.Canvas.darknessAnimations` */
-  static get ANIMATIONS(): LightSourceAnimationConfig;
+  static get ANIMATIONS(): typeof CONFIG.Canvas.darknessAnimations;
 
-  static override get _layers(): Record<string, foundry.canvas.sources.RenderedEffectSource.RenderedEffectLayerConfig>;
+  static override get _layers(): Record<string, foundry.canvas.sources.RenderedEffectSource.LayerConfig>;
+
+  /** @privateRemarks This is not in Foundry's code, but accounts for the mixin class's static property's inability to be generic */
+  static override defaultData: PointDarknessSource.SourceData;
 
   /**
    * The optional geometric shape is solely utilized for visual representation regarding darkness sources.
    * Used only when an additional radius is added for visuals.
    */
-  protected _visualShape: SourceShape;
+  protected _visualShape: SourceShape | null;
+
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
 
   /**
    * Padding applied on the darkness source shape for visual appearance only.
    * Note: for now, padding is increased radius. It might evolve in a future release.
+   * @defaultValue `(CONFIG.Canvas.darknessSourcePaddingMultiplier ?? 0) * canvas.grid.size`
    */
   protected _padding: number;
 
@@ -51,11 +51,18 @@ export default class PointDarknessSource<
    */
   edges: foundry.canvas.edges.Edge[];
 
+  /**
+   * A convenience accessor to the darkness layer mesh.
+   */
+  get darkness(): this["layers"]["darkness"]["mesh"];
+
+  override _initialize(data: IntentionalPartial<SourceData>): void;
+
   override _createShapes(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  override _getPolygonConfiguration(): PointSourcePolygon.Config;
 
   override _drawMesh(layerId: string): PIXI.Mesh | null;
 
@@ -69,9 +76,26 @@ export default class PointDarknessSource<
   override _destroy(): void;
 
   /**
-   * A convenience accessor to the darkness layer mesh.
    * @deprecated since v12, until v14
    * @remarks `"BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."`
    */
-  get darkness(): PointSourceMesh;
+  get isDarkness(): boolean;
+}
+
+declare namespace PointDarknessSource {
+  type AnyConstructor = typeof AnyPointDarknessSource;
+
+  type SourceData = BaseLightSource.SourceData & PointEffectSourceMixin.SourceData;
+
+  // Interface would require `RenderingLayers extends ... = InterfaceToObject<Layers>` in every subclass signature
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+  type Layers = {
+    darkness: RenderedEffectSource.SourceLayer;
+  };
 }
+
+declare abstract class AnyPointDarknessSource extends PointDarknessSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
+export default PointDarknessSource;

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

@@ -1,4 +1,4 @@
-import type { Mixin } from "../../../../types/utils.d.mts";
+import type { Mixin, IntentionalPartial, FixedInstanceType } from "fvtt-types/utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 
 declare class PointEffectSource {
@@ -17,22 +17,27 @@ declare class PointEffectSource {
    * walls: true
    * }
    * ```
+   * @privateRemarks This will only be accurate for classes extending `PointEffectSourceMixin(BaseEffectSource)`.
+   * Other subclasses must override this.
    */
-  static defaultData: PointEffectSourceMixin.PointEffectSourceData;
+  static defaultData: PointEffectSourceMixin.MixedSourceData;
+
+  /** @privateRemarks This is not in Foundry's code, but the mixin class loses access to the type parameter that would otherwise be here */
+  shape: PointSourcePolygon;
 
   /**
    * A convenience reference to the radius of the source.
    */
   get radius(): number;
 
-  _initialize(data: Partial<PointEffectSourceMixin.PointEffectSourceData>): void;
+  _initialize(data: IntentionalPartial<PointEffectSourceMixin.MixedSourceData>): void;
 
   _initializeSoftEdges(): void;
 
   /**
    * Configure the parameters of the polygon that is generated for this source.
    */
-  protected _getPolygonConfiguration(): PointSourcePolygonConfig;
+  protected _getPolygonConfiguration(): PointSourcePolygon.Config;
 
   _createShapes(): void;
 
@@ -59,14 +64,19 @@ declare class PointEffectSource {
  * TODO - documentation required about what a PointEffectSource is.
  * @privateRemarks the TODO is from foundry, update this class whenever the comments are done
  */
-declare function PointEffectSourceMixin<BaseClass extends BaseEffectSource.AnyConstructor>(
+declare function PointEffectSourceMixin<BaseClass extends PointEffectSourceMixin.BaseClass>(
   Base: BaseClass,
 ): Mixin<typeof PointEffectSource, BaseClass>;
 
 declare namespace PointEffectSourceMixin {
-  type AnyMixed = ReturnType<typeof PointEffectSourceMixin<BaseEffectSource.AnyConstructor>>;
+  type AnyMixedConstructor = ReturnType<typeof PointEffectSourceMixin<BaseClass>>;
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = BaseEffectSource.AnyConstructor;
+
+  type MixedSourceData = SourceData & BaseEffectSource.SourceData;
 
-  interface PointEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+  interface SourceData {
     /**
      * The radius of the source
      */

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

@@ -1,37 +1,37 @@
+import type { IntentionalPartial } from "fvtt-types/utils";
 import type BaseLightSource from "./base-light-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
-type LightSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseLightSource.LightSourceData;
-
 /**
  * A specialized subclass of the BaseLightSource which renders a source of light as a point-based effect.
  */
-export default class PointLightSource<
-  SourceData extends LightSourceData = LightSourceData,
+declare class PointLightSource<
+  SourceData extends PointLightSource.SourceData = PointLightSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
 > extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape> {
   /** @defaultValue `"lightSources"` */
   static override effectsCollection: string;
 
-  override _initialize(data: Partial<SourceData>): void;
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
+
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   override _createShapes(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  override _getPolygonConfiguration(): PointSourcePolygon.Config;
 
   /**
    * Test whether this LightSource provides visibility to see a certain target object.
    * @param config - The visibility test configuration
    * @returns Is the target object visible to this source?
    */
-  testVisibility(config: {
-    /** The sequence of tests to perform */
-    tests: CanvasVisibilityTest[];
-    /** The target object being tested */
-    object: PlaceableObject;
-  }): boolean;
+  testVisibility(config?: CanvasVisibilityTestConfig): boolean;
 
   /**
    * Can this LightSource theoretically detect a certain object based on its properties?
@@ -39,5 +39,17 @@ export default class PointLightSource<
    * @param target - The target object being tested
    * @returns Can the target object theoretically be detected by this vision source?
    */
-  _canDetectObject(target: PlaceableObject): boolean;
+  _canDetectObject(target?: PlaceableObject | null): boolean;
+}
+
+declare namespace PointLightSource {
+  type AnyConstructor = typeof AnyPointLightSource;
+
+  type SourceData = PointEffectSourceMixin.SourceData & BaseLightSource.SourceData;
 }
+
+declare abstract class AnyPointLightSource extends PointLightSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
+export default PointLightSource;

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

@@ -1,15 +1,31 @@
 import type BaseEffectSource from "./base-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
-type MovementSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseEffectSource.BaseEffectSourceData;
-
 /**
  * A specialized subclass of the BaseEffectSource which describes a movement-based source.
  */
-export default class PointMovementSource<
-  SourceData extends MovementSourceData = MovementSourceData,
+declare class PointMovementSource<
+  SourceData extends PointMovementSource.SourceData = PointMovementSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
 > extends PointEffectSourceMixin(BaseEffectSource)<SourceData, SourceShape> {
   /** @defaultValue `"move"` */
   static override sourceType: string;
+
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
+}
+
+declare namespace PointMovementSource {
+  type AnyConstructor = typeof AnyPointMovementSource;
+
+  type SourceData = PointEffectSourceMixin.MixedSourceData;
+}
+
+declare abstract class AnyPointMovementSource extends PointMovementSource {
+  constructor(arg0: never, ...args: never[]);
 }
+
+export default PointMovementSource;

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

@@ -1,29 +1,47 @@
+import type { NullishProps } from "fvtt-types/utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
 
-type SoundSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseEffectSource.BaseEffectSourceData;
-
 /**
  * A specialized subclass of the BaseEffectSource which describes a point-based source of sound.
  */
-export default class PointSoundSource<
-  SourceData extends SoundSourceData = SoundSourceData,
+declare class PointSoundSource<
+  SourceData extends PointSoundSource.SourceData = PointSoundSource.SourceData,
   SourceShape extends PointSourcePolygon = PointSourcePolygon,
 > extends PointEffectSourceMixin(BaseEffectSource)<SourceData, SourceShape> {
   /** @defaultValue `"sound"` */
   static override sourceType: string;
 
+  /**
+   * @privateRemarks This is not in foundry's code, but since this class (and its parent) implements `_createShapes`,
+   * and we are counting what happens in `initialize` as 'the constructor', this gets to be declared never undefined.
+   */
+  override shape: SourceShape;
+
   override get effectsCollection(): Collection<this>;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  override _getPolygonConfiguration(): PointSourcePolygon.Config;
 
   /**
    * Get the effective volume at which an AmbientSound source should be played for a certain listener.
    */
   getVolumeMultiplier(
     listener: Canvas.Point,
-    options?: {
-      easing?: boolean | undefined;
-    },
+    options?: NullishProps<{
+      /** If no easing, return `1` */
+      easing: boolean;
+    }>,
   ): number;
 }
+
+declare namespace PointSoundSource {
+  type AnyConstructor = typeof AnyPointSoundSource;
+
+  type SourceData = PointEffectSourceMixin.MixedSourceData;
+}
+
+declare abstract class AnyPointSoundSource extends PointSoundSource {
+  constructor(arg0: never, ...args: never[]);
+}
+
+export default PointSoundSource;