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

package/src/foundry/client/pixi/core/loader.d.mts

@@ -1,10 +1,17 @@
-import type { AnyObject } from "../../../../types/utils.d.mts";
+import type { InexactPartial, NullishProps } from "fvtt-types/utils";
+import type { TranscoderWorker } from "@pixi/basis";
 
 declare global {
   /**
    * A Loader class which helps with loading video and image textures
    */
   class TextureLoader {
+    /**
+     * A global reference to the singleton texture loader
+     * @privateRemarks This is set outside the class via `TextureLoader.loader = new TextureLoader();`
+     */
+    static loader: TextureLoader;
+
     /**
      * The duration in milliseconds for which a texture will remain cached
      * @defaultValue `1000 * 60 * 15`
@@ -14,7 +21,7 @@ declare global {
     /**
      * Initialize the basis transcoder for PIXI.Assets
      */
-    static initializeBasisTranscoder(): Promise<unknown>;
+    static initializeBasisTranscoder(): TextureLoader.TranscodeWorkerLoadTranscoderReturn | Promise<void>;
 
     /**
      * Check if a source has a text file extension.
@@ -31,7 +38,7 @@ declare global {
      *                     (default: `1`)
      * @returns The texture data if the texture is valid, else undefined.
      */
-    static getTextureAlphaData(texture: PIXI.Texture, resolution?: number): TextureLoader.TextureAlphaData | undefined;
+    static getTextureAlphaData(texture: PIXI.Texture, resolution?: number): TextureLoader.TextureAlphaData | void;
 
     /**
      * Load all the textures which are required for a particular Scene
@@ -41,8 +48,8 @@ declare global {
      */
     static loadSceneTextures(
       scene: Scene.ConfiguredInstance,
-      options?: Partial<TextureLoader.LoadSceneTextureOptions>,
-    ): Promise<void[]>;
+      options?: TextureLoader.LoadSceneTexturesOptions,
+    ): Promise<void>;
 
     /**
      * Load an Array of provided source URL paths
@@ -51,58 +58,29 @@ declare global {
      *                  (default: `{}`)
      * @returns A Promise which resolves once all textures are loaded
      */
-    load(sources: string[], options?: Partial<TextureLoader.LoadOptions>): Promise<PIXI.BaseTexture | void[]>;
+    load(sources: string[], options?: TextureLoader.LoadOptions): Promise<void>;
 
     /**
      * Load a single texture on-demand from a given source URL path
      * @param src - The source texture path to load
      * @returns The loaded texture object
      */
-    loadTexture(src: string): Promise<PIXI.BaseTexture | PIXI.Spritesheet | null>;
-
-    /**
-     * Log texture loading progress in the console and in the Scene loading bar
-     * @internal
-     */
-    protected _onProgress(src: string, progress: TextureLoader.Progress): void;
-
-    /**
-     * Log failed texture loading
-     * @internal
-     */
-    protected _onError(src: string, progress: TextureLoader.Progress, error: Error): void;
+    loadTexture(src: string): TextureLoader.LoadTextureReturn;
 
     /**
      * Use the Fetch API to retrieve a resource and return a Blob instance for it.
+     * @param src     - The resource URL
      * @param options - Options to configure the loading behaviour.
-     *                  (default: `{}`)
-     * @internal
+     * @returns A Blob containing the loaded data
      */
-    protected _fetchResource(
-      src: string,
-      options?: {
-        /**
-         * Append a cache-busting query parameter to the request.
-         * @defaultValue `false`
-         */
-        bustCache?: boolean | undefined;
-      },
-    ): Promise<Blob>;
-
-    /**
-     * Return a URL with a cache-busting query parameter appended.
-     * @param src - The source URL being attempted
-     * @returns The new URL, or false on a failure.
-     * @internal
-     */
-    protected _getCacheBustURL(src: string): string | false;
+    static fetchResource(src: string, options?: TextureLoader.FetchResourceOptions): Promise<Blob>;
 
     /**
      * Add an image or a sprite sheet url to the assets cache.
      * @param src - The source URL
      * @param tex - The readied texture
      */
-    setCache(src: string, tex: PIXI.BaseTexture | PIXI.Spritesheet): void;
+    setCache(src: string, asset: PIXI.BaseTexture | PIXI.Spritesheet): void;
 
     /**
      * Retrieve a texture or a sprite sheet from the assets cache
@@ -113,40 +91,43 @@ declare global {
     /**
      * Expire and unload assets from the cache which have not been used for more than CACHE_TTL milliseconds.
      */
-    expireCache(): void;
+    expireCache(): Promise<void>;
+
     /**
      * Return a URL with a cache-busting query parameter appended.
      * @param src - The source URL being attempted
      * @returns The new URL, or false on a failure.
      */
-    static getCacheBustURL(src: string): string | boolean;
+    static getCacheBustURL(src: string): string | false;
 
     /**
      * @deprecated since v11, will be removed in v13
      * @remarks TextureLoader#loadImageTexture is deprecated. Use TextureLoader#loadTexture instead.
      */
-    loadImageTexture(src: string): Promise<PIXI.BaseTexture>;
+    loadImageTexture(src: string): TextureLoader.LoadTextureReturn;
 
     /**
      * @deprecated since v11, will be removed in v13
      * @remarks TextureLoader#loadVideoTexture is deprecated. Use TextureLoader#loadTexture instead.
      */
-    loadVideoTexture(src: string): Promise<PIXI.BaseTexture>;
+    loadVideoTexture(src: string): TextureLoader.LoadTextureReturn;
 
     /**
      * @deprecated since v12, will be removed in v14
      * @remarks `"TextureLoader.textureBufferDataMap is deprecated without replacement. Use TextureLoader.getTextureAlphaData`
      * `to create a texture data map and cache it automatically, or create your own caching system."`
      */
-    static get textureBufferDataMap(): Map<string, AnyObject>
-
-    /**
-     * A global reference to the singleton texture loader
-     */
-    static loader: TextureLoader;
+    static get textureBufferDataMap(): Map<unknown, unknown>;
   }
 
   namespace TextureLoader {
+    interface Any extends AnyTextureLoader {}
+    type AnyConstructor = typeof AnyTextureLoader;
+
+    type TranscodeWorkerLoadTranscoderReturn = ReturnType<typeof TranscoderWorker.loadTranscoder>;
+
+    type LoadTextureReturn = Promise<PIXI.BaseTexture | PIXI.Spritesheet | null>;
+
     interface TextureAlphaData {
       /** The width of the (downscaled) texture. */
       width: number;
@@ -170,50 +151,70 @@ declare global {
       data: Uint8Array;
     }
 
-    interface LoadSceneTextureOptions {
+    /** @internal */
+    type _LoadSceneTexturesOptions = InexactPartial<{
       /**
        * Destroy other expired textures
        * @defaultValue `true`
        */
-      expireCache?: boolean;
+      expireCache: boolean | null;
 
       /**
        * Additional sources to load during canvas initialize
        * @defaultValue `[]`
+       * @remarks Can't be `null` because it only has a parameter default.
+       * @privateRemarks Foundry types this as `boolean`, not even as an array, as of 13.335
        */
-      additionalSource?: Array<boolean>;
+      additionalSources: string[];
 
       /**
        * The maximum number of textures that can be loaded concurrently
+       * @remarks Can't be `null` becuase it is eventually passed to the constructor of
+       * {@link foundry.utils.Semaphore}, with only a parameter deafult.
        */
-      maxConcurrent?: number;
-    }
+      maxConcurrent: number;
+    }>;
 
-    interface LoadOptions {
+    /** Options for {@link TextureLoader.loadSceneTextures}*/
+    interface LoadSceneTexturesOptions extends _LoadSceneTexturesOptions {}
+
+    /** @internal */
+    type _LoadOptions = NullishProps<{
       /**
        * The status message to display in the load bar
+       * @remarks Allowed to be null or undefined because ultimately `HTMLElement.textContent = undefined`
+       * or `= null` (via {@link SceneNavigation.displayProgressBar}) does not error and simply blanks textContent.
        */
-      message?: string | undefined;
+      message: string;
 
       /**
        * Expire other cached textures?
+       * @defaultValue `false`
+       */
+      expireCache: boolean;
+
+      /**
+       * Display loading progress bar?
        * @defaultValue `true`
        */
-      expireCache?: boolean;
+      displayProgress: boolean;
+    }> &
+      /** @privateRemarks Can't Pick `expireCache`, despite it existing on `LoadSceneTexturesOptions`, as it has a different default here */
+      Pick<LoadSceneTexturesOptions, "maxConcurrent">;
 
+    /** Options for {@link TextureLoader#load} */
+    interface LoadOptions extends _LoadOptions {}
+
+    /** @internal */
+    type _FetchResourceOptions = NullishProps<{
       /**
-       * The maximum number of textures that can be loaded concurrently
+       * Append a cache-busting query parameter to the request.
+       * @defaultValue `false`
        */
-      maxConcurrent?: number;
-    }
+      bustCache: boolean;
+    }>;
 
-    interface Progress {
-      message: string;
-      loaded: number;
-      failed: number;
-      total: number;
-      pct: number;
-    }
+    interface FetchResourceOptions extends _FetchResourceOptions {}
   }
 
   /**
@@ -228,7 +229,7 @@ declare global {
    * @param src - The texture path to load.
    * @returns A texture, a sprite sheet or null if not found in cache.
    */
-  function getTexture(src: string): PIXI.Texture | null;
+  function getTexture(src: string): LoadTexture.Return;
 
   /**
    * Load a single asset and return a Promise which resolves once the asset is ready to use
@@ -236,11 +237,20 @@ declare global {
    * @param options  - Additional options which modify assset loading
    * @returns The loaded Texture or sprite sheet, or null if loading failed with no fallback
    */
-  function loadTexture(
-    src: string,
-    options?: {
+  function loadTexture(src: string, options?: LoadTexture.Options): Promise<LoadTexture.Return>;
+
+  namespace LoadTexture {
+    type Return = PIXI.Texture | PIXI.Spritesheet | null;
+
+    /** @internal */
+    type _Options = NullishProps<{
       /** A fallback texture URL to use if the requested source is unavailable */
-      fallback?: string;
-    },
-  ): Promise<PIXI.Texture | PIXI.Spritesheet | null>;
+      fallback: string;
+    }>;
+    interface Options extends _Options {}
+  }
+}
+
+declare abstract class AnyTextureLoader extends TextureLoader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/core/shapes/limited-angle-polygon.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { InexactPartial } from "../../../../../utils/index.d.mts";
 
 declare global {
   /**
@@ -6,12 +6,12 @@ declare global {
    * The shape is defined by a point origin, radius, angle, and rotation.
    * The shape is further customized by a configurable density which informs the approximation.
    * An optional secondary externalRadius can be provided which adds supplementary visibility outside the primary angle.
+   * @param origin - The origin point for this polygon
+   * @param config - Configuration for the polygon.
+   * @remarks Despite `config` being an `={}` parameter, the `radius` key must be passed to avoid `NaN`s
    */
   class LimitedAnglePolygon extends PIXI.Polygon {
-    constructor(
-      origin: Canvas.Point,
-      { radius, angle, rotation, density, externalRadius }: LimitedAnglePolygon.ConstructorOptions,
-    );
+    constructor(origin: Canvas.Point, config: LimitedAnglePolygon.ConstructorOptions);
 
     /**
      * The origin point of the Polygon
@@ -59,6 +59,12 @@ declare global {
      */
     aMax: number;
 
+    /**
+     * The bounding box of the circle defined by the externalRadius, if any
+     * @privateRemarks Set in `##generatePoints`, which is called at the end of the constructor
+     */
+    externalBounds: PIXI.Rectangle;
+
     /**
      * Restrict the edges which should be included in a PointSourcePolygon based on this specialized shape.
      * We use two tests to jointly keep or reject edges.
@@ -67,9 +73,9 @@ declare global {
      * @param a - The first edge vertex
      * @param b - The second edge vertex
      * @returns Should the edge be included in the PointSourcePolygon computation?
-     * @internal
+     * @remarks Foundry marked `@internal`
      */
-    protected _includeEdge(a: Canvas.Point, b: Canvas.Point): boolean;
+    _includeEdge(a: Canvas.Point, b: Canvas.Point): boolean;
 
     /**
      * Test whether a vertex lies between two boundary rays.
@@ -85,35 +91,49 @@ declare global {
   }
 
   namespace LimitedAnglePolygon {
-    interface ConstructorOptions {
-      /**
-       * The radius of the emitted cone.
-       */
-      radius: number;
+    interface Any extends AnyLimitedAnglePolygon {}
+    type AnyConstructor = typeof AnyLimitedAnglePolygon;
 
+    /** @internal */
+    type _ConstructorOptions = InexactPartial<{
       /**
        * The angle of the Polygon in degrees.
        * @defaultValue `360`
+       * @remarks Can't be `null` as it only has a parameter default
        */
-      angle?: number;
+      angle: number;
 
       /**
        * The direction of rotation at the center of the emitted angle in degrees.
        * @defaultValue `0`
+       * @remarks Can't be `null` as it only has a parameter default
        */
-      rotation?: number;
+      rotation: number;
 
       /**
        * The density of rays which approximate the cone, defined as rays per PI.
        * @defaultValue `PIXI.Circle.approximateVertexDensity(this.radius)`
        */
-      density?: number;
+      density: number | null;
 
       /**
        * An optional "external radius" which is included in the polygon for the supplementary area outside the cone.
        * @defaultValue `0`
+       * @remarks Only used if truthy
        */
-      externalRadius?: number;
+      externalRadius: number | null;
+    }>;
+
+    interface ConstructorOptions extends _ConstructorOptions {
+      /**
+       * The radius of the emitted cone.
+       * @privateRemarks This is given no default, but is directly used in multiplication and division, resulting in `NaN` if allowed to be `undefined`
+       */
+      radius: number;
     }
   }
 }
+
+declare abstract class AnyLimitedAnglePolygon extends LimitedAnglePolygon {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/core/shapes/polygon-mesher.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
+import type { IntentionalPartial } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -10,14 +10,13 @@ declare global {
      * @param poly    - Closed polygon to be processed and converted to a mesh
      *                  (array of points or PIXI Polygon)
      * @param options - Various options : normalizing, offsetting, add depth, ...
+     * @remarks `options` is `IntentionalPartial`'d because the constructor immediately does
+     * `this.options = {...this.constructor._defaultOptions, ...options}`, so explicit `undefined` would break things
      */
-    constructor(poly: number[] | PIXI.Polygon, options?: InexactPartial<PolygonMesherOptions>);
-
-    /** Contains options to apply during the meshing process */
-    options: PolygonMesherOptions;
+    constructor(poly: PIXI.Polygon.OrPointsFlat, options?: IntentionalPartial<PolygonMesher.Options>);
 
     /** Default options values */
-    static _defaultOptions: PolygonMesherOptions;
+    static _defaultOptions: PolygonMesher.Options;
 
     /**
      * Polygon mesh vertices
@@ -29,14 +28,20 @@ declare global {
      */
     indices: number[];
 
+    /** Contains options to apply during the meshing process */
+    options: PolygonMesher.Options;
+
     /**
      * Convert a flat points array into a 2 dimensional ClipperLib path
      * @param poly      - PIXI.Polygon or points flat array.
      * @param dimension - Dimension.
      *                    (default 2)
      * @returns The clipper lib path.
+     * @throws If `dimension < 2`
+     * @privateRemarks Foundry types this return as `number[] | undefined`, but it cannot return either of those;
+     * Either it will throw or return a (possibly empty) `ClipperLib.Path` (an array-like of `ClipperLib.IntPoint`s)
      */
-    static getClipperPathFromPoints(poly: number[] | PIXI.Polygon, dimension?: number): number[] | undefined;
+    static getClipperPathFromPoints(poly: PIXI.Polygon.OrPointsFlat, dimension?: number): ClipperLib.Path;
 
     /**
      * Execute the triangulation to create indices
@@ -46,65 +51,88 @@ declare global {
     triangulate(geometry: PIXI.Geometry): PIXI.Geometry;
   }
 
-  interface PolygonMesherOptions {
-    /**
-     * The position value in pixels
-     * @defaultValue `0`
-     */
-    offset: number;
-
-    /**
-     * Should the vertices be normalized?
-     * @defaultValue `false`
-     */
-    normalize: boolean;
-
-    /**
-     * The x origin
-     * @defaultValue `0`
-     */
-    x: number;
-
-    /**
-     * The y origin
-     * @defaultValue `0`
-     */
-    y: number;
-
-    /**
-     * The radius
-     * @defaultValue `0`
-     */
-    radius: number;
-
-    /**
-     * The depth value on the outer polygon
-     * @defaultValue `0`
-     */
-    depthOuter: number;
-
-    /**
-     * The depth value on the inner polygon
-     * @defaultValue `1`
-     */
-    depthInner: number;
+  namespace PolygonMesher {
+    interface Any extends AnyPolygonMesher {}
+    type AnyConstructor = typeof AnyPolygonMesher;
 
     /**
-     * Constant multiplier to avoid floating point imprecision with ClipperLib
-     * @defaultValue `10e8`
+     *  @remarks These properties all have non-nullish values in `_defaultOptions`, and explicit `undefined` breaks
+     * things that aren't `boolean` due to math and object spread syntax in the constructor. `null` has been allowed
+     * where its casting to `0` or `false` doesn't break things.
      */
-    scale: number;
-
-    /**
-     * Distance of the miter limit, when sharp angles are cut during offsetting.
-     * @defaultValue `7`
-     */
-    miterLimit: number;
-
-    /**
-     * Should the vertex data be interleaved into one VBO?
-     * @defaultValue `false`
-     */
-    interleaved: boolean;
+    interface Options {
+      /**
+       * The position value in pixels
+       * @defaultValue `0`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      offset: number | null;
+
+      /**
+       * Should the vertices be normalized?
+       * @defaultValue `false`
+       */
+      normalize: boolean | undefined | null;
+
+      /**
+       * The x origin
+       * @defaultValue `0`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      x: number | null;
+
+      /**
+       * The y origin
+       * @defaultValue `0`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      y: number | null;
+
+      /**
+       * The radius
+       * @defaultValue `0`
+       * @remarks Can't be `null` because of an `=== 0` check, nor `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      radius: number;
+
+      /**
+       * The depth value on the outer polygon
+       * @defaultValue `0`
+       * @remarks Can't be `null` as it can be pushed directly into a `number[]`, nor `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      depthOuter: number;
+
+      /**
+       * The depth value on the inner polygon
+       * @defaultValue `1`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      depthInner: number | null;
+
+      /**
+       * Constant multiplier to avoid floating point imprecision with ClipperLib
+       * @defaultValue `10e8`
+       * @remarks Not allowing `null` because a zero value here defeats the purpose, and `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      scale: number;
+
+      /**
+       * Distance of the miter limit, when sharp angles are cut during offsetting.
+       * @defaultValue `7`
+       * @remarks Allowed to be `undefined` but not `null` because it is passed to
+       * `new ClipperLib.ClipperOffset()`, which provides its own default if `=== undefined`
+       */
+      miterLimit: number | undefined;
+
+      /**
+       * Should the vertex data be interleaved into one VBO?
+       * @defaultValue `false`
+       */
+      interleaved: boolean | undefined | null;
+    }
   }
 }
+
+declare abstract class AnyPolygonMesher extends PolygonMesher {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/core/shapes/precise-text.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -6,22 +6,40 @@ declare global {
    * At default resolution Text often looks blurry or fuzzy.
    */
   class PreciseText extends PIXI.Text {
-    /**
-     * @param options - Additional options merged with the default TextStyle
-     */
     constructor(...args: ConstructorParameters<typeof PIXI.Text>);
 
+    /** @defaultValue `false` */
+    override _autoResolution: boolean;
+
+    /** @defaultValue `2` */
+    override _resolution: number;
     /**
      * Prepare a TextStyle object which merges the canvas defaults with user-provided options
      * @param anchor  - A text anchor point from CONST.TEXT_ANCHOR_POINTS
      * @param options - Additional options merged with the default TextStyle
      * @returns The prepared TextStyle
      */
-    static getTextStyle({
-      anchor,
-      ...options
-    }?: { anchor?: foundry.CONST.TEXT_ANCHOR_POINTS } & ConstructorParameters<
-      typeof PIXI.TextStyle
-    >[0]): PIXI.TextStyle;
+    static getTextStyle({ anchor, ...options }?: PreciseText.GetTextStyleOptions): PIXI.TextStyle;
   }
+
+  namespace PreciseText {
+    interface Any extends AnyPreciseText {}
+    type AnyConstructor = typeof AnyPreciseText;
+
+    /** @internal */
+    type _GetTextStyleOptions = NullishProps<{
+      /**
+       * A text anchor point from CONST.TEXT_ANCHOR_POINTS
+       * @remarks Only checked againt `.RIGHT` and `.LEFT`, and only if an `align` key is omitted
+       */
+      anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
+    }> &
+      // Can't be NullishProps because keys are only checked for `!== undefined` in PIXI
+      InexactPartial<PIXI.ITextStyle>;
+    interface GetTextStyleOptions extends _GetTextStyleOptions {}
+  }
+}
+
+declare abstract class AnyPreciseText extends PreciseText {
+  constructor(arg0: never, ...args: never[]);
 }