@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1-beta.20250704.94554

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

@@ -1,256 +0,0 @@
-import type { Identity, 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`
-     */
-    static CACHE_TTL: number;
-
-    /**
-     * Initialize the basis transcoder for PIXI.Assets
-     */
-    static initializeBasisTranscoder(): TextureLoader.TranscodeWorkerLoadTranscoderReturn | Promise<void>;
-
-    /**
-     * Check if a source has a text file extension.
-     * @param src - The source.
-     * @returns If the source has a text extension or not.
-     */
-    static hasTextExtension(src: string): boolean;
-
-    /**
-     * Use the texture to create a cached mapping of pixel alpha and cache it.
-     * Cache the bounding box of non-transparent pixels for the un-rotated shape.
-     * @param texture    - The provided texture
-     * @param resolution - Resolution of the texture data output
-     *                     (default: `1`)
-     * @returns The texture data if the texture is valid, else undefined.
-     */
-    static getTextureAlphaData(texture: PIXI.Texture, resolution?: number): TextureLoader.TextureAlphaData | void;
-
-    /**
-     * Load all the textures which are required for a particular Scene
-     * @param scene   - The Scene to load
-     * @param options - Additional options that configure texture loading
-     *                  (default: `{}`)
-     */
-    static loadSceneTextures(
-      scene: Scene.Implementation,
-      options?: TextureLoader.LoadSceneTexturesOptions,
-    ): Promise<void>;
-
-    /**
-     * Load an Array of provided source URL paths
-     * @param sources - The source URLs to load
-     * @param options - Additional options which modify loading
-     *                  (default: `{}`)
-     * @returns A Promise which resolves once all textures are loaded
-     */
-    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): 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.
-     * @returns A Blob containing the loaded data
-     */
-    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, asset: PIXI.BaseTexture | PIXI.Spritesheet): void;
-
-    /**
-     * Retrieve a texture or a sprite sheet from the assets cache
-     * @param src - The source URL
-     */
-    getCache(src: string): PIXI.BaseTexture | PIXI.Spritesheet | null;
-
-    /**
-     * Expire and unload assets from the cache which have not been used for more than CACHE_TTL milliseconds.
-     */
-    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 | false;
-
-    /**
-     * @deprecated since v11, will be removed in v13
-     * @remarks TextureLoader#loadImageTexture is deprecated. Use TextureLoader#loadTexture instead.
-     */
-    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): 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<unknown, unknown>;
-  }
-
-  namespace TextureLoader {
-    interface Any extends AnyTextureLoader {}
-    interface AnyConstructor extends Identity<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;
-
-      /** The height of the (downscaled) texture. */
-      height: number;
-
-      /** The minimum x-coordinate with alpha \> 0. */
-      minX: number;
-
-      /** The minimum y-coordinate with alpha \> 0. */
-      minY: number;
-
-      /** The maximum x-coordinate with alpha \> 0 plus 1. */
-      maxX: number;
-
-      /** The maximum y-coordinate with alpha \> 0 plus 1. */
-      maxY: number;
-
-      /** The array containing the texture alpha values (0-255) with the dimensions (maxX-minX)×(maxY-minY). */
-      data: Uint8Array;
-    }
-
-    /** @internal */
-    type _LoadSceneTexturesOptions = InexactPartial<{
-      /**
-       * Destroy other expired textures
-       * @defaultValue `true`
-       */
-      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
-       */
-      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 | `foundry.utils.Semaphore`}, with only a parameter deafult.
-       */
-      maxConcurrent: number;
-    }>;
-
-    /** Options for {@link TextureLoader.loadSceneTextures | `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 | `SceneNavigation.displayProgressBar`}) does not error and simply blanks textContent.
-       */
-      message: string;
-
-      /**
-       * Expire other cached textures?
-       * @defaultValue `false`
-       */
-      expireCache: boolean;
-
-      /**
-       * Display loading progress bar?
-       * @defaultValue `true`
-       */
-      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 | `TextureLoader#load`} */
-    interface LoadOptions extends _LoadOptions {}
-
-    /** @internal */
-    type _FetchResourceOptions = NullishProps<{
-      /**
-       * Append a cache-busting query parameter to the request.
-       * @defaultValue `false`
-       */
-      bustCache: boolean;
-    }>;
-
-    interface FetchResourceOptions extends _FetchResourceOptions {}
-  }
-
-  /**
-   * Test whether a file source exists by performing a HEAD request against it
-   * @param src - The source URL or path to test
-   * @returns Does the file exist at the provided url?
-   */
-  function srcExists(src: string): Promise<boolean>;
-
-  /**
-   * Get a single texture or sprite sheet from the cache.
-   * @param src - The texture path to load.
-   * @returns A texture, a sprite sheet or null if not found in cache.
-   */
-  function getTexture(src: string): LoadTexture.Return;
-
-  /**
-   * Load a single asset and return a Promise which resolves once the asset is ready to use
-   * @param src      - The requested asset source
-   * @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?: 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;
-    }>;
-    interface Options extends _Options {}
-  }
-}
-
-declare abstract class AnyTextureLoader extends TextureLoader {
-  constructor(...args: never);
-}

package/src/foundry/client/pixi/core/shapes/index.d.mts

@@ -1,5 +0,0 @@
-import "./limited-angle-polygon.d.mts";
-import "./polygon-mesher.d.mts";
-import "./precise-text.d.mts";
-import "./ray.d.mts";
-import "./source-polygon.d.mts";

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

@@ -1,144 +0,0 @@
-import type { Identity, InexactPartial } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A special class of Polygon which implements a limited angle of emission for a Point Source.
-   * 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, config: LimitedAnglePolygon.ConstructorOptions);
-
-    /**
-     * The origin point of the Polygon
-     */
-    origin: Canvas.Point;
-
-    /**
-     * The radius of the emitted cone.
-     */
-    radius: number;
-
-    /**
-     * The angle of the Polygon in degrees.
-     * @defaultValue `360`
-     */
-    angle: number;
-
-    /**
-     * The direction of rotation at the center of the emitted angle in degrees.
-     * @defaultValue `0`
-     */
-    rotation: number;
-
-    /**
-     * The density of rays which approximate the cone, defined as rays per PI.
-     * @defaultValue `PIXI.Circle.approximateVertexDensity(this.radius)`
-     */
-    density: number;
-
-    /**
-     * An optional "external radius" which is included in the polygon for the supplementary area outside the cone.
-     * @defaultValue `0`
-     */
-    externalRadius: number;
-
-    /**
-     * The angle of the left (counter-clockwise) edge of the emitted cone in radians.
-     * @defaultValue `Math.normalizeRadians(Math.toRadians(this.rotation + 90 - (this.angle / 2)))`
-     */
-    aMin: number;
-
-    /**
-     * The angle of the right (clockwise) edge of the emitted cone in radians.
-     * @defaultValue `this.aMin + Math.toRadians(this.angle)`
-     */
-    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.
-     * 1. If this shape uses an externalRadius, keep edges which collide with the bounding box of that circle.
-     * 2. Keep edges which are contained within or collide with one of the primary angle boundary rays.
-     * @param a - The first edge vertex
-     * @param b - The second edge vertex
-     * @returns Should the edge be included in the PointSourcePolygon computation?
-     * @remarks Foundry marked `@internal`
-     */
-    _includeEdge(a: Canvas.Point, b: Canvas.Point): boolean;
-
-    /**
-     * Test whether a vertex lies between two boundary rays.
-     * If the angle is greater than 180, test for points between rMax and rMin (inverse).
-     * Otherwise, keep vertices that are between the rays directly.
-     * @param point - The candidate point
-     * @param rMin  - The counter-clockwise bounding ray
-     * @param rMax  - The clockwise bounding ray
-     * @param angle - The angle being tested, in degrees
-     * @returns Is the vertex between the two rays?
-     */
-    static pointBetweenRays(
-      point: Canvas.Point,
-      rMin: ClockwiseSweepPolygon.Ray,
-      rMax: ClockwiseSweepPolygon.Ray,
-      angle: number,
-    ): boolean;
-  }
-
-  namespace LimitedAnglePolygon {
-    interface Any extends AnyLimitedAnglePolygon {}
-    interface AnyConstructor extends Identity<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;
-
-      /**
-       * 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;
-
-      /**
-       * The density of rays which approximate the cone, defined as rays per PI.
-       * @defaultValue `PIXI.Circle.approximateVertexDensity(this.radius)`
-       */
-      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 | 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(...args: never);
-}

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

@@ -1,138 +0,0 @@
-import type { Identity, IntentionalPartial } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A helper class used to construct triangulated polygon meshes
-   * Allow to add padding and a specific depth value.
-   */
-  class PolygonMesher {
-    /**
-     * @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: PIXI.Polygon.OrPointsFlat, options?: IntentionalPartial<PolygonMesher.Options>);
-
-    /** Default options values */
-    static _defaultOptions: PolygonMesher.Options;
-
-    /**
-     * Polygon mesh vertices
-     */
-    vertices: number[];
-
-    /**
-     * Polygon mesh indices
-     */
-    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: PIXI.Polygon.OrPointsFlat, dimension?: number): ClipperLib.Path;
-
-    /**
-     * Execute the triangulation to create indices
-     * @param geometry - A geometry to update
-     * @returns The resulting geometry
-     */
-    triangulate(geometry: PIXI.Geometry): PIXI.Geometry;
-  }
-
-  namespace PolygonMesher {
-    interface Any extends AnyPolygonMesher {}
-    interface AnyConstructor extends Identity<typeof AnyPolygonMesher> {}
-
-    /**
-     *  @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.
-     */
-    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(...args: never);
-}

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

@@ -1,45 +0,0 @@
-import type { Identity, InexactPartial, NullishProps } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * An extension of the default PIXI.Text object which forces double resolution.
-   * At default resolution Text often looks blurry or fuzzy.
-   */
-  class PreciseText extends PIXI.Text {
-    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 }?: PreciseText.GetTextStyleOptions): PIXI.TextStyle;
-  }
-
-  namespace PreciseText {
-    interface Any extends AnyPreciseText {}
-    interface AnyConstructor extends Identity<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(...args: never);
-}