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

package/src/foundry/client/pixi/layer.d.ts

@@ -1,105 +0,0 @@
-/**
- * An abstract pattern for primary layers of the game canvas to implement
- * @typeParam Options - The type of the options in this layer.
- */
-declare abstract class CanvasLayer<Options extends CanvasLayerOptions = CanvasLayerOptions> extends PIXI.Container {
-  constructor();
-
-  /**
-   * Options for this layer instance.
-   * @defaultValue `this.constructor.layerOptions`
-   */
-  options: Options;
-
-  /**
-   * @defaultValue `false`
-   */
-  interactive: boolean;
-
-  /**
-   * @defaultValue `false`
-   */
-  interactiveChildren: boolean;
-
-  /**
-   * Track whether the canvas layer is currently active for interaction
-   * @defaultValue `false`
-   * @remarks This is public because it's checked from outside in foundry and modules sometimes need to do the same.
-   */
-  _active: boolean;
-
-  /**
-   * Customize behaviors of this CanvasLayer by modifying some behaviors at a class level.
-   */
-  static get layerOptions(): CanvasLayerOptions;
-
-  /**
-   * Return a reference to the active instance of this canvas layer
-   */
-  static get instance(): CanvasLayer | undefined;
-
-  /**
-   * The canonical name of the CanvasLayer
-   * @remarks Foundry defines this as a getter, but since CanvasLayer extends PIXI.Container, it has to be a property.
-   */
-  readonly name: string;
-
-  /**
-   * Draw the canvas layer, rendering its internal components and returning a Promise
-   * The Promise resolves to the drawn layer once its contents are successfully rendered.
-   * @remarks It returns Promise<this> but is overridden by a subclass in this way.
-   */
-  draw(): Promise<this | undefined> | this;
-
-  /**
-   * Deconstruct data used in the current layer in preparation to re-draw the canvas
-   * @remarks ControlsLayer returns void. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6939
-   */
-  tearDown(): Promise<this | void>;
-
-  /**
-   * Activate the CanvasLayer, deactivating other layers and marking this layer's children as interactive.
-   * @returns The layer instance, now activated
-   */
-  activate(): this;
-
-  /**
-   * Deactivate the CanvasLayer, removing interactivity from its children.
-   * @returns The layer instance, now inactive
-   * @remarks It returns Promise<this> but is overridden by a subclass returning void.
-   */
-  deactivate(): this | void;
-
-  /**
-   * Get the zIndex that should be used for ordering this layer vertically relative to others in the same Container.
-   */
-  getZIndex(): number;
-}
-
-/**
- * Options which configure the behavior of a Canvas Layer.
- */
-declare interface CanvasLayerOptions {
-  /**
-   * The layer name by which the instance is referenced within the Canvas
-   */
-  name: string;
-
-  /**
-   * The zIndex sorting of this layer relative to other layers
-   */
-  zIndex: number;
-
-  /**
-   * Should this layer be sorted to the top when it is active?
-   */
-  sortActiveTop: boolean;
-}
-
-declare namespace CanvasLayer {
-  /**
-   * Options which configure the behavior of a Canvas Layer.
-   * @remarks This type exists for consistency
-   */
-  type LayerOptions = CanvasLayerOptions;
-}

package/src/foundry/client/pixi/layers/controls/cursor.d.ts

@@ -1,27 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
-
-declare global {
-  /**
-   * A single Mouse Cursor
-   */
-  class Cursor extends PIXI.Container {
-    constructor(user: InstanceType<ConfiguredDocumentClass<typeof User>>);
-
-    /**
-     * @defaultValue `{x: 0, y: 0}`
-     */
-    target: { x: number; y: number };
-
-    /**
-     * Draw the user's cursor as a small dot with their user name attached as text
-     */
-    draw(user: InstanceType<ConfiguredDocumentClass<typeof User>>): void;
-
-    /**
-     * Move an existing cursor to a new position smoothly along the animation loop
-     */
-    protected _animate(): void;
-
-    override destroy(options?: Parameters<PIXI.Container['destroy']>[0]): void;
-  }
-}

package/src/foundry/client/pixi/layers/controls/door.d.ts

@@ -1,67 +0,0 @@
-import type { ConfiguredDocumentClassForName, ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
-
-declare global {
-  /**
-   * An icon representing a Door Control
-   */
-  class DoorControl extends PIXI.Container {
-    constructor(wall: InstanceType<ConfiguredObjectClassForName<'Wall'>>);
-
-    wall: InstanceType<ConfiguredObjectClassForName<'Wall'>>;
-
-    /**
-     * Draw the DoorControl icon, displaying it's icon texture and border
-     */
-    draw(): Promise<this>;
-
-    icon?: PIXI.Sprite;
-
-    bg?: PIXI.Graphics;
-
-    border?: PIXI.Graphics;
-
-    /**
-     * Get the icon texture to use for the Door Control icon based on the door state
-     */
-    protected _getTexture(): ReturnType<typeof getTexture>;
-
-    reposition(): void;
-
-    /**
-     * Determine whether the DoorControl is visible to the calling user's perspective.
-     * The control is always visible if the user is a GM and no Tokens are controlled.
-     * @see {@link SightLayer#testVisibility}
-     */
-    get isVisible(): boolean;
-
-    /**
-     * Handle mouse over events on a door control icon.
-     * @param event - The originating interaction event
-     */
-    protected _onMouseOver(event: PIXI.InteractionEvent): false | void;
-
-    /**
-     * Handle mouse out events on a door control icon.
-     * @param event - The originating interaction event
-     */
-    protected _onMouseOut(event: PIXI.InteractionEvent): false | void;
-
-    /**
-     * Handle left mouse down events on a door control icon.
-     * This should only toggle between the OPEN and CLOSED states.
-     * @param event - The originating interaction event
-     */
-    protected _onMouseDown(
-      event: PIXI.InteractionEvent
-    ): false | void | Promise<InstanceType<ConfiguredDocumentClassForName<'Wall'>> | undefined>;
-
-    /**
-     * Handle right mouse down events on the door control icon
-     * This should toggle whether the door is LOCKED or CLOSED
-     * @param event - The originating interaction event
-     */
-    protected _onRightDown(
-      event: PIXI.InteractionEvent
-    ): void | Promise<InstanceType<ConfiguredDocumentClassForName<'Wall'>> | undefined>;
-  }
-}

package/src/foundry/client/pixi/layers/controls/hud.d.ts

@@ -1,117 +0,0 @@
-/**
- * An extension of PIXI.Transform.
- * This uses a different DisplayObject than the current parent as the reference for the worldTransform.
- */
-declare class SynchronizedTransform extends PIXI.Transform {
-  constructor(transform: PIXI.Transform);
-
-  /**
-   * A list of attributes from the transform reference which should be synchronized
-   * @defaultValue
-   * ```javascript
-   * [
-   *   "localTransform", "position", "scale", "pivot", "skew", "_rotation",
-   *   "_cx", "_sx", "_cy", "_sy", "_localID", "_currentLocalID"
-   * ];
-   * ```
-   */
-  static synchronizedAttributes: string[];
-
-  /**
-   * A Transform instance which defines the reference point for the worldTransform
-   */
-  get reference(): PIXI.Transform;
-
-  set reference(value: PIXI.Transform);
-
-  /** @internal */
-  protected _reference: PIXI.Transform;
-
-  /** @internal */
-  protected _syncLocalID: number;
-
-  override updateTransform(parentTransform: PIXI.Transform): void;
-
-  override updateLocalTransform(): void;
-}
-
-/**
- * An extension of PIXI.Container used as the interface frame for a PlaceableObject on the ControlsLayer
- *
- * @see {@link PlaceableObject}
- * @see {@link ControlsLayer}
- */
-declare class ObjectHUD extends PIXI.Container {
-  constructor(object: PIXI.DisplayObject);
-
-  /**
-   * The object that this HUD container is linked to
-   */
-  object: PIXI.DisplayObject;
-
-  /**
-   * Use the linked object's transform matrix to easily synchronize position
-   */
-  transform: PIXI.Transform;
-
-  // @ts-expect-error this is a property in `PIXI.Container` but foundry overrides it as an accessor.
-  override get visible(): boolean;
-  override set visible(value: boolean);
-
-  // @ts-expect-error this is a property in `PIXI.Container` but foundry overrides it as an accessor.
-  override get renderable(): boolean;
-  override set renderable(value: boolean);
-
-  /**
-   * Display scrolling status text originating from this ObjectHUD container.
-   * @param content - The text content to display
-   * @param options - (default: `{}`)
-   * @returns The created PreciseText object which is scrolling
-   */
-  createScrollingText(
-    content: string,
-    options?: ObjectHUD.CreateScrollingTextOptions | undefined
-  ): Promise<PreciseText | null>;
-
-  /**
-   * Orchestrate the animation of the scrolling text in this HUD
-   * @param text     - The PrecisText instance to animate
-   * @param duration - A desired duration of animation
-   * @param dx       - A horizontal distance to animate the text
-   *                   (default: `0`)
-   * @param dy       - A vertical distance to animate the text
-   *                   (default: `0`)
-   * @internal
-   */
-  protected _animateScrollText(text: PreciseText, duration: number, dx?: number, dy?: number): Promise<void>;
-}
-
-type TextStyleProperties = Exclude<ConstructorParameters<typeof PIXI.TextStyle>[0], undefined>;
-
-declare namespace ObjectHUD {
-  interface CreateScrollingTextOptions extends TextStyleProperties {
-    /**
-     * The original anchor point where the text first appears
-     * @defaultValue `CONST.TEXT_ANCHOR_POINTS.CENTER`
-     */
-    anchor?: foundry.CONST.TEXT_ANCHOR_POINTS | undefined;
-
-    /**
-     * The direction in which the text scrolls
-     * @defaultValue `CONST.TEXT_ANCHOR_POINTS.TOP`
-     */
-    direction?: foundry.CONST.TEXT_ANCHOR_POINTS | undefined;
-
-    /**
-     * The duration of the scrolling effect in milliseconds
-     * @defaultValue `2000`
-     */
-    duration?: number | undefined;
-
-    /**
-     * An amount of randomization between 0 and 1 to apply to the initial Position
-     * @defaultValue `0`
-     */
-    jitter?: number | undefined;
-  }
-}

package/src/foundry/client/pixi/layers/controls/index.d.ts

@@ -1,4 +0,0 @@
-import './cursor';
-import './door';
-import './hud';
-import './ruler';

package/src/foundry/client/pixi/layers/controls/ruler.d.ts

@@ -1,207 +0,0 @@
-import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
-
-declare global {
-  interface RulerData {
-    /** The ruler measurement state. */
-    _state: Ruler['_state'];
-
-    /** A unique name for the ruler containing the owning user's ID. */
-    name: string;
-
-    /** The current point the ruler has been extended to. */
-    destination: PIXI.Point;
-
-    /** The class name of this ruler instance. */
-    class: string;
-
-    /** Additional waypoints along the ruler's length, including the starting point. */
-    waypoints: PIXI.Point[];
-  }
-
-  /**
-   * The Ruler - used to measure distances and trigger movements
-   */
-  class Ruler extends PIXI.Container {
-    /**
-     * @param user  - The User for whom to construct the Ruler instance
-     * @param color - (default: `null`)
-     */
-    constructor(
-      user?: InstanceType<ConfiguredDocumentClass<typeof User>> | null,
-      { color }?: { color?: number | null }
-    );
-
-    /**
-     * Record the User which this Ruler references
-     * @defaultValue `game.user`
-     */
-    user: InstanceType<ConfiguredDocumentClass<typeof User>>;
-
-    /**
-     * The ruler name - used to differentiate between players
-     * @defaultValue `Ruler.${user.id}`
-     */
-    name: string;
-
-    /**
-     * The ruler color - by default the color of the active user
-     * @defaultValue `foundry.utils.colorStringToHex(this.user.data.color) || 0x42F4E2`
-     */
-    color: number;
-
-    /**
-     * This Array tracks individual waypoints along the ruler's measured path.
-     * The first waypoint is always the origin of the route.
-     * @defaultValue `[]`
-     */
-    waypoints: PIXI.Point[];
-
-    /**
-     * The current destination point at the end of the measurement
-     * @defaultValue `null`
-     */
-    destination: PIXI.Point | null;
-
-    /**
-     * The Ruler element is a Graphics instance which draws the line and points of the measured path
-     */
-    ruler: PIXI.Graphics;
-
-    /**
-     * The Labels element is a Container of Text elements which label the measured path
-     */
-    labels: PIXI.Container;
-
-    /**
-     * Track the current measurement state
-     * @defaultValue `Ruler.STATES.INACTIVE`
-     */
-    protected _state: ValueOf<typeof Ruler['STATES']>;
-
-    /**
-     * An enumeration of the possible Ruler measurement states.
-     */
-    static STATES: {
-      INACTIVE: 0;
-      STARTING: 1;
-      MEASURING: 2;
-      MOVING: 3;
-    };
-
-    /**
-     * Is the Ruler being actively used to measure distance?
-     */
-    get active(): boolean;
-
-    /**
-     * Measure the distance between two points and render the ruler UI to illustrate it
-     * @param destination - The destination point to which to measure
-     * @param gridSpaces  - Restrict measurement only to grid spaces
-     *                      (default: `true`)
-     */
-    measure(destination: Point, { gridSpaces }?: { gridSpaces?: boolean }): Ruler.Segment[];
-
-    /**
-     * Get the text label for a segment of the measured path
-     */
-    protected _getSegmentLabel(segmentDistance: number, totalDistance: number, isTotal: boolean): string;
-
-    /**
-     * Highlight the measurement required to complete the move in the minimum number of discrete spaces
-     */
-    protected _highlightMeasurement(ray: Ray): void;
-
-    /**
-     * Determine whether a SPACE keypress event entails a legal token movement along a measured ruler
-     *
-     * @returns An indicator for whether a token was successfully moved or not. If True the event should be
-     *          prevented from propagating further, if False it should move on to other handlers.
-     */
-    moveToken(): Promise<false | undefined>;
-
-    /**
-     * Acquire a Token, if any, which is eligible to perform a movement based on the starting point of the Ruler
-     */
-    protected _getMovementToken(): InstanceType<ConfiguredObjectClassForName<'Token'>> | null | undefined;
-
-    /**
-     * A helper method to return an Array of Ray objects constructed from the waypoints of the measurement
-     * @param waypoints   - An Array of waypoint `{x, y}` Objects
-     * @param destination - An optional destination point to append to the existing waypoints
-     * @returns An Array of Ray objects which represent the segemnts of the waypoint path
-     */
-    protected _getRaysFromWaypoints(waypoints: PIXI.Point[], destination?: PIXI.Point): Ray[];
-
-    /**
-     * Clear display of the current Ruler
-     */
-    clear(): void;
-
-    /**
-     * Handle the beginning of a new Ruler measurement workflow
-     * @see Canvas._onDragLeftStart
-     */
-    protected _onDragStart(event: PIXI.InteractionEvent): void;
-
-    /**
-     * Handle left-click events on the Canvas during Ruler measurement.
-     * @see Canvas._onClickLeft
-     */
-    protected _onClickLeft(event: PIXI.InteractionEvent): void;
-
-    /**
-     * Handle right-click events on the Canvas during Ruler measurement.
-     * @see Canvas._onClickRight
-     */
-    protected _onClickRight(event: PIXI.InteractionEvent): boolean | void;
-
-    /**
-     * Continue a Ruler measurement workflow for left-mouse movements on the Canvas.
-     * @see Canvas._onDragLeftMove
-     */
-    protected _onMouseMove(event: PIXI.InteractionEvent): void;
-
-    /**
-     * Conclude a Ruler measurement workflow by releasing the left-mouse button.
-     * @see Canvas._onDragLeftDrop
-     */
-    protected _onMouseUp(event: PIXI.InteractionEvent): void;
-
-    /**
-     * Handle the addition of a new waypoint in the Ruler measurement path
-     * @remarks point is intentionally typed as Point because it is called with event.data.origin and only uses x and y
-     */
-    protected _addWaypoint(point: Point): void;
-
-    /**
-     * Handle the removal of a waypoint in the Ruler measurement path
-     * @param point - The current cursor position to snap to
-     * @param snap  - Snap exactly to grid spaces?
-     *                (default: `true`)
-     */
-    protected _removeWaypoint(point: PIXI.Point, { snap }?: { snap?: boolean }): void;
-
-    /**
-     * Handle the conclusion of a Ruler measurement workflow
-     */
-    protected _endMeasurement(): void;
-
-    toJSON(): RulerData;
-
-    /**
-     * Update a Ruler instance using data provided through the cursor activity socket
-     * @param data - Ruler data with which to update the display
-     */
-    update(data: ReturnType<Ruler['toJSON']>): void;
-  }
-
-  namespace Ruler {
-    interface Segment {
-      distance: number;
-      label: PIXI.DisplayObject;
-      last: boolean;
-      ray: Ray;
-      text: string;
-    }
-  }
-}

package/src/foundry/client/pixi/layers/controls.d.ts

@@ -1,144 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-
-declare global {
-  /**
-   * A CanvasLayer for displaying UI controls which are overlayed on top of other layers.
-   *
-   * We track three types of events:
-   * 1) Cursor movement
-   * 2) Ruler measurement
-   * 3) Map pings
-   */
-  class ControlsLayer extends CanvasLayer<ControlsLayer.LayerOptions> {
-    constructor();
-
-    /**
-     * A container of DoorControl instances
-     * @defaultValue `this.addChild(new PIXI.Container())`
-     */
-    doors: PIXI.Container;
-
-    /**
-     * A container of HUD interface elements
-     * @defaultValue `this.addChild(new PIXI.Container())`
-     */
-    hud: PIXI.Container;
-
-    /**
-     * A container of cursor interaction elements.
-     * Contains cursors, rulers, interaction rectangles, and pings
-     * @defaultValue `this.addChild(new PIXI.Container())`
-     */
-    cursors: PIXI.Container;
-
-    /**
-     * Ruler tools, one per connected user
-     * @defaultValue `this.addChild(new PIXI.Container())`
-     */
-    rulers: PIXI.Container;
-
-    /**
-     * A graphics instance used for drawing debugging visualization
-     * @defaultValue `this.addChild(new PIXI.Graphics())`
-     */
-    debug: PIXI.Graphics;
-
-    /**
-     * Canvas selection rectangle
-     * @defaultValue `undefined`
-     */
-    select: PIXI.Graphics | undefined;
-
-    /**
-     * A mapping of user IDs to Cursor instances for quick access
-     * @defaultValue `{}`
-     */
-    protected _cursors: Record<string, Cursor>;
-
-    /**
-     * A convenience mapping of user IDs to Ruler instances for quick access
-     * @internal
-     * @defaultValue `{}`
-     */
-    protected _rulers: Record<string, Ruler>;
-
-    /**
-     * @defaultValue
-     * ```typescript
-     * foundry.utils.mergeObject(super.layerOptions, {
-     *   name: "controls",
-     *   zIndex: 1000
-     * })
-     * ```
-     */
-    static override get layerOptions(): ControlsLayer.LayerOptions;
-
-    /**
-     * A convenience accessor to the Ruler for the active game user
-     */
-    get ruler(): ReturnType<ControlsLayer['getRulerForUser']>;
-
-    /**
-     * Get the Ruler display for a specific User ID
-     */
-    getRulerForUser(userId: string): Ruler | null;
-
-    override draw(): Promise<this>;
-
-    /**
-     * @remarks This breaks polymorphism. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6939
-     */
-    override tearDown(): Promise<void>;
-
-    /**
-     * Draw the cursors container
-     */
-    drawCursors(): void;
-
-    /**
-     * Draw Ruler tools
-     */
-    drawRulers(): void;
-
-    /**
-     * Draw the select rectangle given an event originated within the base canvas layer
-     * @param coords - The rectangle coordinates of the form `{x, y, width, height}`
-     */
-    drawSelect({ x, y, width, height }: { x: number; y: number; width: number; height: number }): void;
-
-    override deactivate(): void;
-
-    /**
-     * Handle mousemove events on the game canvas to broadcast activity of the user's cursor position
-     */
-    protected _onMoveCursor(event: PIXI.InteractionEvent): void;
-
-    /**
-     * Create and draw the Cursor object for a given User
-     * @param user - The User document for whom to draw the cursor Container
-     */
-    drawCursor(user: InstanceType<ConfiguredDocumentClass<typeof User>>): Cursor;
-
-    /**
-     * Update the cursor when the user moves to a new position
-     * @param user     - The User for whom to update the cursor
-     * @param position - The new cursor position
-     */
-    updateCursor(user: InstanceType<ConfiguredDocumentClass<typeof User>>, position: Point | null): void;
-
-    /**
-     * Update display of an active Ruler object for a user given provided data
-     */
-    updateRuler(
-      user: InstanceType<ConfiguredDocumentClass<typeof User>>,
-      rulerData: Parameters<Ruler['update']>[0] | null
-    ): void;
-  }
-
-  namespace ControlsLayer {
-    interface LayerOptions extends CanvasLayer.LayerOptions {
-      name: 'controls';
-      zIndex: 1000;
-    }
-  }
-}