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

package/src/foundry/client/pixi/core/containers/quadtree.d.mts

@@ -1,258 +0,0 @@
-import type { Brand, Identity, InexactPartial, NullishProps } from "fvtt-types/utils";
-
-declare global {
-  /** @deprecated {@link Quadtree.Object | `Quadtree.Object`} */
-  type QuadtreeObject<T> = Quadtree.Object<T>;
-
-  /**
-   * A Quadtree implementation that supports collision detection for rectangles.
-   */
-  class Quadtree<T> {
-    /**
-     * @param bounds  - The outer bounds of the region
-     * @param options - Additional options which configure the Quadtree
-     * @remarks `bounds` is NullishProps because `PIXI.Rectangle`'s constructor casts `null`/`undefined` to `0`.
-     * A `width` or `height` of zero is likely undesirable, however.
-     */
-    constructor(bounds: NullishProps<Canvas.Rectangle>, options?: Quadtree.Options<T>);
-
-    /**
-     * The bounding rectangle of the region
-     */
-    bounds: PIXI.Rectangle;
-
-    /**
-     * The maximum number of objects allowed within this node before it must split
-     * @defaultValue `20`
-     */
-    maxObjects: number;
-
-    /**
-     * The maximum number of levels that the base quadtree is allowed
-     * @defaultValue `4`
-     */
-    maxDepth: number;
-
-    /**
-     * The depth of this node within the root Quadtree
-     * @defaultValue `0`
-     */
-    depth: number;
-
-    /**
-     * The objects contained at this level of the tree
-     * @defaultValue `[]`
-     */
-    objects: Quadtree.Object<T>[];
-
-    /**
-     * Children of this node
-     * @defaultValue `[]`
-     */
-    nodes: Quadtree<T>[];
-
-    /**
-     * The root Quadtree
-     */
-    root: Quadtree<T>;
-
-    /**
-     * A constant that enumerates the index order of the quadtree nodes from top-left to bottom-right.
-     */
-    static INDICES: Quadtree.Indices;
-
-    /**
-     * Return an array of all the objects in the Quadtree (recursive)
-     */
-    get all(): Quadtree.Object<T>[];
-
-    /**
-     * Split this node into 4 sub-nodes.
-     * @returns The split Quadtree
-     */
-    split(): this;
-
-    /**
-     * Clear the quadtree of all existing contents
-     * @returns The cleared Quadtree
-     */
-    clear(): this;
-
-    /**
-     * Add a rectangle object to the tree
-     * @param obj - The object being inserted
-     * @returns The Quadtree nodes the object was added to.
-     */
-    insert(obj: Quadtree.Object<T>): Quadtree<T>[];
-
-    /**
-     * Remove an object from the quadtree
-     * @param target - The quadtree target being removed
-     * @returns The Quadtree for method chaining
-     */
-    remove(target: T): this;
-
-    /**
-     * Remove an existing object from the quadtree and re-insert it with a new position
-     * @param obj - The object being inserted
-     * @returns The Quadtree nodes the object was added to
-     */
-    update(obj: Quadtree.Object<T>): Quadtree<T>[];
-
-    /**
-     * Get all the objects which could collide with the provided rectangle
-     * @param rect - The normalized target rectangle
-     * @param options - Options affecting the collision test.
-     * @returns The objects in the Quadtree which represent potential collisions
-     */
-    getObjects(rect: Canvas.Rectangle, options?: Quadtree.GetObjectsOptions<T>): Set<T>;
-
-    /**
-     * Obtain the leaf nodes to which a target rectangle belongs.
-     * This traverses the quadtree recursively obtaining the final nodes which have no children.
-     * @param rect - The target rectangle.x
-     * @returns The Quadtree nodes to which the target rectangle belongs
-     */
-    getLeafNodes(rect: Canvas.Rectangle): Quadtree<T>[];
-
-    /**
-     * Obtain the child nodes within the current node which a rectangle belongs to.
-     * Note that this function is not recursive, it only returns nodes at the current or child level.
-     * @param rect - The target rectangle.
-     * @returns The Quadtree nodes to which the target rectangle belongs
-     */
-    getChildNodes(rect: Canvas.Rectangle): Quadtree<T>[];
-
-    /**
-     * Identify all nodes which are adjacent to this one within the parent Quadtree.
-     */
-    getAdjacentNodes(): Quadtree<T>[];
-
-    /**
-     * Visualize the nodes and objects in the quadtree
-     */
-    visualize({ objects }?: Quadtree.VisualizeOptions): void;
-  }
-
-  namespace Quadtree {
-    interface Any extends AnyQuadtree {}
-    interface AnyConstructor extends Identity<typeof AnyQuadtree> {}
-
-    /** @internal */
-    type _OptionalSet<T> = NullishProps<{
-      /** @remarks Foundry never passes an object including `n`, which is handled by `obj.n = obj.n || new Set()` in `#insert()` */
-      n?: Set<Quadtree<T>>;
-    }>;
-
-    /** @internal */
-    interface _ObjectBase<T> {
-      r: Canvas.Rectangle;
-      t: T;
-    }
-
-    /** @deprecated {@link Quadtree.Object | `Quadtree.Object`} */
-    type QuadtreeObject<T> = Object<T>;
-
-    interface Object<T> extends _ObjectBase<T>, _OptionalSet<T> {}
-
-    type INDICES = Brand<number, "Quadtree.INDICES">;
-
-    interface Indices {
-      tl: 0 & Quadtree.INDICES;
-      tr: 1 & Quadtree.INDICES;
-      bl: 2 & Quadtree.INDICES;
-      br: 3 & Quadtree.INDICES;
-    }
-
-    /** @internal */
-    type _Options<T> = InexactPartial<{
-      /**
-       * The maximum number of objects per node
-       * @defaultValue `20`
-       * @remarks Can't be `null` because it only has a parameter default.
-       */
-      maxObjects: number;
-
-      /**
-       * The maximum number of levels within the root Quadtree
-       * @defaultValue `4`
-       * @remarks Can't be `null` because it only has a parameter default.
-       */
-      maxDepth: number;
-
-      /**
-       * The depth level of the sub-tree. For internal use
-       * @defaultValue `0`
-       * @remarks Can't be `null` because of an `=== 0` check in `#visualize()`, and it only has a parameter default
-       * Foundry marked `@internal`
-       */
-      _depth: number;
-
-      /**
-       * The root of the quadtree. For internal use
-       * Foundry marked `@internal`
-       */
-      _root: Quadtree<T> | null;
-    }>;
-
-    /**
-     * Additional options which configure the Quadtree
-     */
-    interface Options<T> extends _Options<T> {}
-
-    /** @internal */
-    type _GetObjectsOptions<T> = NullishProps<{
-      /**
-       * Function to further refine objects to return
-       * after a potential collision is found. Parameters are the object and rect, and the
-       * function should return true if the object should be added to the result set.
-       */
-      collisionTest: (o: Quadtree.Object<T>, rect: Canvas.Rectangle) => boolean;
-
-      /**
-       * The existing result set, for internal use.
-       * @defaultValue `new Set<T>()`
-       * @remarks Foundry marked `@internal`
-       */
-      _s: Set<T>;
-    }>;
-
-    interface GetObjectsOptions<T> extends _GetObjectsOptions<T> {}
-
-    /** @internal */
-    type _VisualizeOptions = NullishProps<{
-      /**
-       * Visualize the rectangular bounds of objects in the Quadtree.
-       * @defaultValue `false`
-       */
-      objects: boolean;
-    }>;
-
-    interface VisualizeOptions extends _VisualizeOptions {}
-  }
-  /**
-   * A subclass of Quadtree specifically intended for classifying the location of objects on the game canvas.
-   * @remarks Foundry never uses `Quadtree` directly, only this class, and only ever fills it with `PrimaryCanvasObject`s or `PlaceableObject`s
-   */
-  class CanvasQuadtree<T extends CanvasQuadtree.CanvasQuadtreeObject> extends Quadtree<T> {
-    constructor(options?: Quadtree.Options<T>);
-
-    /** @remarks A getter for `canvas.dimensions.rect` */
-    readonly bounds: PIXI.Rectangle;
-  }
-
-  namespace CanvasQuadtree {
-    interface Any extends AnyCanvasQuadtree {}
-    interface AnyConstructor extends Identity<typeof AnyCanvasQuadtree> {}
-
-    type CanvasQuadtreeObject = PrimaryCanvasObjectMixin.AnyMixed | PlaceableObject.Any;
-  }
-}
-
-declare abstract class AnyQuadtree extends Quadtree<unknown> {
-  constructor(...args: never);
-}
-
-declare abstract class AnyCanvasQuadtree extends CanvasQuadtree<CanvasQuadtree.CanvasQuadtreeObject> {
-  constructor(...args: never);
-}

package/src/foundry/client/pixi/core/containers/sprite-mesh.d.mts

@@ -1,369 +0,0 @@
-import type { Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * An extension of PIXI.Mesh which emulate a PIXI.Sprite with a specific shader.
-   */
-  class SpriteMesh extends PIXI.Container {
-    /**
-     * @param texture   - Texture bound to this sprite mesh.
-     *                    (default: `PIXI.Texture.EMPTY`)
-     * @param shaderCls - Shader class used by this sprite mesh.
-     *                    (default: `BaseSamplerShader`)
-     */
-    constructor(texture?: PIXI.Texture | null, shaderClass?: BaseSamplerShader.AnyConstructor);
-
-    /** @defaultValue `true` */
-    override isSprite: boolean;
-
-    /**
-     * Snapshot of some parameters of this display object to render in batched mode.
-     */
-    protected _batchData: SpriteMesh.BatchData;
-
-    /**
-     * The indices of the geometry.
-     */
-    indices: Uint16Array;
-
-    /**
-     * The width of the sprite (this is initially set by the texture).
-     * @defaultValue `0`
-     */
-    protected _width: number;
-
-    /**
-     * The height of the sprite (this is initially set by the texture).
-     * @defaultValue `0`
-     */
-    protected _height: number;
-
-    /**
-     * The texture that the sprite is using.
-     */
-    protected _texture: PIXI.Texture | null;
-
-    /**
-     * The texture ID
-     * @defaultValue `-1`
-     */
-    protected _textureID: number;
-
-    /**
-     * Cached tint value so we can tell when the tint is changed.
-     * @defaultValue `[1, 1, 1, 1]`
-     */
-    protected _cachedTint: Color.RGBAColorVector;
-
-    /**
-     * The texture trimmed ID.
-     * @defaultValue `-1`
-     */
-    protected _textureTrimmedID: number;
-
-    /**
-     * This is used to store the uvs data of the sprite, assigned at the same time
-     * as the vertexData in calculateVertices().
-     */
-    protected uvs: Float32Array;
-
-    /**
-     * The anchor point defines the normalized coordinates
-     * in the texture that map to the position of this
-     * sprite.
-     *
-     * By default, this is `(0,0)` (or `texture.defaultAnchor`
-     * if you have modified that), which means the position
-     * `(x,y)` of this `Sprite` will be the top-left corner.
-     *
-     * Note: Updating `texture.defaultAnchor` after
-     * constructing a `Sprite` does _not_ update its anchor.
-     *
-     * {@link https://docs.cocos2d-x.org/cocos2d-x/en/sprites/manipulation.html}
-     */
-    protected _anchor: PIXI.ObservablePoint;
-
-    /**
-     * This is used to store the vertex data of the sprite (basically a quad).
-     */
-    protected vertexData: Float32Array;
-
-    /**
-     * This is used to calculate the bounds of the object IF it is a trimmed sprite.
-     * @defaultValue `null`
-     */
-    protected vertexTrimmedData: Float32Array | null;
-
-    /**
-     * The transform ID.
-     * @defaultValue `-1`
-     */
-    private _transformID: number;
-
-    /**
-     * The transform ID.
-     * @defaultValue `-1`
-     */
-    private _transformTrimmedID: number;
-
-    /**
-     * The tint applied to the sprite. This is a hex value. A value of 0xFFFFFF will remove any tint effect.
-     * @defaultValue `new PIXI.Color(0xFFFFFF)`
-     */
-    protected _tintColor: PIXI.Color;
-
-    /**
-     * The tint applied to the sprite. This is a RGB value. A value of 0xFFFFFF will remove any tint effect.
-     * @defaultValue `0xFFFFFF`
-     */
-    protected _tintRGB: number;
-
-    /**
-     * An instance of a texture uvs used for padded SpriteMesh.
-     * Instanced only when padding becomes non-zero.
-     * @defaultValue `null`
-     */
-    protected _textureUvs: PIXI.TextureUvs | null;
-
-    /**
-     * Used to track a tint or alpha change to execute a recomputation of _cachedTint.
-     * @defaultValue `true`
-     */
-    protected _tintAlphaDirty: boolean;
-
-    /**
-     * The shader bound to this mesh.
-     */
-    get shader(): BaseSamplerShader;
-
-    /**
-     * The shader bound to this mesh.
-     */
-    protected _shader: BaseSamplerShader;
-
-    /**
-     * The x padding in pixels (must be a non-negative value.)
-     */
-    get paddingX(): number;
-
-    set paddingX(value);
-
-    /**
-     * They y padding in pixels (must be a non-negative value.)
-     */
-    get paddingY(): number;
-
-    set paddingY(value);
-
-    /**
-     * The maximum x/y padding in pixels (must be a non-negative value.)
-     */
-    get padding(): number;
-
-    /** @throws If `value < 0` */
-    set padding(value);
-
-    /**
-     * @defaultValue `0`
-     */
-    protected _paddingX: number;
-
-    /**
-     * @defaultValue `0`
-     */
-    protected _paddingY: number;
-
-    /**
-     * The blend mode applied to the SpriteMesh.
-     * @defaultValue `PIXI.BLEND_MODES.NORMAL`
-     */
-    set blendMode(value: PIXI.BLEND_MODES);
-
-    get blendMode();
-
-    /**
-     * If true PixiJS will Math.round() x/y values when rendering, stopping pixel interpolation.
-     * Advantages can include sharper image quality (like text) and faster rendering on canvas.
-     * The main disadvantage is movement of objects may appear less smooth.
-     * To set the global default, change PIXI.settings.ROUND_PIXELS
-     * @defaultValue `PIXI.settings.ROUND_PIXELS`
-     */
-    set roundPixels(value: boolean);
-
-    get roundPixels();
-
-    /**
-     * Used to force an alpha mode on this sprite mesh.
-     * If this property is non null, this value will replace the texture alphaMode when computing color channels.
-     * Affects how tint, worldAlpha and alpha are computed each others.
-     */
-    get alphaMode(): PIXI.ALPHA_MODES;
-
-    set alphaMode(mode);
-
-    /**
-     * Returns the SpriteMesh associated batch plugin. By default the returned plugin is that of the associated shader.
-     * If a plugin is forced, it will returns the forced plugin.
-     * @defaultValue `this._shader.pluginName`
-     */
-    get pluginName(): string;
-
-    set pluginName(name);
-
-    override get width(): number;
-
-    override set width(width);
-
-    /**
-     * The texture that the sprite is using
-     */
-    get texture(): PIXI.Texture | null;
-
-    set texture(texture);
-
-    /**
-     * The anchor sets the origin point of the sprite. The default value is taken from the {@link PIXI.Texture | `PIXI.Texture`}
-     * and passed to the constructor.
-     *
-     * The default is `(0,0)`, this means the sprite's origin is the top left.
-     *
-     * Setting the anchor to `(0.5,0.5)` means the sprite's origin is centered.
-     *
-     * Setting the anchor to `(1,1)` would mean the sprite's origin point will be the bottom right corner.
-     *
-     * If you pass only single parameter, it will set both x and y to the same value as shown in the example below.
-     * @privateRemarks Technically should be `ObservablePoint<this>` but this breaks `PrimarySpriteMesh`
-     */
-    get anchor(): PIXI.ObservablePoint<SpriteMesh.Any>;
-
-    set anchor(anchor);
-
-    /**
-     * The tint applied to the sprite. This is a hex value.
-     *
-     * A value of 0xFFFFFF will remove any tint effect.
-     * @defaultValue `0xFFFFFF`
-     */
-    get tint(): number;
-
-    set tint(tint);
-
-    /**
-     * The HTML source element for this SpriteMesh texture.
-     * @privateRemarks This could possibly be `PIXI.ImageSource | null`, but the below is Foundry's typing, which I think is accurate in practice
-     */
-    get sourceElement(): HTMLImageElement | HTMLVideoElement | null;
-
-    /**
-     * Is this SpriteMesh rendering a video texture?
-     */
-    get isVideo(): boolean;
-
-    /**
-     * When the texture is updated, this event will fire to update the scale and frame.
-     */
-    protected _onTextureUpdate(): void;
-
-    /**
-     * Called when the anchor position updates.
-     */
-    protected _onAnchorUpdate(): void;
-
-    /**
-     * Update uvs and push vertices and uv buffers on GPU if necessary.
-     */
-    updateUvs(): void;
-
-    /**
-     * Initialize shader based on the shader class type.
-     * @param shaderClass - The shader class
-     */
-    setShaderClass(shaderClass: BaseSamplerShader.AnyConstructor): void;
-
-    override updateTransform(): void;
-
-    /**
-     * Calculates the worldTransform * vertices, store it in vertexData
-     */
-    calculateVertices(): void;
-
-    /**
-     * Calculates worldTransform * vertices for a non texture with a trim. store it in vertexTrimmedData.
-     *
-     * This is used to ensure that the true width and height of a trimmed texture is respected.
-     */
-    calculateTrimmedVertices(): void;
-
-    override _render(renderer: PIXI.Renderer): void;
-
-    /**
-     * Update the batch data object.
-     */
-    protected _updateBatchData(): void;
-
-    override _calculateBounds(): void;
-
-    override getLocalBounds(rect: PIXI.Rectangle): PIXI.Rectangle;
-
-    /** @privateRemarks Foundry still marks this `@override` from when this class used to extend `PIXI.Mesh` */
-    containsPoint(point: PIXI.IPointData): boolean;
-
-    override destroy(options?: PIXI.IDestroyOptions | boolean): void;
-
-    /**
-     * Create a SpriteMesh from another source.
-     * You can specify texture options and a specific shader class derived from BaseSamplerShader.
-     * @param source         - Source to create texture from.
-     * @param textureOptions - See {@link PIXI.BaseTexture | `PIXI.BaseTexture`}'s constructor for options.
-     * @param shaderClass    - The shader class to use. BaseSamplerShader by default.
-     */
-    static from(
-      source: PIXI.Texture | HTMLImageElement | HTMLVideoElement | string,
-      textureOptions?: PIXI.IBaseTextureOptions,
-      shaderClass?: BaseSamplerShader.AnyConstructor,
-    ): SpriteMesh;
-  }
-
-  namespace SpriteMesh {
-    interface Any extends AnySpriteMesh {}
-    interface AnyConstructor extends Identity<typeof AnySpriteMesh> {}
-
-    /** Snapshot of some parameters of this display object to render in batched mode. */
-    interface BatchData {
-      _tintRGB: number | undefined;
-      _texture: PIXI.Texture | undefined | null;
-
-      /**
-       * @defaultValue `this.#geometry.indexBuffer.data`
-       * @remarks Set during construction
-       */
-      indices: number[];
-
-      /**
-       * @defaultValue `this.#geometry.buffers[1].data`
-       * @remarks Set during construction
-       */
-      uvs: number[];
-
-      blendMode: PIXI.BLEND_MODES | undefined;
-
-      /**
-       * @defaultValue `this.#geometry.buffers[0].data`
-       * @remarks Set during construction
-       */
-      vertexData: number[];
-
-      worldAlpha: number | undefined;
-
-      /**
-       * @defaultValue `this`
-       * @remarks Set during construction
-       */
-      object: SpriteMesh;
-    }
-  }
-}
-
-declare abstract class AnySpriteMesh extends SpriteMesh {
-  constructor(...args: never);
-}

package/src/foundry/client/pixi/core/containers/unbound-container.d.mts

@@ -1,39 +0,0 @@
-import type { Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * UnboundContainers behave like PIXI.Containers except that they are not bound to their parent's transforms.
-   * However, they normally propagate their own transformations to their children.
-   */
-  class UnboundContainer extends PIXI.Container {
-    transform: UnboundTransform;
-  }
-
-  namespace UnboundContainer {
-    interface Any extends AnyUnboundContainer {}
-    interface AnyConstructor extends Identity<typeof AnyUnboundContainer> {}
-  }
-
-  /**
-   * A custom Transform class which is not bound to the parent worldTransform.
-   * localTransform are working as usual.
-   */
-  class UnboundTransform extends PIXI.Transform {
-    static override IDENTITY: UnboundTransform;
-
-    override updateTransform(parentTransform: PIXI.Transform): void;
-  }
-
-  namespace UnboundTransform {
-    interface Any extends AnyUnboundTransform {}
-    interface AnyConstructor extends Identity<typeof AnyUnboundTransform> {}
-  }
-}
-
-declare abstract class AnyUnboundContainer extends UnboundContainer {
-  constructor(...args: never);
-}
-
-declare abstract class AnyUnboundTransform extends UnboundTransform {
-  constructor(...args: never);
-}

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

@@ -1,4 +0,0 @@
-import "./containers/index.d.mts";
-import "./interaction/index.d.mts";
-import "./loader.d.mts";
-import "./shapes/index.d.mts";