@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-beta

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

@@ -0,0 +1,45 @@
+export {};
+
+interface SetReplacementMembers<T> {
+  add(value: T): void;
+  delete(value: T): void;
+  clear(): void;
+}
+
+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 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"]);
+
+    user: User.ConfiguredInstance;
+
+    /**
+     * Return the Token IDs which are user targets
+     */
+    get ids(): string[];
+
+    /**
+     * @remarks Returns void, but Set<T>.add returns boolean
+     */
+    override add(token: TokenDocument.ObjectInstance): void;
+
+    override clear(): void;
+
+    /**
+     * @remarks Returns void, but Set<T>.delete returns boolean
+     */
+    override delete(token: TokenDocument.ObjectInstance): void;
+  }
+}

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

@@ -0,0 +1,206 @@
+export {};
+
+declare global {
+  /**
+   * A Loader class which helps with loading video and image textures
+   */
+  class TextureLoader {
+    /**
+     * The duration in milliseconds for which a texture will remain cached
+     * @defaultValue `1000 * 60 * 15`
+     */
+    static CACHE_TTL: number;
+
+    /**
+     * A mapping of url to cached texture buffer data
+     */
+    static textureBufferDataMap: Map<string, object>;
+
+    /**
+     * 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;
+
+    /**
+     * 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.ConfiguredInstance,
+      options?: Partial<TextureLoader.LoadSceneTextureOptions>,
+    ): 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?: Partial<TextureLoader.LoadOptions>): Promise<PIXI.BaseTexture | 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;
+
+    /**
+     * Use the Fetch API to retrieve a resource and return a Blob instance for it.
+     * @param options - Options to configure the loading behaviour.
+     *                  (default: `{}`)
+     * @internal
+     */
+    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;
+
+    /**
+     * 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;
+
+    /**
+     * 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(): 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;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks TextureLoader#loadImageTexture is deprecated. Use TextureLoader#loadTexture instead.
+     */
+    loadImageTexture(src: string): Promise<PIXI.BaseTexture>;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks TextureLoader#loadVideoTexture is deprecated. Use TextureLoader#loadTexture instead.
+     */
+    loadVideoTexture(src: string): Promise<PIXI.BaseTexture>;
+
+    /**
+     * A global reference to the singleton texture loader
+     */
+    static loader: TextureLoader;
+  }
+
+  namespace TextureLoader {
+    interface LoadSceneTextureOptions {
+      /**
+       * Destroy other expired textures
+       * @defaultValue `true`
+       */
+      expireCache?: boolean;
+
+      /**
+       * Additional sources to load during canvas initialize
+       * @defaultValue `[]`
+       */
+      additionalSource?: Array<boolean>;
+
+      /**
+       * The maximum number of textures that can be loaded concurrently
+       */
+      maxConcurrent?: number;
+    }
+
+    interface LoadOptions {
+      /**
+       * The status message to display in the load bar
+       */
+      message?: string | undefined;
+
+      /**
+       * Expire other cached textures?
+       * @defaultValue `true`
+       */
+      expireCache?: boolean;
+
+      /**
+       * The maximum number of textures that can be loaded concurrently
+       */
+      maxConcurrent?: number;
+    }
+
+    interface Progress {
+      message: string;
+      loaded: number;
+      failed: number;
+      total: number;
+      pct: number;
+    }
+  }
+
+  /**
+   * 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): PIXI.Texture | null;
+
+  /**
+   * 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?: {
+      /** A fallback texture URL to use if the requested source is unavailable */
+      fallback?: string;
+    },
+  ): Promise<PIXI.Texture | PIXI.Spritesheet | null>;
+}

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

@@ -0,0 +1,6 @@
+import "./limited-angle-polygon.d.mts";
+import "./polygon-helpers.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

@@ -0,0 +1,119 @@
+export {};
+
+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.
+   */
+  class LimitedAnglePolygon extends PIXI.Polygon {
+    constructor(
+      origin: Point,
+      { radius, angle, rotation, density, externalRadius }: LimitedAnglePolygon.ConstructorOptions,
+    );
+
+    /**
+     * The origin point of the Polygon
+     */
+    origin: 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;
+
+    /**
+     * 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?
+     * @internal
+     */
+    protected _includeEdge(a: Point, b: 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: Point, rMin: PolygonRay, rMax: PolygonRay, angle: number): boolean;
+  }
+
+  namespace LimitedAnglePolygon {
+    interface ConstructorOptions {
+      /**
+       * 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;
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+import type Document from "../../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * An internal data structure for polygon edges
+   * @internal
+   */
+  class PolygonEdge {
+    constructor(a: Point, b: Point, type: foundry.CONST.WALL_SENSE_TYPES, wall: Wall);
+
+    /**
+     * An internal flag used to record whether an Edge represents a canvas boundary.
+     */
+    protected _isBoundary: boolean;
+
+    /**
+     * Is this edge limited in type?
+     */
+    get isLimited(): boolean;
+
+    /**
+     * Construct a PolygonEdge instance from a Wall placeable object.
+     * @param wall - The Wall from which to construct an edge
+     * @param type - The type of polygon being constructed
+     */
+    static fromWall(
+      wall: Document.ConfiguredObjectClassForName<"Wall"> | WallDocument,
+      type: foundry.CONST.WALL_RESTRICTION_TYPES,
+    ): PolygonEdge;
+  }
+}

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

@@ -0,0 +1,110 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+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, ...
+     */
+    constructor(poly: number[] | PIXI.Polygon, options?: InexactPartial<PolygonMesherOptions>);
+
+    /** Contains options to apply during the meshing process */
+    options: PolygonMesherOptions;
+
+    /** Default options values */
+    static _defaultOptions: PolygonMesherOptions;
+
+    /**
+     * Polygon mesh vertices
+     */
+    vertices: number[];
+
+    /**
+     * Polygon mesh indices
+     */
+    indices: number[];
+
+    /**
+     * 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.
+     */
+    static getClipperPathFromPoints(poly: number[] | PIXI.Polygon, dimension?: number): number[] | undefined;
+
+    /**
+     * Execute the triangulation to create indices
+     * @param geometry - A geometry to update
+     * @returns The resulting geometry
+     */
+    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;
+
+    /**
+     * Constant multiplier to avoid floating point imprecision with ClipperLib
+     * @defaultValue `10e8`
+     */
+    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;
+  }
+}

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

@@ -0,0 +1,27 @@
+export {};
+
+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 {
+    /**
+     * @param options - Additional options merged with the default TextStyle
+     */
+    constructor(...args: ConstructorParameters<typeof PIXI.Text>);
+
+    /**
+     * 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;
+  }
+}