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

package/src/foundry/client/pixi/webgl/shaders/vision/illumination-vision.d.mts

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Identity } from "../../../../../../utils/index.d.mts";
 
 declare global {
-  namespace IlluminationVisionShader {
-    type AnyConstructor = typeof AnyIlluminationVisionShader;
-  }
-
   /**
    * The default illumination shader used for vision sources
    */
@@ -33,4 +25,13 @@ declare global {
 
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace IlluminationVisionShader {
+    interface Any extends AnyIlluminationVisionShader {}
+    interface AnyConstructor extends Identity<typeof AnyIlluminationVisionShader> {}
+  }
+}
+
+declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/base-weather.d.mts

@@ -1,9 +1,4 @@
-import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
-import type { AnyObject, RemoveIndexSignatures } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyAbstractWeatherShader extends AbstractWeatherShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { RemoveIndexSignatures, FixedInstanceType, Identity } from "#utils";
 
 type AbstractBaseShaderClass = typeof AbstractBaseShader;
 
@@ -17,41 +12,18 @@ declare const InternalAbstractWeatherShader_Const: InternalAbstractWeatherShader
 
 // @ts-expect-error - This pattern inherently requires a ts-expect-error as the base class is dynamic.
 class InternalAbstractWeatherShader<
-  DefaultUniforms extends AnyObject,
-  _ComputedUniforms extends object = RemoveIndexSignatures<Extract<DefaultUniforms, AnyObject>>,
+  DefaultUniforms extends AbstractBaseShader.Uniforms,
+  _ComputedUniforms extends object = RemoveIndexSignatures<DefaultUniforms>,
 > extends InternalAbstractWeatherShader_Const<_ComputedUniforms> {}
 
 declare global {
-  namespace AbstractWeatherShader {
-    type AnyConstructor = typeof AnyAbstractWeatherShader;
-
-    interface CommonUniforms {
-      terrainUvMatrix: PIXI.Matrix;
-      useOcclusion: boolean;
-      occlusionTexture: PIXI.Matrix | null;
-      reverseOcclusion: boolean;
-      occlusionWeights: number[];
-      useTerrain: boolean;
-      terrainTexture: PIXI.Texture | null;
-      reverseTerrain: boolean;
-      terrainWeights: number[];
-      alpha: number;
-      tint: number[];
-      screenDimensions: [number, number];
-      effectDimensions: [number, number];
-      depthElevation: number;
-      time: number;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    interface DefaultUniforms {}
-  }
-
   /**
    * The base shader class for weather shaders.
+   * @typeParam DefaultUniforms - An interface representing an `AbstractWeatherShader` subclass's `static defaultUniforms`
+   * @remarks For each key in `static defaultOptions`, dynamically defines a getter/setter pair for `this.uniforms[key]` on the instance
    */
   class AbstractWeatherShader<
-    DefaultUniforms extends AnyObject = InterfaceToObject<AbstractWeatherShader.DefaultUniforms>,
+    DefaultUniforms extends AbstractBaseShader.Uniforms = AbstractWeatherShader.DefaultUniforms,
   > extends InternalAbstractWeatherShader<DefaultUniforms> {
     constructor(...args: ConstructorParameters<typeof AbstractBaseShader>);
 
@@ -74,8 +46,8 @@ declare global {
 
     static override create<ThisType extends AbstractBaseShader.AnyConstructor>(
       this: ThisType,
-      initialUniforms?: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+      initialUniforms?: AbstractBaseShader.Uniforms | null,
+    ): FixedInstanceType<ThisType>;
 
     /**
      * Create the shader program.
@@ -90,6 +62,9 @@ declare global {
      */
     set scale(scale: number | { x: number; y?: number });
 
+    /** @remarks No getter is actually provided */
+    get scale(): undefined;
+
     set scaleX(x: number);
 
     set scaleY(y: number);
@@ -103,4 +78,33 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace AbstractWeatherShader {
+    interface Any extends AnyAbstractWeatherShader {}
+    interface AnyConstructor extends Identity<typeof AnyAbstractWeatherShader> {}
+
+    interface CommonUniforms extends AbstractBaseShader.Uniforms {
+      terrainUvMatrix: PIXI.Matrix;
+      useOcclusion: boolean;
+      occlusionTexture: PIXI.Matrix | null;
+      reverseOcclusion: boolean;
+      occlusionWeights: number[];
+      useTerrain: boolean;
+      terrainTexture: PIXI.Texture | null;
+      reverseTerrain: boolean;
+      terrainWeights: number[];
+      alpha: number;
+      tint: Color.RGBColorVector;
+      screenDimensions: [number, number];
+      effectDimensions: [number, number];
+      depthElevation: number;
+      time: number;
+    }
+
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms {}
+  }
+}
+
+declare abstract class AnyAbstractWeatherShader extends AbstractWeatherShader<AbstractWeatherShader.DefaultUniforms> {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/effect.d.mts

@@ -1,47 +1,30 @@
-import type { InexactPartial } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyWeatherShaderEffect extends WeatherShaderEffect<any> {
-  constructor(arg0: never, ...args: never[]);
-}
-
-type QuadMeshClass = typeof QuadMesh;
-
-interface InternalWeatherShaderEffect_Interface extends QuadMeshClass {
-  new <ShaderClassInstance extends object>(
-    ...args: ConstructorParameters<typeof QuadMesh>
-  ): QuadMesh & ShaderClassInstance;
-}
-
-declare const InternalWeatherShaderEffect_Const: InternalWeatherShaderEffect_Interface;
-
-// @ts-expect-error - This pattern inherently requires a ts-expect-error as the base class is dynamic.
-class InternalWeatherShaderEffect<
-  ShaderClass extends AbstractBaseShader.AnyConstructor,
-  _ShaderClassInstance extends object = InstanceType<ShaderClass>,
-> extends InternalWeatherShaderEffect_Const<_ShaderClassInstance> {}
+import type { Identity, IntentionalPartial } from "#utils";
 
 declare global {
-  namespace WeatherShaderEffect {
-    type AnyConstructor = typeof AnyWeatherShaderEffect;
-
-    type WeatherShaderEffectConfig = InexactPartial<AbstractBaseShader.Uniforms & WeatherShaderEffect["shader"]>;
-  }
-
   /**
    * An interface for defining shader-based weather effects
    */
-  class WeatherShaderEffect<
-    ShaderClass extends AbstractWeatherShader.AnyConstructor = AbstractWeatherShader.AnyConstructor,
-  > extends InternalWeatherShaderEffect<ShaderClass> {
+  class WeatherShaderEffect extends QuadMesh {
     /**
      * @param config - The config object to create the shader effect
      */
-    constructor(config: WeatherShaderEffect.WeatherShaderEffectConfig, shaderClass: ShaderClass);
+    constructor(
+      config: WeatherShaderEffect.Configuration | undefined,
+      shaderClass: AbstractWeatherShader.AnyConstructor,
+    );
+
+    /** @privateRemarks Override not in Foundry code, but reflects reality at runtime */
+    override get shader(): AbstractWeatherShader;
+
+    /** @privateRemarks Override not in Foundry code, but reflects reality at runtime */
+    override setShaderClass(shaderClass: AbstractWeatherShader.AnyConstructor): void;
 
     /**
      * Set shader parameters.
      */
-    configure(config?: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+    configure(
+      config?: WeatherShaderEffect.Configuration, // not:null (gets `Object.entries()`ed)
+    ): void;
 
     /**
      * Begin animation
@@ -57,6 +40,17 @@ declare global {
      * Initialize the weather effect.
      * @param config - Config object.
      */
-    protected _initialize(config: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+    protected _initialize(config: WeatherShaderEffect.Configuration): void;
   }
+
+  namespace WeatherShaderEffect {
+    interface Any extends AnyWeatherShaderEffect {}
+    interface AnyConstructor extends Identity<typeof AnyWeatherShaderEffect> {}
+
+    type Configuration = IntentionalPartial<AbstractBaseShader.Uniforms & AbstractWeatherShader>;
+  }
+}
+
+declare abstract class AnyWeatherShaderEffect extends WeatherShaderEffect {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/fog.d.mts

@@ -1,26 +1,12 @@
-import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
-
-declare abstract class AnyFogShader extends FogShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Identity } from "../../../../../../utils/index.d.mts";
 
 declare global {
-  namespace FogShader {
-    type AnyConstructor = typeof AnyFogShader;
-
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
-      intensity: number;
-      rotation: number;
-      slope: number;
-    }
-  }
-
   /**
    * Fog shader effect.
    */
   class FogShader<
     DefaultUniforms extends FogShader.DefaultUniforms = FogShader.DefaultUniforms,
-  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+  > extends AbstractWeatherShader<DefaultUniforms> {
     /**
      * @defaultValue
      * ```js
@@ -47,4 +33,19 @@ declare global {
 
     static override fragmentShader(mode: number): string;
   }
+
+  namespace FogShader {
+    interface Any extends AnyFogShader {}
+    interface AnyConstructor extends Identity<typeof AnyFogShader> {}
+
+    interface DefaultUniforms extends AbstractWeatherShader.DefaultUniforms {
+      intensity: number;
+      rotation: number;
+      slope: number;
+    }
+  }
+}
+
+declare abstract class AnyFogShader extends FogShader {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/rain.d.mts

@@ -1,28 +1,12 @@
-import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
-
-declare abstract class AnyRainShader extends RainShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Identity } from "../../../../../../utils/index.d.mts";
 
 declare global {
-  namespace RainShader {
-    type AnyConstructor = typeof AnyRainShader;
-
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
-      opacity: number;
-      intensity: number;
-      strength: number;
-      rotation: number;
-      resolution: [number, number];
-    }
-  }
-
   /**
    * Rain shader effect.
    */
   class RainShader<
     DefaultUniforms extends RainShader.DefaultUniforms = RainShader.DefaultUniforms,
-  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+  > extends AbstractWeatherShader<DefaultUniforms> {
     /**
      * @defaultValue
      * ```js
@@ -39,4 +23,21 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace RainShader {
+    interface Any extends AnyRainShader {}
+    interface AnyConstructor extends Identity<typeof AnyRainShader> {}
+
+    interface DefaultUniforms extends AbstractWeatherShader.DefaultUniforms {
+      opacity: number;
+      intensity: number;
+      strength: number;
+      rotation: number;
+      resolution: [number, number];
+    }
+  }
+}
+
+declare abstract class AnyRainShader extends RainShader {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/webgl/shaders/weather/snow.d.mts

@@ -1,24 +1,12 @@
-import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
-
-declare abstract class AnySnowShader extends SnowShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Identity } from "../../../../../../utils/index.d.mts";
 
 declare global {
-  namespace SnowShader {
-    type AnyConstructor = typeof AnySnowShader;
-
-    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
-      direction: number;
-    }
-  }
-
   /**
    * Snow shader effect.
    */
   class SnowShader<
     DefaultUniforms extends SnowShader.DefaultUniforms = SnowShader.DefaultUniforms,
-  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+  > extends AbstractWeatherShader<DefaultUniforms> {
     /**
      * @defaultValue
      * ```
@@ -31,4 +19,17 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace SnowShader {
+    interface Any extends AnySnowShader {}
+    interface AnyConstructor extends Identity<typeof AnySnowShader> {}
+
+    interface DefaultUniforms extends AbstractWeatherShader.DefaultUniforms {
+      direction: number;
+    }
+  }
+}
+
+declare abstract class AnySnowShader extends SnowShader {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/workers/texture-worker.d.mts

@@ -1,4 +1,11 @@
-export {};
+import type { Identity, NullishProps } from "#utils";
+import type {
+  _ProcessBufferToBase64Options,
+  Debug,
+  ProcessBufferRedToBufferRGBAReturn,
+  ProcessBufferRGBAToBufferREDReturn,
+  ProcessBufferToBase64Return,
+} from "../../../../types/workers/image-compressor.d.mts";
 
 declare global {
   /**
@@ -23,8 +30,8 @@ declare global {
       buffer: Uint8ClampedArray,
       width: number,
       height: number,
-      options?: TextureCompressor.compressBase64Options,
-    ): Promise<unknown>;
+      options?: TextureCompressor.CompressBase64Options,
+    ): Promise<ProcessBufferToBase64Return>;
 
     /**
      * Expand a buffer in RED format to a buffer in RGBA format.
@@ -36,8 +43,8 @@ declare global {
       buffer: Uint8ClampedArray,
       width: number,
       height: number,
-      options?: TextureCompressor.expandRedToRGBAOptions,
-    ): Promise<unknown>;
+      options?: TextureCompressor.ExpandOrReduceBufferOptions,
+    ): Promise<ProcessBufferRedToBufferRGBAReturn>;
 
     /**
      * Expand a buffer in RED format to a buffer in RGBA format.
@@ -49,77 +56,50 @@ declare global {
       buffer: Uint8ClampedArray,
       width: number,
       height: number,
-      options?: TextureCompressor.reduceRGBAToRedOptions,
-    ): Promise<unknown>;
+      options?: TextureCompressor.ExpandOrReduceBufferOptions,
+    ): Promise<ProcessBufferRGBAToBufferREDReturn>;
   }
 
   namespace TextureCompressor {
-    interface ConstructorOptions {
+    interface Any extends AnyTextureCompressor {}
+    interface AnyConstructor extends Identity<typeof AnyTextureCompressor> {}
+
+    /** @internal */
+    type _ConstructorOptions = NullishProps<{
       /**
        * Should the worker run in debug mode?
        * @defaultValue `false`
        */
-      debug?: boolean;
+      debug: boolean;
 
       /**
        * @defaultValue `["./workers/image-compressor.js", "./spark-md5.min.js"]`
+       * @remarks Undocumented by Foundry
        */
-      scripts?: string[];
+      scripts: string[];
 
       /**
        * @defaultValue `false`
+       * @remarks Undocumented by Foundry
        */
-      loadPrimitives?: boolean;
+      loadPrimitives: boolean;
 
       /**
        * Do we need to control the hash?
        * @defaultValue `false`
        */
       controlHash?: boolean;
-    }
-
-    interface compressBase64Options {
-      /**
-       * The required image type.
-       * @defaultValue `"image/png"`
-       */
-      type?: string;
-
-      /**
-       * The required image quality.
-       * @defaultValue `1`
-       */
-      quality?: number;
-
-      /**
-       * The debug option.
-       * @defaultValue `false`
-       */
-      debug?: boolean;
+    }>;
 
-      readFormat: PIXI.FORMATS;
-    }
+    /** Options for the {@link TextureCompressor | `TextureCompressor`} constructor */
+    interface ConstructorOptions extends _ConstructorOptions {}
 
-    interface expandRedToRGBAOptions {
-      /**
-       * The debug option
-       * @defaultValue `false`
-       */
-      debug: boolean;
-    }
-
-    interface reduceRGBAToRedOptions {
-      /**
-       * The debug option
-       * @defaultValue `false`
-       */
-      debug?: boolean;
-
-      compression: (typeof TextureExtractor)["COMPRESSION_MODES"];
+    interface CompressBase64Options extends _ProcessBufferToBase64Options, Debug {}
 
-      type: string;
-
-      quality: number;
-    }
+    interface ExpandOrReduceBufferOptions extends Pick<_ProcessBufferToBase64Options, "hash">, Debug {}
   }
 }
+
+declare abstract class AnyTextureCompressor extends TextureCompressor {
+  constructor(...args: never);
+}

package/src/foundry/client/tours/setup-tour.d.mts

@@ -3,24 +3,29 @@ import type { Tour } from "../core/tour.d.mts";
 declare global {
   class SetupTour extends Tour {
     constructor(
-      config: SetupTourConfig,
-      { id, namespace }?: { id?: SetupTourConfig["id"]; namespace?: SetupTourConfig["namespace"] },
+      config: SetupTour.Config,
+      { id, namespace }?: { id?: SetupTour.Config["id"]; namespace?: SetupTour.Config["namespace"] },
     );
-    config: SetupTourConfig;
+    config: SetupTour.Config;
 
     focusedApp: Application.Any;
     override get canStart(): boolean;
-    override get steps(): TourStep[];
+    override get steps(): Tour.Step[];
     protected override _preStep(): Promise<void>;
     private _installingASystem(): Promise<void>;
     private _creatingAWorld(): Promise<void>;
   }
 
-  interface SetupTourConfig extends TourConfig {
-    /**
-     * Whether to close all open windows before beginning the tour.
-     * @defaultValue `true`
-     */
-    closeWindows: boolean;
+  namespace SetupTour {
+    interface Config extends Tour.Config {
+      /**
+       * Whether to close all open windows before beginning the tour.
+       * @defaultValue `true`
+       */
+      closeWindows: boolean;
+    }
   }
+
+  /** @deprecated {@link SetupTour.Config | `SetupTour.Config`} */
+  type SetupTourConfig = SetupTour.Config;
 }

package/src/foundry/client/ui/context.d.mts

@@ -1,50 +1,58 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { InexactPartial } from "#utils";
 import type ApplicationV2 from "../../client-esm/applications/api/application.d.mts";
 
-export {};
-
 declare global {
-  interface ContextMenuEntry {
-    /**
-     * The context menu label. Can be localized.
-     */
-    name: string;
-
-    /**
-     * A string containing an HTML icon element for the menu item
-     */
-    icon: string;
-
-    /**
-     * An identifier for a group this entry belongs to.
-     * @defaultValue `_none`
-     */
-    group?: string | undefined;
-
-    /**
-     * The function to call when the menu item is clicked. Receives the HTML element
-     * of the entry that this context menu is for.
-     */
-    callback: (target: JQuery) => void;
-
-    /**
-     * A function to call or boolean value to determine if this entry
-     * appears in the menu.
-     */
-    condition?: boolean | ((target: JQuery) => boolean) | undefined;
-  }
+  /**
+   * @deprecated {@link ContextMenu.Entry | `ContextMenu.Entry`}
+   */
+  type ContextMenuEntry = ContextMenu.Entry;
 
   /**
-   * @param html      - The HTML element of the context menu entry.
-   * @returns         whether the entry should be rendered in the context menu.
+   * @deprecated {@link ContextMenu.Condition | `ContextMenu.Condition`}
    */
-  type ContextMenuCondition = (html: JQuery) => boolean;
+  type ContextMenuCondition = ContextMenu.Condition;
 
   namespace ContextMenu {
     interface RenderOptions {
       /** The event that triggered the context menu opening. */
       event: PointerEvent;
     }
+
+    interface Entry {
+      /**
+       * The context menu label. Can be localized.
+       */
+      name: string;
+
+      /**
+       * A string containing an HTML icon element for the menu item
+       */
+      icon: string;
+
+      /**
+       * An identifier for a group this entry belongs to.
+       * @defaultValue `_none`
+       */
+      group?: string | undefined;
+
+      /**
+       * The function to call when the menu item is clicked. Receives the HTML element
+       * of the entry that this context menu is for.
+       */
+      callback: (target: JQuery) => void;
+
+      /**
+       * A function to call or boolean value to determine if this entry
+       * appears in the menu.
+       */
+      condition?: boolean | ((target: JQuery) => boolean) | undefined;
+    }
+
+    /**
+     * @param html      - The HTML element of the context menu entry.
+     * @returns         whether the entry should be rendered in the context menu.
+     */
+    type Condition = (html: JQuery) => boolean;
   }
 
   /**
@@ -65,7 +73,7 @@ declare global {
     constructor(
       element: JQuery,
       selector: string | null | undefined,
-      menuItems: ContextMenuEntry[],
+      menuItems: ContextMenu.Entry[],
       { hookName, onOpen, onClose }?: ContextMenu.ConstructorOptions,
     );
 
@@ -88,7 +96,7 @@ declare global {
     /**
      * The array of menu items being rendered
      */
-    menuItems: ContextMenuEntry[];
+    menuItems: ContextMenu.Entry[];
 
     /**
      * A function to call when the context menu is opened.
@@ -121,10 +129,10 @@ declare global {
      *                    (default: `"EntryContext"`)
      */
     static create(
-      app: Application | ApplicationV2,
+      app: Application.Any | ApplicationV2.Any,
       html: JQuery | HTMLElement,
       selector: string,
-      menuItems: ContextMenuEntry[],
+      menuItems: ContextMenu.Entry[],
       options?: ContextMenu.ConstructorOptions,
     ): ContextMenu;
 
@@ -137,7 +145,7 @@ declare global {
      * Closes the menu and removes it from the DOM.
      * @param options - Options to configure the closing behavior.
      */
-    close(options?: ContextMenu.CloseOptions | undefined): Promise<void>;
+    close(options?: ContextMenu.CloseOptions): Promise<void>;
 
     /** @internal */
     protected _close(): void;