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

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

@@ -1,12 +1,15 @@
 import type RenderedEffectSource from "./rendered-effect-source.d.mts";
 import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+import type { IntentionalPartial } from "fvtt-types/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;
 
@@ -18,16 +21,18 @@ declare class PointVisionSource<
 
   /**
    * 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;
 
@@ -45,9 +50,10 @@ declare class PointVisionSource<
    * }
    * ```
    */
-  static override defaultData: PointVisionSourceData;
+  static override defaultData: PointVisionSource.SourceData;
 
-  static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+  /** @remarks Overrides `Adaptive*Shader` references with `*VisionShader` ones */
+  static get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
   /**
    * The vision mode linked to this VisionSource
@@ -78,7 +84,7 @@ declare class PointVisionSource<
   /**
    * If this vision source background is rendered into the lighting container.
    */
-  get preferred(): boolean;
+  get preferred(): boolean | undefined;
 
   /**
    * Is the rendered source animated?
@@ -108,22 +114,20 @@ declare class PointVisionSource<
    */
   visionModeOverrides: object;
 
-  override _initialize(data: Partial<SourceData>): void;
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   override _createShapes(): void;
 
-  override shape: PointSourcePolygon;
-
   /**
    * Responsible for assigning the Vision Mode and calling the activation and deactivation handlers.
    */
   protected _updateVisionMode(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
-  override _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+  override _configureLayer(layer: RenderedEffectSource.SourceLayer, layerId: string): void;
 
-  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+  override _getPolygonConfiguration(): PointSourcePolygon.Config;
 
   /**
    * Creates the polygon that represents light perception.
@@ -141,11 +145,7 @@ declare class PointVisionSource<
    */
   protected _createRestrictedPolygon(): PointSourcePolygon;
 
-  override _configureShaders(): {
-    background: AdaptiveLightingShader;
-    coloration: AdaptiveLightingShader;
-    illumination: AdaptiveLightingShader;
-  };
+  override _configureShaders(): Record<keyof RenderingLayers, typeof AdaptiveVisionShader>;
 
   override _updateColorationUniforms(): void;
 
@@ -164,11 +164,11 @@ declare class PointVisionSource<
 }
 
 declare namespace PointVisionSource {
-  type Any = PointVisionSource<VisionSourceData>;
+  type Any = PointVisionSource<SourceData>;
 
-  interface VisionSourceData
-    extends RenderedEffectSource.RenderedEffectSourceData,
-      PointEffectSourceMixin.PointEffectSourceData {
+  type AnyConstructor = typeof AnyPointVisionSource;
+
+  interface SourceData extends RenderedEffectSource.SourceData, PointEffectSourceMixin.SourceData {
     /**
      * The amount of contrast
      */
@@ -197,7 +197,7 @@ declare namespace PointVisionSource {
     /**
      * The range of light perception.
      */
-    lightRadius: number;
+    lightRadius: number | null;
 
     /**
      * Is this vision source blinded?
@@ -206,7 +206,8 @@ declare namespace PointVisionSource {
   }
 }
 
-type PointVisionSourceData = PointEffectSourceMixin.PointEffectSourceData &
-  RenderedEffectSource.RenderedEffectSourceData;
+declare abstract class AnyPointVisionSource extends PointVisionSource {
+  constructor(arg0: never, ...args: never[]);
+}
 
 export default PointVisionSource;

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

@@ -1,17 +1,14 @@
-import type { AnyFunction, InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial, IntentionalPartial } from "fvtt-types/utils";
 import type BaseEffectSource from "./base-effect-source.d.mts";
 
-// TODO: Remove after shaders are done
-type AdaptiveDarknessShader = unknown;
-
 /**
  * An abstract class which extends the base PointSource to provide common functionality for rendering.
  * This class is extended by both the LightSource and VisionSource subclasses.
  */
 declare class RenderedEffectSource<
-  SourceData extends RenderedEffectSource.RenderedEffectSourceData = RenderedEffectSource.RenderedEffectSourceData,
+  SourceData extends RenderedEffectSource.SourceData = RenderedEffectSource.SourceData,
   SourceShape extends PIXI.Polygon = PIXI.Polygon,
-  RenderingLayers extends Record<string, RenderedEffectSource.RenderedEffectSourceLayer> = RenderedEffectSource.Layers,
+  RenderingLayers extends Record<string, RenderedEffectSource.SourceLayer> = RenderedEffectSource.Layers,
 > extends BaseEffectSource<SourceData, SourceShape> {
   /**
    * Keys of the data object which require shaders to be re-initialized.
@@ -27,7 +24,7 @@ declare class RenderedEffectSource<
    * Layers handled by this rendered source.
    * @remarks Keys should match the keys of RenderingLayers
    */
-  protected static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+  protected static get _layers(): Record<string, RenderedEffectSource.LayerConfig>;
 
   /**
    * The offset in pixels applied to create soft edges.
@@ -47,13 +44,13 @@ declare class RenderedEffectSource<
    * }
    * ```
    */
-  static defaultData: RenderedEffectSource.RenderedEffectSourceData;
+  static defaultData: RenderedEffectSource.SourceData;
 
   /**
    * The animation configuration applied to this source
    * @defaultValue `{}`
    */
-  animation: RenderedEffectSource.RenderedEffectSourceAnimationConfig;
+  animation: RenderedEffectSource.AnimationConfig;
 
   /**
    * Track the status of rendering layers
@@ -100,29 +97,25 @@ declare class RenderedEffectSource<
    */
   get illumination(): PointSourceMesh;
 
-  _initialize(data: Partial<SourceData>): void;
+  override _initialize(data: IntentionalPartial<SourceData>): void;
 
   /**
    * Decide whether to render soft edges with a blur.
    */
   protected _initializeSoftEdges(): void;
 
-  override _configure(changes: Partial<SourceData>): void;
+  override _configure(changes: IntentionalPartial<SourceData>): void;
 
   /**
    * Configure which shaders are used for each rendered layer.
    * @privateRemarks Foundry marks this as private then overrides it in `PointVisionSource`
    */
-  protected _configureShaders(): {
-    background: AdaptiveLightingShader;
-    coloration: AdaptiveLightingShader;
-    illumination: AdaptiveLightingShader;
-  };
+  protected _configureShaders(): Record<keyof RenderingLayers, typeof AdaptiveLightingShader>;
 
   /**
    * Specific configuration for a layer.
    */
-  protected _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+  protected _configureLayer(layer: RenderedEffectSource.SourceLayer, layerId: string): void;
 
   /**
    * Create the geometry for the source shape that is used in shaders and compute its bounds for culling purpose.
@@ -134,11 +127,8 @@ declare class RenderedEffectSource<
   /**
    * Render the containers used to represent this light source within the LightingLayer
    */
-  drawMeshes(): {
-    background: PIXI.Mesh;
-    coloration: PIXI.Mesh;
-    illumination: PIXI.Mesh;
-  };
+  drawMeshes(): Record<keyof RenderingLayers, PIXI.Mesh | null>;
+
   /**
    * Create a Mesh for a certain rendered layer of this source.
    * @param layerId - The layer key in layers to draw
@@ -166,18 +156,22 @@ declare class RenderedEffectSource<
    */
   protected _updateIlluminationUniforms(): void;
 
+  protected override _destroy(): void;
+
   /**
    * Animate the PointSource, if an animation is enabled and if it currently has rendered containers.
    * @param dt - Delta time.
+   * @privateRemarks In core this will return `void`, as the `this.animation.animation` function will  be a {@link BaseLightSource.LightAnimationFunction}
+   * and in fact most of the time will be `RenderedEffectSource#animateTime`, but it could technically be set to any function
    */
-  animate(dt: number): this["animation"]["animation"] extends (...args: any) => infer Return ? Return : void;
+  animate(dt: number): this["animation"]["animation"] extends (...args: infer _1) => infer Return ? Return : void;
 
   /**
    * Generic time-based animation used for Rendered Point Sources.
    * @param dt      - Delta time.
    * @param options - Options which affect the time animation
    */
-  animateTime(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+  animateTime(dt: number, options?: RenderedEffectSource.AnimationFunctionOptions): void;
 
   /**
    * Get corrected level according to level and active vision mode data.
@@ -196,12 +190,14 @@ declare class RenderedEffectSource<
   ): Color;
 
   /**
-   * @deprecated since v11
+   * @deprecated since v11, until v13
+   * @remarks "The RenderedEffectSource#preview is deprecated. Use RenderedEffectSource#isPreview instead."
    */
   set preview(preview: boolean);
 
   /**
-   * @deprecated since v11
+   * @deprecated since v11, until v13
+   * @remarks "The RenderedEffectSource#preview is deprecated. Set RenderedEffectSource#preview as part of RenderedEffectSource#initialize instead."
    */
   get preview(): boolean;
 }
@@ -209,122 +205,163 @@ declare class RenderedEffectSource<
 declare namespace RenderedEffectSource {
   type Any = RenderedEffectSource<any, any, any>;
 
-  interface RenderedEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+  type AnyConstructor = typeof AnyRenderedEffectSource;
+
+  interface SourceData extends BaseEffectSource.SourceData {
     /**
      * An animation configuration for the source
      */
     animation: object;
+
     /**
      * A color applied to the rendered effect
      */
     color: number | null;
+
     /**
      * An integer seed to synchronize (or de-synchronize) animations
      */
     seed: number | null;
+
     /**
      * Is this source a temporary preview?
      */
     preview: boolean;
   }
 
-  interface AnimationOptions {
+  type AnimationFunction = (
+    this: RenderedEffectSource,
+    /** Delta time */
+    dt: number,
+    options?: AnimationFunctionOptions,
+  ) => void;
+
+  /** @internal */
+  type _AnimationFunctionOptions = InexactPartial<{
     /**
      * The animation speed, from 0 to 10
      * @defaultValue `5`
+     * @remarks Can't be null due to only having default via signature
      */
-    speed?: number;
+    speed: number;
 
     /**
      * The animation intensity, from 1 to 10
      * @defaultValue `5`
+     * @remarks Can't be null due to only having default via signature
      */
-    intensity?: number;
+    intensity: number;
 
     /**
      * Reverse the animation direction
      * @defaultValue `false`
      */
-    reverse?: boolean;
-  }
+    reverse: boolean | null;
+  }>;
+
+  /** Shared options for the {@link AnimationFunction}s provided by `_Source` classes */
+  interface AnimationFunctionOptions extends _AnimationFunctionOptions {}
 
-  interface RenderedEffectSourceAnimationConfig {
+  type AnimationConfig = InexactPartial<{
     /**
      * The human-readable (localized) label for the animation
      */
-    label?: string | undefined;
+    label: string;
+
     /**
      * The animation function that runs every frame
      * @privateRemarks TODO: Figure out if there's a better way to define the function
      */
-    animation?: AnyFunction | undefined;
+    animation: RenderedEffectSource.AnimationFunction;
+
     /**
      * A custom illumination shader used by this animation
      */
-    illuminationShader?: AdaptiveIlluminationShader | undefined;
+    illuminationShader: typeof AdaptiveIlluminationShader;
+
     /**
      * A custom coloration shader used by this animation
      */
-    colorationShader?: AdaptiveColorationShader | undefined;
+    colorationShader: typeof AdaptiveColorationShader;
+
     /**
      * A custom background shader used by this animation
      */
-    backgroundShader?: AdaptiveBackgroundShader | undefined;
+    backgroundShader: typeof AdaptiveBackgroundShader;
+
     /**
      * A custom darkness shader used by this animation
      */
-    darknessShader?: AdaptiveDarknessShader | undefined;
+    darknessShader: typeof AdaptiveDarknessShader;
+
     /**
      * The animation seed
      */
-    seed?: number | undefined;
+    seed: number;
+
     /**
      * The animation time
      */
-    time?: number | undefined;
-  }
+    time: number;
+  }>;
 
-  interface RenderedEffectSourceLayer {
+  /**
+   * @remarks The properties `mesh` and `shader` from `LayerConfig` are not documented as being part of the typedef. They are given values
+   * during initialization *if* the Source has a valid `Placeable` as its `object`. `vmUniforms` is only provided a value for `PointVisionSource` layers.
+   */
+  interface SourceLayer extends LayerConfig {
     /**
      * Is this layer actively rendered?
      */
     active: boolean;
+
     /**
      * Do uniforms need to be reset?
      */
     reset: boolean;
+
     /**
      * Is this layer temporarily suppressed?
      */
     suppressed: boolean;
+
     /**
      * The rendered mesh for this layer
      */
-    mesh: PointSourceMesh;
+    mesh: PointSourceMesh | undefined;
+
     /**
      * The shader instance used for the layer
      */
-    shader: AdaptiveLightingShader;
+    shader: AdaptiveLightingShader | undefined;
+
+    /** @remarks Foundry does not include this in the typedef but is in the initalization of `RenderedEffectSource#layers` */
+    vmUniforms: AbstractBaseShader.Uniforms | undefined;
   }
 
-  interface RenderedEffectLayerConfig {
+  interface LayerConfig {
     /**
      * The default shader used by this layer
      */
-    defaultShader: AdaptiveLightingShader;
+    defaultShader: typeof AdaptiveLightingShader;
+
     /**
      * The blend mode used by this layer
      */
-    blendMode: PIXI.BLEND_MODES;
+    blendMode: keyof typeof PIXI.BLEND_MODES;
   }
 
-  // Interface causes errors
+  // Interface would require `RenderingLayers extends ... = InterfaceToObject<Layers>` in every subclass signature
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
   type Layers = {
-    background: RenderedEffectSource.RenderedEffectSourceLayer;
-    coloration: RenderedEffectSource.RenderedEffectSourceLayer;
-    illumination: RenderedEffectSource.RenderedEffectSourceLayer;
+    background: RenderedEffectSource.SourceLayer;
+    coloration: RenderedEffectSource.SourceLayer;
+    illumination: RenderedEffectSource.SourceLayer;
   };
 }
 
+declare abstract class AnyRenderedEffectSource extends RenderedEffectSource<any, any, any> {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default RenderedEffectSource;

package/src/foundry/client-esm/canvas/tokens/_module.d.mts

@@ -1,8 +1,7 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
-/* eslint-disable import/no-unresolved */ // TODO: Remove when the files are instantiated
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export { default as TokenRing } from "./ring.mjs";
 export { default as TokenRingConfig } from "./ring-config.mjs";

package/src/foundry/client-esm/canvas/tokens/ring-config.d.mts

@@ -1,3 +1,5 @@
+import type DynamicRingData from "./ring-data.d.mts";
+import type TokenRing from "./ring.d.mts";
 
 /**
  * Token Ring configuration Singleton Class.
@@ -73,8 +75,116 @@
  * CONFIG.Token.ring.debugColorBands = true;
  * ```
  */
-declare class TokenRingConfig {}
+declare class TokenRingConfig {
+  #TokenRingConfig: true;
 
-declare namespace TokenRingConfig {}
+  constructor();
+
+  /**
+   * Core token rings used in Foundry VTT.
+   * Each key is a string identifier for a ring, and the value is an object containing the ring's data.
+   * This object is frozen to prevent any modifications.
+   */
+  static CORE_TOKEN_RINGS: TokenRingConfig.CoreTokenRings;
+
+  /**
+   * Core token rings fit modes used in Foundry VTT.
+   */
+  static CORE_TOKEN_RINGS_FIT_MODES: TokenRingConfig.CoreTokenRingsFitModes;
+
+  /** Register the token ring config and initialize it */
+  static initialize(): void;
+
+  /** Register game settings used by the Token Ring */
+  static registerSettings(): void;
+
+  /** A mapping of token subject paths where modules or systems have configured subject images. */
+  subjectPaths: Record<string, string>;
+
+  /**
+   * All color bands visual debug flag.
+   * @defaultValue `false`
+   */
+  debugColorBands: boolean;
+
+  /**
+   * Get the current ring class.
+   */
+  get ringClass(): typeof TokenRing;
+  set ringClass(value);
+
+  /** Get the current effects. */
+  get effects(): Record<string, string>;
+
+  /** Get the current spritesheet. */
+  get spritesheet(): string;
+
+  /** Get the current shader class. */
+  get shaderClass(): typeof PrimaryBaseSamplerShader;
+  set shaderClass(value);
+
+  /** Get the current localized label */
+  get label(): string;
+
+  /** Get the current id. */
+  get id(): string;
+
+  /** Is a custom fit mode active? */
+  get isGridFitMode(): boolean;
+
+  /**
+   * Add a new ring configuration.
+   * @param id      - The id of the ring configuration.
+   * @param config  - The configuration object for the ring.
+   */
+  addConfig(id: string, config: TokenRingConfig): void;
+
+  /**
+   * Get a ring configuration.
+   * @param id  - The id of the ring configuration.
+   * @returns   - The ring configuration object.
+   */
+  getConfig(id: string): TokenRingConfig;
+
+  /**
+   * Use a ring configuration.
+   * @param id  - The id of the ring configuration to use.
+   * @returns   - True if the configuration was successfully set, false otherwise.
+   */
+  useConfig(id: string): boolean;
+
+  /** Get the IDs of all configurations. */
+  get configIDs(): string[];
+
+  /** Get the labels of all configurations. */
+  get configLabels(): Record<string, string>;
+
+  /** @deprecated since v11 */
+  get configNames(): string[];
+}
+
+declare namespace TokenRingConfig {
+  /** Token ring fit modes for dynamic token ring visualization */
+  interface RingFitMode {
+    /** The fit mode identifier. */
+    id: string;
+
+    /** The fit mode label. */
+    label: string;
+  }
+
+  /** Dynamic ring id. */
+  type DynamicRingId = string;
+
+  /**
+   * Core token rings used in Foundry VTT.
+   * Each key is a string identifier for a ring, and the value is an object containing the ring's data.
+   * This object is frozen to prevent any modifications.
+   */
+  interface CoreTokenRings extends Readonly<Record<DynamicRingId, DynamicRingData.RingData>> {}
+
+  /** Core token rings fit modes used in Foundry VTT. */
+  interface CoreTokenRingsFitModes extends Readonly<Record<string, RingFitMode>> {}
+}
 
 export default TokenRingConfig;