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

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

@@ -1,45 +1,49 @@
+import type { AnyObject, FixedInstanceType, Identity, IntentionalPartial, RequiredProps } from "#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";
 
-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> {
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = PointDarknessSource.Layers,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"darknessSources"` */
   static override effectsCollection: string;
 
-  /** @defaultValue `LIGHTING_LEVELS.HALFDARK` */
-  static override _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.HALFDARK` */
+  protected static override _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
-  /** @defaultValue `LIGHTING_LEVELS.DARKNESS` */
-  static override _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+  /** @defaultValue `foundry.CONST.LIGHTING_LEVELS.DARKNESS` */
+  protected static override _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
 
   /** @defaultValue `CONFIG.Canvas.darknessAnimations` */
-  static get ANIMATIONS(): CONFIG.Canvas.LightSourceAnimationConfig;
+  protected static get ANIMATIONS(): typeof CONFIG.Canvas.darknessAnimations;
+
+  protected static override get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
-  static override get _layers(): Record<string, foundry.canvas.sources.RenderedEffectSource.RenderedEffectLayerConfig>;
+  /** @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;
 
@@ -48,27 +52,67 @@ export default class PointDarknessSource<
    */
   edges: foundry.canvas.edges.Edge[];
 
-  override _createShapes(): void;
+  /**
+   * A convenience accessor to the darkness layer mesh.
+   */
+  get darkness(): PointSourceMesh;
+
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
+
+  protected override _createShapes(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected override _configure(changes: AnyObject): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  protected override _getPolygonConfiguration(): PointDarknessSource.PolygonConfig;
 
-  override _drawMesh(layerId: string): PIXI.Mesh | null;
+  protected override _drawMesh(layerId: string): PointSourceMesh | null;
 
-  override _updateGeometry(): void;
+  protected override _updateGeometry(): void;
 
   /**
    * Update the uniforms of the shader on the darkness layer.
    */
-  _updateDarknessUniforms(): void;
+  protected _updateDarknessUniforms(): void;
 
-  override _destroy(): void;
+  protected 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."`
+   *
+   * Always returns `true`
    */
-  get darkness(): PointSourceMesh;
+  get isDarkness(): true;
 }
+
+declare namespace PointDarknessSource {
+  interface Any extends AnyPointDarknessSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointDarknessSource> {}
+
+  interface SourceData extends BaseLightSource.SourceData, PointEffectSourceMixin.SourceData {
+    animation: RenderedEffectSource.StoredDarknessAnimationConfig;
+  }
+
+  interface PolygonConfig
+    extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold" | "includeDarkness" | "radius"> {}
+
+  // 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;
+  };
+
+  type ConfiguredClass = CONFIG["Canvas"]["darknessSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+}
+
+declare abstract class AnyPointDarknessSource extends PointDarknessSource<
+  PointDarknessSource.SourceData,
+  PointSourcePolygon,
+  PointDarknessSource.Layers
+> {
+  constructor(...args: never);
+}
+
+export default PointDarknessSource;

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

@@ -1,44 +1,55 @@
-import type { Mixin } from "../../../../types/utils.d.mts";
+import type { Mixin, IntentionalPartial, FixedInstanceType, RequiredProps } from "#utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare class PointEffectSource {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
   /**
    * @defaultValue
    * ```js
    * {
-   * ...super.defaultData,
-   * radius: 0,
-   * externalRadius: 0,
-   * rotation: 0,
-   * angle: 360,
-   * walls: true
+   *   ...super.defaultData,
+   *   radius: 0,
+   *   externalRadius: 0,
+   *   rotation: 0,
+   *   angle: 360,
+   *   walls: true
    * }
    * ```
+   * @remarks This type is only accurate for classes extending `PointEffectSourceMixin(BaseEffectSource)`.
+   * Other subclasses must override.
    */
-  static defaultData: PointEffectSourceMixin.PointEffectSourceData;
+  static defaultData: PointEffectSourceMixin.MixedSourceData;
+
+  /**
+   * @defaultValue `CONFIG.Canvas.polygonBackends[this.constructor.sourceType].create(origin, config)`
+   * @privateRemarks This is not in Foundry's code, but the mixin class loses access to the type parameter that would
+   * otherwise be here, and per the default above this is always a {@link PointSourcePolygon | `PointSourcePolygon`} subclass, always
+   * {@link ClockwiseSweepPolygon | `ClockwiseSweepPolygon`} in core
+   */
+  shape: PointSourcePolygon;
 
   /**
    * A convenience reference to the radius of the source.
    */
   get radius(): number;
 
-  _initialize(data: Partial<PointEffectSourceMixin.PointEffectSourceData>): void;
+  protected _initialize(data: IntentionalPartial<PointEffectSourceMixin.MixedSourceData>): void;
 
-  _initializeSoftEdges(): void;
+  protected _initializeSoftEdges(): void;
 
   /**
    * Configure the parameters of the polygon that is generated for this source.
    */
-  protected _getPolygonConfiguration(): PointSourcePolygonConfig;
+  protected _getPolygonConfiguration(): PointEffectSourceMixin.PolygonConfig;
 
-  _createShapes(): void;
+  protected _createShapes(): void;
 
-  _drawMesh(layerId: string): PIXI.Mesh | null;
+  protected _drawMesh(layerId: string): PointSourceMesh | null;
 
-  _updateGeometry(): void;
+  protected _updateGeometry(): void;
 
   /**
    * @deprecated since v11, until v13
@@ -50,41 +61,59 @@ declare class PointEffectSource {
   /**
    * @deprecated since v11, until v13
    * @remarks `"PointEffectSource#los is deprecated in favor of PointEffectSource#shape."`
-   * @privateRemarks Actual definition is get/set
+   * @privateRemarks Actually implemented as getter/setter for deprecation warning purposes, but this causes inheritance problems with  {@link foundry.canvas.sources.PointVisionSource#los | `PointVisionSource`}
    */
-  los: PointSourcePolygon;
+  los: this["shape"];
 }
 
 /**
  * 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>>;
+  interface AnyMixedConstructor extends ReturnType<typeof PointEffectSourceMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = BaseEffectSource.AnyConstructor;
+
+  type MixedSourceData = SourceData & BaseEffectSource.SourceData;
 
-  interface PointEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+  /** @remarks This mixin guarantees certain keys in the return type beyond the base required `type` */
+  interface PolygonConfig
+    extends RequiredProps<PointSourcePolygon.Config, "radius" | "externalRadius" | "angle" | "rotation" | "source"> {}
+
+  interface SourceData {
     /**
      * The radius of the source
+     * @defaultValue `0`
      */
     radius: number;
+
     /**
      * A secondary radius used for limited angles
+     * @defaultValue `0`
      */
     externalRadius: number;
+
     /**
      * The angle of rotation for this point source
+     * @defaultValue `0`
      */
     rotation: number;
+
     /**
      * The angle of emission for this point source
+     * @defaultValue `360`
      */
     angle: number;
+
     /**
      * Whether or not the source is constrained by walls
+     * @defaultValue `true`
      */
     walls: boolean;
   }

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

@@ -1,37 +1,44 @@
+import type { AnyObject, FixedInstanceType, Identity, IntentionalPartial, RequiredProps } from "#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;
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 
 /**
  * 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> {
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, RenderingLayers> {
   /** @defaultValue `"lightSources"` */
   static override effectsCollection: string;
 
-  override _initialize(data: Partial<SourceData>): void;
+  /** @privateRemarks Not in Foundry code, necessary type override */
+  static override defaultData: PointLightSource.SourceData;
+
+  /**
+   * @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;
+
+  protected override _initialize(data: IntentionalPartial<SourceData>): void;
 
-  override _createShapes(): void;
+  protected override _createShapes(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  // TODO: Flatten<IntentionalPartial<SourceData>>
+  protected override _configure(changes: AnyObject): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  protected override _getPolygonConfiguration(): PointLightSource.PolygonConfig;
 
   /**
    * 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?
+   * @remarks Despite being an `={}` parameter, this will error if `config.tests` is not at least an empty array of `CanvasVisibility.Test`s
    */
-  testVisibility(config: {
-    /** The sequence of tests to perform */
-    tests: CanvasVisibilityTest[];
-    /** The target object being tested */
-    object: PlaceableObject;
-  }): boolean;
+  testVisibility(config: CanvasVisibility.TestConfig): boolean;
 
   /**
    * Can this LightSource theoretically detect a certain object based on its properties?
@@ -39,5 +46,39 @@ 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;
+  protected _canDetectObject(target?: PlaceableObject.Any | null): boolean;
+
+  /**
+   * @deprecated since v12, until v14
+   * @remarks `"BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."`
+   *
+   * Always returns `false`
+   * @privateRemarks This isn't actually overridden here, `BaseLightSource#isDarkness` always returns false, but it's type as `boolean` there to allow `PointDarknessSource#isDarkness` to return true.
+   */
+  get isDarkness(): false;
 }
+
+declare namespace PointLightSource {
+  interface Any extends AnyPointLightSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointLightSource> {}
+
+  interface SourceData extends PointEffectSourceMixin.SourceData, BaseLightSource.SourceData {
+    animation: RenderedEffectSource.StoredLightAnimationConfig;
+  }
+
+  interface PolygonConfig
+    extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold" | "includeDarkness"> {}
+
+  type ConfiguredClass = CONFIG["Canvas"]["lightSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+}
+
+declare abstract class AnyPointLightSource extends PointLightSource<
+  PointLightSource.SourceData,
+  PointSourcePolygon,
+  RenderedEffectSource.Layers
+> {
+  constructor(...args: never);
+}
+
+export default PointLightSource;

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

@@ -1,15 +1,42 @@
+import type { Identity } from "../../../../utils/index.d.mts";
 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 Not in Foundry code, necessary type override */
+  static override defaultData: PointMovementSource.SourceData;
+
+  /**
+   * @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 {
+  interface Any extends AnyPointMovementSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointMovementSource> {}
+
+  interface SourceData extends PointEffectSourceMixin.MixedSourceData {}
+
+  // This is the only core Point*Source class that isn't configurable, `Token##getMovementSource`
+  // references this class directly, not a `CONFIG` property
 }
+
+declare abstract class AnyPointMovementSource extends PointMovementSource<
+  PointMovementSource.SourceData,
+  PointSourcePolygon
+> {
+  constructor(...args: never);
+}
+
+export default PointMovementSource;

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

@@ -1,29 +1,62 @@
+import type { FixedInstanceType, Identity, NullishProps, RequiredProps } from "#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;
 
-  override get effectsCollection(): Collection<this>;
+  /** @privateRemarks Not in Foundry code, necessary type override */
+  static override defaultData: PointSoundSource.SourceData;
+
+  /**
+   * @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(): foundry.utils.Collection<this>;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  override _getPolygonConfiguration(): PointSoundSource.PolygonConfig;
 
   /**
    * Get the effective volume at which an AmbientSound source should be played for a certain listener.
+   * @remarks If `listener` is falsey, returns `0`. If `options.easing` is falsey, returns `1`
    */
-  getVolumeMultiplier(
-    listener: Canvas.Point,
-    options?: {
-      easing?: boolean | undefined;
-    },
-  ): number;
+  getVolumeMultiplier(listener?: Canvas.Point | null, options?: PointSoundSource.GetVolumeMultiplierOptions): number;
 }
+
+declare namespace PointSoundSource {
+  interface Any extends AnyPointSoundSource {}
+  interface AnyConstructor extends Identity<typeof AnyPointSoundSource> {}
+
+  /** @internal */
+  type _GetVolumeMultiplierOptions = NullishProps<{
+    /**
+     * @defaultValue `true`
+     * @remarks If `false`, return `1`
+     */
+    easing: boolean;
+  }>;
+
+  interface GetVolumeMultiplierOptions extends _GetVolumeMultiplierOptions {}
+
+  interface SourceData extends PointEffectSourceMixin.MixedSourceData {}
+
+  interface PolygonConfig extends RequiredProps<PointEffectSourceMixin.PolygonConfig, "useThreshold"> {}
+
+  type ConfiguredClass = CONFIG["Canvas"]["soundSourceClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+}
+
+declare abstract class AnyPointSoundSource extends PointSoundSource<PointSoundSource.SourceData, PointSourcePolygon> {
+  constructor(...args: never);
+}
+
+export default PointSoundSource;