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

package/src/foundry/client/pixi/core/containers/cached-container.d.ts

@@ -1,64 +0,0 @@
-/**
- * A special type of PIXI.Container which draws its contents to a cached RenderTexture.
- * This is accomplished by overriding the Container#render method to draw to our own special RenderTexture.
- */
-declare class CachedContainer extends PIXI.Container {
-  constructor();
-
-  /**
-   * The RenderTexture that is the render destination for the contents of this Container
-   */
-  readonly renderTexture: PIXI.RenderTexture;
-
-  protected _onResize: () => void;
-
-  /**
-   * An object which stores a reference to the normal renderer target and source frame.
-   * We track this so we can restore them after rendering our cached texture.
-   */
-  protected _backup: {
-    renderTexture: PIXI.RenderTexture | undefined;
-    sourceFrame: PIXI.Rectangle;
-  };
-
-  /**
-   * An RGBA array used to define the clear color of the RenderTexture
-   * @defaultValue `[0, 0, 0, 1]`
-   */
-  clearColor: [r: number, g: number, b: number, a: number];
-
-  /**
-   * Should our Container also be displayed on screen, in addition to being drawn to the cached RenderTexture?
-   * @defaultValue `false`
-   */
-  displayed: boolean;
-
-  /**
-   * A bound Sprite which uses this container's render texture
-   */
-  get sprite(): PIXI.Sprite;
-
-  /** @internal */
-  protected _sprite: PIXI.Sprite | undefined;
-
-  destroy(options?: Parameters<PIXI.Container['destroy']>[0]): ReturnType<PIXI.Container['destroy']>;
-
-  render(renderer: Parameters<PIXI.Container['render']>[0]): void;
-
-  /**
-   * Bind our cached RenderTexture to the Renderer, replacing the original target.
-   * @param renderer - The active canvas renderer
-   */
-  protected _bind(renderer: PIXI.Renderer): void;
-
-  /**
-   * Remove our cached RenderTexture from the Renderer, re-binding the original target.
-   * @param renderer - The active canvas renderer
-   */
-  protected _unbind(renderer: PIXI.Renderer): void;
-
-  /**
-   * Resize the cached RenderTexture when the dimensions or resolution of the Renderer have changed.
-   */
-  protected _resize(renderer: PIXI.Renderer): void;
-}

package/src/foundry/client/pixi/core/containers/index.d.ts

@@ -1,3 +0,0 @@
-import './cached-container';
-import './quadtree';
-import './sampler-mesh';

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

@@ -1,166 +0,0 @@
-declare interface QuadTreeObject<T> {
-  r: Rectangle;
-  t: T;
-  n: Set<Quadtree<T>>;
-}
-
-/**
- * A Quadtree implementation that supports collision detection for rectangles.
- */
-declare class Quadtree<T> {
-  /**
-   * @param bounds  - The outer bounds of the region
-   * @param options - Additional options which configure the Quadtree
-   */
-  constructor(bounds: Rectangle, options?: Quadtree.Options<T>);
-
-  /**
-   * The bounding rectangle of the region
-   */
-  bounds: 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: QuadTreeObject<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: {
-    tl: 0;
-    tr: 1;
-    bl: 2;
-    br: 3;
-  };
-
-  /**
-   * Return an array of all the objects in the Quadtree (recursive)
-   */
-  get all(): QuadTreeObject<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: QuadTreeObject<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;
-
-  /**
-   * Get all the objects which could collide with the provided rectangle
-   * @param rect - The normalized target rectangle
-   * @param _s   - The existing result set, for internal use.
-   *               (default: `new Set<T>()`)
-   * @returns The objects in the Quadtree which represent potential collisions
-   */
-  getObjects(rect: NormalizedRectangle, _s?: Set<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: 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: 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
-   * @param objects - Visualize the rectangular bounds of objects in the Quadtree. Default is false.
-   *                  (default: `false`)
-   */
-  visualize({ objects }?: { objects?: boolean }): void;
-}
-
-declare namespace Quadtree {
-  /**
-   * Additional options which configure the Quadtree
-   */
-  interface Options<T> {
-    /**
-     * The maximum number of objects per node
-     * @defaultValue `20`
-     */
-    maxObjects?: number;
-
-    /**
-     * The maximum number of levels within the root Quadtree
-     * @defaultValue `4`
-     */
-    maxDepth?: number;
-
-    /**
-     * The depth level of the sub-tree. For internal use
-     * @defaultValue `0`
-     * @internal
-     */
-    _depth?: number;
-
-    /**
-     * The root of the quadtree. For internal use
-     * @internal
-     */
-    _root?: Quadtree<T>;
-  }
-}

package/src/foundry/client/pixi/core/containers/sampler-mesh.d.ts

@@ -1,22 +0,0 @@
-/**
- * A Mesh subclass used to render a texture with faster performance than a PIXI.Sprite.
- */
-declare class SamplerMesh extends PIXI.Mesh {
-  /**
-   * The basic quad geometry used for the Mesh
-   * @defaultValue
-   * ```javascript
-   * new PIXI.Geometry()
-   *   .addAttribute('aVertexPosition', [0, 0, 1, 0, 1, 1, 0, 1], 2)
-   *   .addAttribute('aUvs', [0, 0, 1, 0, 1, 1, 0, 1], 2)
-   *   .addIndex([0, 1, 2, 0, 2, 3])
-   * ```
-   */
-  static QUAD: PIXI.Geometry;
-
-  /**
-   * Create a SamplerMesh using a provided RenderTexture
-   * @param texture - The texture to render using a Mesh
-   */
-  static create(texture: PIXI.RenderTexture): SamplerMesh;
-}

package/src/foundry/client/pixi/core/culling.d.ts

@@ -1,37 +0,0 @@
-/**
- * A tool for culling the renderable state of objects which are outside the current viewport.
- */
-declare class ScreenCulling {
-  constructor();
-
-  /**
-   * Toggle the renderable state of objects based on the current viewport rectangle
-   */
-  cull(rect: Rectangle): void;
-
-  /**
-   * Test whether rectangular bounds intersect
-   * @param rect   - The target rectangle (the screen)
-   * @param bounds - The reference rectangle (the object)
-   * @returns Do they intersect?
-   */
-  intersects(rect: Rectangle, bounds: Rectangle): boolean;
-}
-
-/**
- * An experimental approach to culling using the quadtree mapping rather than the screen rectangle.
- * @internal
- */
-declare class QuadtreeCulling {
-  constructor();
-
-  cull(screen: Rectangle): void;
-
-  protected _getRect(screen: Rectangle): NormalizedRectangle;
-}
-
-/**
- * Benchmark the performance of different culling methods
- * @internal
- */
-declare function benchmarkCulling(n?: number): Promise<void>;

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

@@ -1,5 +0,0 @@
-import './containers';
-import './culling';
-import './interaction';
-import './loader';
-import './shapes';

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

@@ -1,148 +0,0 @@
-interface CanvasAnimationData {
-  /** The animation function being executed each frame */
-  fn: (dt: number) => void;
-
-  /** The object context within which animation occurs */
-  context: PIXI.DisplayObject;
-
-  /** 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;
-}
-
-/**
- * A helper class providing utility methods for PIXI Canvas animation
- */
-declare 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 a linear 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. Structure of the Array is shown in the example
-   * @param options    - Additional options which customize the animation
-   *                     (default: `{}`)
-   * @returns A Promise which resolves once the linear animation has concluded
-   *
-   * @example
-   * ```typescript
-   * let animation = [
-   *   {
-   *     parent: token,
-   *     attribute: x,
-   *     to: 1000
-   *   },
-   *   {
-   *     parent: token,
-   *     attribute: y,
-   *     to: 2000
-   *   }
-   * ];
-   * CanvasAnimation.animateLinear(attributes, {duration:500, ontick: console.log("ticking")});
-   * ```
-   */
-  static animateLinear(
-    attributes: CanvasAnimation.Attribute[],
-    options?: InexactPartial<LinearAnimationOptions>
-  ): Promise<boolean>;
-
-  /**
-   * 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;
-
-  /**
-   * Asynchronously animate a transition function and resolve a Promise once the animation has completed
-   * @param fn         - A suitable transition function. See PIXI.Ticker for details
-   * @param context    - The Canvas container providing scope for the transition
-   * @param name       -  Provide a unique animation name which may be referenced later
-   * @param attributes - The attributes being animated by the function
-   * @param duration   - The duration in milliseconds over which the animation should occur
-   * @param ontick     - A function which defines additional behaviors to apply every animation frame
-   * @returns A Promise which resolves once the animation has completed
-   */
-  protected static _animatePromise(
-    fn: TransitionFunction,
-    context: PIXI.Container,
-    name: string,
-    attributes: CanvasAnimation.Attribute[],
-    duration: number,
-    ontick: TickFunction | undefined
-  ): Promise<boolean>;
-
-  /**
-   * Generic ticker function to implement the animation.
-   * This animation wrapper executes once per frame for the duration of the animation event.
-   * Once the animated attributes have converged to their targets, it resolves the original Promise.
-   * The user-provided ontick function runs each frame update to apply additional behaviors.
-   */
-  protected static _animateFrame(
-    deltaTime: number,
-    resolve: CanvasAnimationData['resolve'],
-    reject: (reason?: any) => void,
-    attributes: CanvasAnimation.Attribute[],
-    duration: number,
-    ontick: TickFunction | undefined
-  ): void;
-}
-
-declare namespace CanvasAnimation {
-  interface Attribute {
-    attribute: string;
-    d?: number;
-    delta?: number;
-    done?: number;
-    parent: any;
-    remaining?: number;
-    to: number;
-  }
-}
-
-interface LinearAnimationOptions {
-  /**
-   * An animation context to use which defines scope
-   */
-  context: PIXI.DisplayObject;
-
-  /**
-   * Provide a unique animation name which may be referenced later
-   */
-  name: string;
-
-  /**
-   * The duration in milliseconds over which the animation should occur
-   * @defaultValue `1000`
-   */
-  duration: number;
-
-  /**
-   * A function which defines additional behaviors to apply every animation frame
-   */
-  ontick: TickFunction;
-}
-
-type TickFunction = (dt: number, attributes: CanvasAnimation.Attribute[]) => void;
-type TransitionFunction = (
-  dt: number,
-  resolve: CanvasAnimationData['resolve'],
-  reject: (reason?: any) => void,
-  attributes: CanvasAnimation.Attribute[],
-  duration: number,
-  ontick?: TickFunction
-) => void;

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

@@ -1,58 +0,0 @@
-/**
- * A generic helper for drawing a standard Control Icon
- */
-declare 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 `true`
-   */
-  interactive: boolean;
-
-  /**
-   * @defaultValue `false`
-   */
-  interactiveChildren: boolean;
-
-  hitArea: PIXI.Rectangle;
-
-  bg: PIXI.Graphics;
-
-  icon: PIXI.Sprite;
-
-  border: PIXI.Graphics;
-
-  draw(): Promise<this>;
-
-  protected _onHoverIn(event: PIXI.InteractionEvent): void;
-
-  protected _onHoverOut(event: PIXI.InteractionEvent): void;
-}

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

@@ -1,5 +0,0 @@
-import './canvas-animation';
-import './control-icon';
-import './mouse-handler';
-import './resize-handle';
-import './targets';