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

package/src/foundry/client/pixi/core/interaction/resize-handle.d.mts

@@ -1,15 +1,15 @@
-export {};
+import type { NullishProps } from "fvtt-types/utils";
 
 declare global {
   class ResizeHandle extends PIXI.Graphics {
     /**
      * @param handlers - (default: `{}`)
      */
-    constructor(offset: ResizeHandle["offset"], handlers?: ResizeHandle["handlers"]);
+    constructor(offset: ResizeHandle.Offsets, handlers?: ResizeHandle.Handlers);
 
-    offset: [widthOffset: number, heightOffset: number];
+    offset: ResizeHandle.Offsets;
 
-    handlers: { canDrag?: boolean };
+    handlers: ResizeHandle.Handlers;
 
     /**
      * Track whether the handle is being actively used for a drag workflow
@@ -26,7 +26,7 @@ declare global {
       current: Canvas.Rectangle,
       origin: Canvas.Rectangle,
       destination: Canvas.Rectangle,
-      { aspectRatio }?: { aspectRatio?: number | null },
+      options?: ResizeHandle.UpdateDimensionsOptions,
     ): Canvas.Rectangle;
 
     activateListeners(): void;
@@ -49,4 +49,34 @@ declare global {
      */
     protected _onMouseDown(event: PIXI.FederatedEvent): void;
   }
+
+  namespace ResizeHandle {
+    interface Any extends AnyResizeHandle {}
+    type AnyConstructor = typeof AnyResizeHandle;
+
+    type Offsets = [widthOffset: number, heightOffset: number];
+
+    /** @internal */
+    type _Handlers = NullishProps<{
+      canDrag: () => boolean | null | void;
+    }>;
+
+    interface Handlers extends _Handlers {}
+
+    /** @internal */
+    type _UpdateDimensionsOptions = NullishProps<{
+      /**
+       * Constrain the aspect ratio
+       * @defaultValue `null`
+       * @remarks If truthy, will enforce the passed ratio, landscape if `width >= height`, portrait otherwise
+       */
+      aspectRatio: number;
+    }>;
+
+    interface UpdateDimensionsOptions extends _UpdateDimensionsOptions {}
+  }
+}
+
+declare abstract class AnyResizeHandle extends ResizeHandle {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/core/interaction/targets.d.mts

@@ -1,27 +1,21 @@
 export {};
 
-interface SetReplacementMembers<T> {
-  add(value: T): void;
-  delete(value: T): void;
-  clear(): void;
+// This class exists make it as sound as possible to override these parts of the class and make them
+// completely unrelated. It's done this way specifically to avoid situations with broken inheritance.
+declare class LenientSet<T> extends globalThis.Set<T> {
+  add(value: T): any;
+  delete(value: T): any;
 }
 
-type PatchedSet<T> = Omit<Set<T>, "add" | "delete" | "clear"> & SetReplacementMembers<T>;
-
-interface PatchedSetConstructor {
-  new <T = any>(values?: readonly T[] | null): PatchedSet<T>;
-  readonly prototype: PatchedSet<any>;
-}
-
-declare const Set: PatchedSetConstructor;
+declare const Set: typeof LenientSet;
 
 declare global {
   /**
    * A subclass of Set which manages the Token ids which the User has targeted.
    * @see User#targets
    */
-  class UserTargets extends Set<TokenDocument.ObjectInstance> {
-    constructor(user: UserTargets["user"]);
+  class UserTargets extends Set<Token.ConfiguredInstance> {
+    constructor(user: User.ConfiguredInstance);
 
     user: User.ConfiguredInstance;
 
@@ -33,13 +27,22 @@ declare global {
     /**
      * @remarks Returns void, but Set<T>.add returns boolean
      */
-    override add(token: TokenDocument.ObjectInstance): void;
+    override add(token: Token.ConfiguredInstance): void;
 
     override clear(): void;
 
     /**
      * @remarks Returns void, but Set<T>.delete returns boolean
      */
-    override delete(token: TokenDocument.ObjectInstance): void;
+    override delete(token: Token.ConfiguredInstance): void;
   }
+
+  namespace UserTargets {
+    interface Any extends AnyUserTargets {}
+    type AnyConstructor = typeof AnyUserTargets;
+  }
+}
+
+declare abstract class AnyUserTargets extends UserTargets {
+  constructor(arg0: never, ...args: never[]);
 }

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[]);
+}