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

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

@@ -0,0 +1,326 @@
+export {};
+
+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, shaderCls?: typeof BaseSamplerShader);
+
+    override isSprite: boolean;
+
+    /**
+     * Snapshot of some parameters of this display object to render in batched mode.
+     */
+    protected _batchData: {
+      _tintRGB: number;
+      _texture: PIXI.Texture;
+      indices: number[];
+      uvs: number[];
+      blendMode: PIXI.BLEND_MODES;
+      vertexData: number[];
+      worldAlpha: number;
+    };
+
+    /**
+     * 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;
+
+    /**
+     * The texture ID
+     * @defaultValue `-1`
+     */
+    protected _textureID: number;
+
+    /**
+     * Cached tint value so we can tell when the tint is changed.
+     */
+    protected _cachedTint: [red: number, green: number, blue: number, alpha: number];
+
+    /**
+     * The texture trimmed ID.
+     * @defaultValue `-1`
+     */
+    _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.
+     */
+    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;
+
+    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.
+     */
+    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;
+
+    set texture(texture);
+
+    /**
+     * The anchor sets the origin point of the sprite. The default value is taken from the {@link PIXI.Texture|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.
+     */
+    get anchor(): PIXI.ObservablePoint;
+
+    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(): PIXI.ColorSource;
+
+    set tint(tint);
+
+    /**
+     * The HTML source element for this SpriteMesh texture.
+     */
+    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.
+     */
+    _onTextureUpdate(): void;
+
+    /**
+     * Called when the anchor position updates.
+     */
+    _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 - Shader class used. Must inherit from AbstractBaseShader.
+     */
+    setShaderClass(shaderClass: typeof AbstractBaseShader): 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;
+
+    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}'s constructor for options.
+     * @param shaderClass    - The shader class to use. BaseSamplerShader by default.
+     */
+    static from(
+      source: string | PIXI.Texture | HTMLCanvasElement | HTMLVideoElement,
+      textureOptions?: PIXI.IBaseTextureOptions,
+      shaderClass?: typeof AbstractBaseShader,
+    ): SpriteMesh;
+  }
+}

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

@@ -0,0 +1,21 @@
+import type { Transform } from "pixi.js";
+
+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;
+  }
+
+  /**
+   * 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: Transform): void;
+  }
+}

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

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

package/src/foundry/client/pixi/core/interaction/canvas-animation.d.mts

@@ -0,0 +1,160 @@
+export {};
+
+declare global {
+  interface CanvasAnimationAttribute {
+    /** The attribute name being animated */
+    attribute: string;
+
+    /** The object within which the attribute is stored */
+    parent: object;
+
+    /** The destination value of the attribute */
+    to: number;
+
+    /** An initial value of the attribute, otherwise parent[attribute] is used */
+    from?: number;
+
+    /** The computed delta between to and from */
+    delta?: number;
+
+    /** The amount of the total delta which has been animated */
+    done?: number;
+
+    /** Is this a color animation that applies to RGB channels */
+    color?: boolean;
+  }
+
+  interface CanvasAnimationOptions {
+    /** A DisplayObject which defines context to the PIXI.Ticker function */
+    context?: PIXI.DisplayObject;
+
+    /** A unique name which can be used to reference the in-progress animation */
+    name?: string;
+
+    /** A duration in milliseconds over which the animation should occur */
+    duration?: number;
+
+    /**
+     * A priority in PIXI.UPDATE_PRIORITY which defines when the animation
+     * should be evaluated related to others
+     */
+    priority?: number;
+
+    /**
+     * An easing function used to translate animation time or the string name
+     * of a static member of the CanvasAnimation class
+     */
+    easing?: ((pt: number) => number) | string;
+
+    /** A callback function which fires after every frame */
+    ontick?: (dt: number, animation: CanvasAnimationData) => void;
+  }
+
+  interface CanvasAnimationData {
+    /** The animation function being executed each frame */
+    fn: (dt: number) => void;
+
+    /** The current time of the animation, in milliseconds */
+    time: number;
+
+    /** The attributes being animated */
+    attributes: CanvasAnimationAttribute[];
+
+    /** A Promise which resolves once the animation is complete */
+    promise: Promise<boolean>;
+
+    /** The resolution function, allowing animation to be ended early */
+    resolve: (value: boolean) => void;
+
+    /** The rejection function, allowing animation to be ended early */
+    reject: (err: Error) => void;
+  }
+
+  /**
+   * A helper class providing utility methods for PIXI Canvas animation
+   */
+  class CanvasAnimation {
+    static get ticker(): PIXI.Ticker;
+
+    /**
+     * Track an object of active animations by name, context, and function
+     * This allows a currently playing animation to be referenced and terminated
+     */
+    static animations: Record<string, CanvasAnimationData>;
+
+    /**
+     * Apply an animation from the current value of some attribute to a new value
+     * Resolve a Promise once the animation has concluded and the attributes have reached their new target
+     *
+     * @param attributes - An array of attributes to animate
+     * @param options    - Additional options which customize the animation
+     *
+     * @returns A Promise which resolves to true once the animation has concluded
+     *          or false if the animation was prematurely terminated
+     *
+     * @example Animate Token Position
+     * ```javascript
+     * let animation = [
+     *   {
+     *     parent: token,
+     *     attribute: "x",
+     *     to: 1000
+     *   },
+     *   {
+     *     parent: token,
+     *     attribute: "y",
+     *     to: 2000
+     *   }
+     * ];
+     * CanvasAnimation.animate(attributes, {duration:500});
+     * ```
+     */
+    static animate(
+      attributes: CanvasAnimationAttribute[],
+      { context, name, duration, easing, ontick, priority }?: CanvasAnimationOptions,
+    ): Promise<boolean | void>;
+
+    /**
+     * Retrieve an animation currently in progress by its name
+     * @param name - The animation name to retrieve
+     * @returns The animation data, or undefined
+     */
+    static getAnimation(name: string): CanvasAnimationData | undefined;
+
+    /**
+     * If an animation using a certain name already exists, terminate it
+     * @param name - The animation name to terminate
+     */
+    static terminateAnimation(name: string): void;
+
+    /**
+     * Cosine based easing with smooth in-out.
+     * @param pt - The proportional animation timing on [0,1]
+     * @returns The eased animation progress on [0,1]
+     */
+    static easeInOutCosine(pt: number): number;
+
+    /**
+     * Shallow ease out.
+     * @param pt - The proportional animation timing on [0,1]
+     * @returns The eased animation progress on [0,1]
+     */
+    static easeOutCircle(pt: number): number;
+
+    /**
+     * Shallow ease in.
+     * @param pt - The proportional animation timing on [0,1]
+     * @returns The eased animation progress on [0,1]
+     */
+    static easeInCircle(pt: number): number;
+
+    /**
+     * @deprecated since v10, will be removed in v12
+     * @remarks "You are calling CanvasAnimation.animateLinear which is deprecated in favor of CanvasAnimation.animate"
+     */
+    static animateLinear(
+      attributes: CanvasAnimationAttribute[],
+      options: CanvasAnimationOptions,
+    ): Promise<boolean | void>;
+  }
+}

package/src/foundry/client/pixi/core/interaction/control-icon.d.mts

@@ -0,0 +1,80 @@
+export {};
+
+declare global {
+  /**
+   * A generic helper for drawing a standard Control Icon
+   */
+  class ControlIcon extends PIXI.Container {
+    /**
+     * @param size        - (default: `40`)
+     * @param borderColor - (default: `0xFF5500`)
+     * @param tint        - (default: `null`)
+     */
+    constructor({
+      texture,
+      size,
+      borderColor,
+      tint,
+    }: {
+      texture: string;
+      size?: number;
+      borderColor?: number;
+      tint?: number | null;
+    });
+
+    iconSrc: string;
+
+    size: number;
+
+    rect: [number, number, number, number];
+
+    borderColor: number;
+
+    /**
+     * The color of the icon tint, if any
+     */
+    tintColor: number | null;
+
+    /**
+     * @defaultValue `static`
+     */
+    override eventMode: "none" | "passive" | "auto" | "static" | "dynamic";
+
+    /**
+     * @defaultValue `false`
+     */
+    interactiveChildren: boolean;
+
+    hitArea: PIXI.Rectangle;
+
+    bg: PIXI.Graphics;
+
+    icon: PIXI.Sprite;
+
+    /**
+     * @defaultValue
+     * The `visible` property is true.
+     */
+    border: PIXI.Graphics;
+
+    /**
+     * Initial drawing of the ControlIcon
+     */
+    draw(): Promise<this>;
+
+    /**
+     * Incremental refresh for ControlIcon appearance.
+     */
+    refresh({
+      visible,
+      iconColor,
+      borderColor,
+      borderVisible,
+    }?: {
+      visible?: boolean;
+      iconColor?: number;
+      borderColor?: number;
+      borderVisible?: boolean;
+    }): this;
+  }
+}

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

@@ -0,0 +1,8 @@
+import "./canvas-animation.d.mts";
+import "./control-icon.d.mts";
+import "./mouse-handler.d.mts";
+import "./ping.d.mts";
+import "./pings/index.d.mts";
+import "./render-flags.d.mts";
+import "./resize-handle.d.mts";
+import "./targets.d.mts";