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

package/src/foundry/client/pixi/core/interaction/render-flags.d.mts

@@ -1,135 +0,0 @@
-import type { AnyConstructor, FixedInstanceType, InexactPartial, Mixin } from "fvtt-types/utils";
-import type { LogCompatibilityWarningOptions } from "../../../../common/utils/logging.d.mts";
-
-declare class RenderFlagObject {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
-  constructor(...args: any[]);
-
-  /**
-   * Configure the render flags used for this class.
-   * @defaultValue `{}`
-   */
-  static RENDER_FLAGS: Record<string, RenderFlag.Any>;
-
-  /**
-   * The ticker priority when RenderFlags of this class are handled.
-   * Valid values are OBJECTS or PERCEPTION.
-   * @defaultValue "OBJECTS"
-   */
-  static RENDER_FLAG_PRIORITY: "OBJECTS" | "PERCEPTION";
-
-  /**
-   * Status flags which are applied at render-time to update the PlaceableObject.
-   * If an object defines RenderFlags, it should at least include flags for "redraw" and "refresh".
-   */
-  renderFlags: RenderFlags;
-
-  /**
-   * Apply any current render flags, clearing the renderFlags set.
-   * Subclasses should override this method to define behavior.
-   */
-  applyRenderFlags(): void;
-}
-
-/**
- * @privateRemarks Values are marked as optional here based on use, foundry docs incomplete
- * @internal
- */
-type _RenderFlags<Flags> = InexactPartial<{
-  /** Activating this flag also sets these flags to true */
-  propagate: Array<keyof Flags>;
-
-  /** Activating this flag resets these flags to false */
-  reset: Array<keyof Flags>;
-
-  /**
-   * Is this flag deprecated? The deprecation options are passed to
-   * logCompatibilityWarning. The deprectation message is auto-generated
-   * unless message is passed with the options.
-   * By default the message is logged only once.
-   */
-  deprecated: {
-    message: string;
-  } & LogCompatibilityWarningOptions;
-
-  /**
-   * @remarks Possibly meant to be a sub-property of deprecated,
-   * the runtime check in `RenderFlags##set` looks for this as a top level property
-   */
-  alias: boolean;
-}>;
-
-declare global {
-  // @ts-expect-error - RenderFlag is built around willfully violating subclassing rules.
-  // The primary issue at hand is that each value can refer to the keys, thus making it technically
-  // unsound to apply a subclass to its superclass.
-  interface RenderFlag<out Flags> extends _RenderFlags<Flags> {}
-
-  namespace RenderFlag {
-    type Any = RenderFlag<any>;
-  }
-
-  /**
-   * A data structure for tracking a set of boolean status flags.
-   * This is a restricted set which can only accept flag values which are pre-defined.
-   */
-  class RenderFlags extends Set<string> {
-    /**
-     * @param flags  - An object which defines the flags which are supported for tracking
-     * @param config - Optional configuration
-     */
-    constructor(
-      flags: Record<string, RenderFlag<Record<string, boolean>>>,
-      config?: {
-        /** The object which owns this RenderFlags instance */
-        object?: RenderFlagObject;
-
-        /**
-         * The update priority when these render flags are applied.
-         * Valid options are OBJECTS or PERCEPTION.
-         * @defaultValue `PIXI.UPDATE_PRIORITY.OBJECTS`
-         */
-        priority?: PIXI.UPDATE_PRIORITY;
-      },
-    );
-
-    readonly flags: Record<string, RenderFlag<Record<string, boolean>>>;
-
-    readonly object: RenderFlagObject;
-
-    readonly priority: "OBJECT" | "PERCEPTION";
-
-    /**
-     * @returns The flags which were previously set that have been cleared.
-     */
-    clear(): Record<string, boolean>;
-
-    /**
-     * Allow for handling one single flag at a time.
-     * This function returns whether the flag needs to be handled and removes it from the pending set.
-     */
-    handle(flag: string): boolean;
-
-    /**
-     * Activate certain flags, also toggling propagation and reset behaviors
-     */
-    set(changes: Record<string, boolean>): void;
-  }
-
-  /**
-   * Add RenderFlags functionality to some other object.
-   * This mixin standardizes the interface for such functionality.
-   * @param Base - The base class being mixed. Normally a PIXI.DisplayObject
-   * @returns The mixed class definition
-   */
-  function RenderFlagsMixin<BaseClass extends RenderFlagsMixin.BaseClass>(
-    Base: BaseClass,
-  ): Mixin<typeof RenderFlagObject, BaseClass>;
-
-  namespace RenderFlagsMixin {
-    type AnyMixedConstructor = ReturnType<typeof RenderFlagsMixin<BaseClass>>;
-    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
-
-    type BaseClass = AnyConstructor;
-  }
-}

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

@@ -1,82 +0,0 @@
-import type { NullishProps } from "fvtt-types/utils";
-
-declare global {
-  class ResizeHandle extends PIXI.Graphics {
-    /**
-     * @param handlers - (default: `{}`)
-     */
-    constructor(offset: ResizeHandle.Offsets, handlers?: ResizeHandle.Handlers);
-
-    offset: ResizeHandle.Offsets;
-
-    handlers: ResizeHandle.Handlers;
-
-    /**
-     * Track whether the handle is being actively used for a drag workflow
-     * @defaultValue `false`
-     */
-    active: boolean;
-
-    refresh(bounds: Canvas.Rectangle): void;
-
-    /**
-     * @param aspectRatio - (default: `null`)
-     */
-    updateDimensions(
-      current: Canvas.Rectangle,
-      origin: Canvas.Rectangle,
-      destination: Canvas.Rectangle,
-      options?: ResizeHandle.UpdateDimensionsOptions,
-    ): Canvas.Rectangle;
-
-    activateListeners(): void;
-
-    /**
-     * Handle mouse-over event on a control handle
-     * @param event - The mouseover event
-     */
-    protected _onHoverIn(event: PIXI.FederatedEvent): void;
-
-    /**
-     * Handle mouse-out event on a control handle
-     * @param event - The mouseout event
-     */
-    protected _onHoverOut(event: PIXI.FederatedEvent): void;
-
-    /**
-     * When we start a drag event - create a preview copy of the Tile for re-positioning
-     * @param event - The mousedown event
-     */
-    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,48 +0,0 @@
-export {};
-
-// 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;
-}
-
-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<Token.ConfiguredInstance> {
-    constructor(user: User.ConfiguredInstance);
-
-    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: Token.ConfiguredInstance): void;
-
-    override clear(): void;
-
-    /**
-     * @remarks Returns void, but Set<T>.delete returns boolean
-     */
-    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,256 +0,0 @@
-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`
-     */
-    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.ConfiguredInstance,
-      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 {}
-    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;
-
-      /** 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}, with only a parameter deafult.
-       */
-      maxConcurrent: number;
-    }>;
-
-    /** 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;
-
-      /**
-       * 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} */
-    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(arg0: never, ...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,139 +0,0 @@
-import type { InexactPartial } from "../../../../../utils/index.d.mts";
-
-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: PolygonRay, rMax: PolygonRay, angle: number): boolean;
-  }
-
-  namespace LimitedAnglePolygon {
-    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;
-
-      /**
-       * 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(arg0: never, ...args: never[]);
-}