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

package/src/foundry/client/pixi/layers/placeables/tiles.d.mts

@@ -0,0 +1,116 @@
+import type BaseTile from "../../../../common/documents/tile.d.mts";
+
+declare global {
+  /**
+   * A PlaceablesLayer designed for rendering the visual Scene for a specific vertical cross-section.
+   */
+  class TilesLayer<
+    DrawOptions extends PlaceablesLayer.DrawOptions = PlaceablesLayer.DrawOptions,
+    TearDownOptions extends TilesLayer.TearDownOptions = TilesLayer.TearDownOptions,
+  > extends PlaceablesLayer<"Tile", DrawOptions, TearDownOptions> {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["tiles"];
+
+    static override documentName: "Tile";
+
+    override options: TilesLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```js
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *    name: "tiles",
+     *    zIndex: 300,
+     *    controllableObjects: true,
+     *    rotatableObjects: true,
+     * })
+     * ```
+     */
+    static override get layerOptions(): TilesLayer.LayerOptions;
+
+    override get hookName(): string;
+
+    override get hud(): TileHUD;
+
+    /**
+     * An array of Tile objects which are rendered within the objects container
+     */
+    get tiles(): Tile.ConfiguredInstance[];
+
+    override controllableObjects(): Generator<Tile.ConfiguredInstance>;
+
+    override getSnappedPoint(point: Canvas.Point): Canvas.Point;
+
+    protected override _tearDown(options?: TearDownOptions): Promise<void>;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftCancel(event: PointerEvent): void;
+
+    /**
+     * Handle drop events for Tile data on the Tiles Layer
+     * @param event - The concluding drag event
+     * @param data  - The extracted Tile data
+     */
+    protected _onDropData(
+      event: DragEvent,
+      data: BaseTile.ConstructorData,
+    ): Promise<TileDocument.ConfiguredInstance | false | void>;
+
+    /**
+     * Prepare the data object when a new Tile is dropped onto the canvas
+     * @param event - The concluding drag event
+     * @param data  - The extracted Tile data
+     * @returns The prepared data to create
+     */
+    _getDropData(event: DragEvent, data: BaseTile.ConstructorData): Promise<BaseTile.ConstructorData>;
+
+    /**
+     * Get an array of overhead Tile objects which are roofs
+     * @deprecated since v12 until v14
+     * @remarks "TilesLayer#roofs has been deprecated without replacement."
+     */
+    get roofs(): Tile.ConfiguredInstance[];
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "TilesLayer#textureDataMap has moved to TextureLoader.textureBufferDataMap"
+     */
+    get textureDataMap(): (typeof TextureLoader)["textureBufferDataMap"];
+
+    /**
+     * A convenience reference to the tile occlusion mask on the primary canvas group.
+     * @deprecated since v11 until v13
+     * @remarks "TilesLayer#depthMask is deprecated without replacement. Use canvas.masks.depth instead"
+     */
+    get depthMask(): CachedContainer;
+  }
+
+  namespace TilesLayer {
+    type AnyConstructor = typeof AnyTilesLayer;
+
+    interface TearDownOptions extends PlaceablesLayer.TearDownOptions {}
+
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Tile"> {
+      name: "tiles";
+      zIndex: 300;
+      controllableObjects: true;
+      rotatableObjects: true;
+    }
+
+    interface DropData extends Canvas.DropPosition {
+      type: "Tile";
+      uuid: string;
+    }
+  }
+}
+
+declare abstract class AnyTilesLayer extends TilesLayer {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/layers/placeables/tokens.d.mts

@@ -0,0 +1,193 @@
+import type { ArrayOverlaps } from "../../../../../types/helperTypes.d.mts";
+import type { NullishProps } from "../../../../../types/utils.d.mts";
+import type Document from "../../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The Tokens Container
+   */
+  class TokenLayer<
+    DrawOptions extends TokenLayer.DrawOptions = TokenLayer.DrawOptions,
+    TearDownOptions extends TokenLayer.TearDownOptions = TokenLayer.TearDownOptions,
+  > extends PlaceablesLayer<"Token", DrawOptions, TearDownOptions> {
+    /**
+     * The current index position in the tab cycle
+     * @defaultValue `null`
+     * @remarks Foundry marked \@private but accesses it from Canvas
+     */
+    _tabIndex: number | null;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["tokens"];
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: TokenLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```js
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *  name: "tokens",
+     *  controllableObjects: true,
+     *  rotatableObjects: true,
+     *  zIndex: 200
+     * })
+     * ```
+     */
+    static override get layerOptions(): TokenLayer.LayerOptions;
+
+    static override documentName: "Token";
+
+    /**
+     * The set of tokens that trigger occlusion (a union of {@link CONST.TOKEN_OCCLUSION_MODES}).
+     */
+    set occlusionMode(value: number);
+
+    get occlusionMode(): number;
+
+    override get hookName(): string;
+
+    /**
+     * Token objects on this layer utilize the TokenHUD
+     */
+    get hud(): TokenHUD;
+
+    /**
+     * An Array of tokens which belong to actors which are owned
+     */
+    get ownedTokens(): ReturnType<this["placeables"]["filter"]>;
+
+    override getSnappedPoint(point: Canvas.Point): Canvas.Point;
+
+    protected override _draw(options?: DrawOptions): Promise<void>;
+
+    protected override _tearDown(options?: TearDownOptions): Promise<void>;
+
+    protected override _activate(): void;
+
+    protected override _deactivate(): void;
+
+    override _pasteObject(
+      copy: Token.ConfiguredInstance,
+      offset: Canvas.Point,
+      options?: NullishProps<{ hidden: boolean; snap: boolean }>,
+    ): Document.ConfiguredSourceForName<"Token">;
+
+    protected override _getMovableObjects<const T>(
+      ids?: ArrayOverlaps<T, string>,
+      includeLocked?: boolean,
+    ): Token.ConfiguredInstance[];
+
+    /**
+     * Target all Token instances which fall within a coordinate rectangle.
+     * @param rectangle - The selection rectangle.
+     * @param options - Additional options to configure targeting behaviour.
+     */
+    targetObjects(rectangle: Canvas.Rectangle, options?: NullishProps<PlaceableObject.ControlOptions>): number;
+
+    /**
+     * Cycle the controlled token by rotating through the list of Owned Tokens that are available within the Scene
+     * Tokens are currently sorted in order of their TokenID
+     * @param forwards - Which direction to cycle. A truthy value cycles forward, while a false value cycles backwards.
+     * @param reset    - Restart the cycle order back at the beginning?
+     */
+    cycleTokens(forwards: boolean, reset: boolean): Token.ConfiguredInstance | null;
+
+    /**
+     * Get the tab cycle order for tokens by sorting observable tokens based on their distance from top-left.
+     */
+    protected _getCycleOrder(): Token.ConfiguredInstance[];
+
+    /**
+     * Immediately conclude the animation of any/all tokens
+     */
+    concludeAnimation(): void;
+
+    /**
+     * Animate targeting arrows on targeted tokens.
+     */
+    protected _animateTargets(): void;
+
+    /**
+     * Provide an array of Tokens which are eligible subjects for overhead tile occlusion.
+     * By default, only tokens which are currently controlled or owned by a player are included as subjects.
+     */
+    protected _getOccludableTokens(): Token.ConfiguredInstance[];
+
+    override storeHistory(
+      type: PlaceablesLayer.HistoryEventType,
+      data: Document.ConfiguredSourceForName<"Token">[],
+    ): void;
+
+    /**
+     * Handle dropping of Actor data onto the Scene canvas
+     */
+    protected _onDropActorData(
+      event: DragEvent,
+      data: TokenLayer.DropData,
+    ): Promise<ReturnType<Notifications["warn"]> | false | TokenDocument.ConfiguredInstance>;
+
+    //TODO: use configured ruler type once it exists
+    protected override _onClickLeft(event: PIXI.FederatedEvent): ReturnType<Ruler["_onClickLeft"]> | void; // ReturnType<CONFIG.Canvas["rulerClass"]["_onClickLeft"]>;
+
+    protected override _onMouseWheel(event: WheelEvent): ReturnType<this["rotateMany"]>;
+
+    /**
+     * @deprecated since v12 until v14
+     * @remarks "TokenLayer#toggleCombat is deprecated in favor of TokenDocument.implementation.createCombatants and TokenDocument.implementation.deleteCombatants"
+     */
+    override get gridPrecision(): 1;
+
+    /**
+     * Add or remove the set of currently controlled Tokens from the active combat encounter
+     * @param  state  - The desired combat state which determines if each Token is added (true) or removed (false)
+     *                  (default: `true`)
+     * @param  combat - A Combat encounter from which to add or remove the Token
+     *                  (default: `null`)
+     * @returns The Combatants added or removed
+     * @deprecated since v12 until v14
+     * @remarks "TokenLayer#toggleCombat is deprecated in favor of TokenDocument.implementation.createCombatants and TokenDocument.implementation.deleteCombatants"
+     */
+    toggleCombat(
+      state?: boolean,
+      combat?: Combat.ConfiguredInstance | null,
+      {
+        token,
+      }?: {
+        /**
+         * A specific Token which is the origin of the group toggle request
+         * @defaultValue `null`
+         */
+        token?: Token.ConfiguredInstance | null;
+      },
+    ): Promise<Combatant.ConfiguredInstance[]>;
+  }
+
+  namespace TokenLayer {
+    type AnyConstructor = typeof AnyTokenLayer;
+
+    interface DrawOptions extends PlaceablesLayer.DrawOptions {}
+
+    interface TearDownOptions extends PlaceablesLayer.TearDownOptions {}
+
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Token"> {
+      name: "tokens";
+      controllableObjects: true;
+      rotatableObjects: true;
+      zIndex: 200;
+    }
+
+    interface DropData extends Canvas.DropPosition {
+      type: "Actor";
+      uuid: string;
+    }
+  }
+}
+
+declare abstract class AnyTokenLayer extends TokenLayer {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/layers/placeables/walls.d.mts

@@ -0,0 +1,209 @@
+import type { ConstructorOf, NullishProps } from "../../../../../types/utils.d.mts";
+import type Document from "../../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The Walls canvas layer which provides a container for Wall objects within the rendered Scene.
+   */
+  class WallsLayer<
+    DrawOptions extends WallsLayer.DrawOptions = WallsLayer.DrawOptions,
+    TearDownOptions extends PlaceablesLayer.TearDownOptions = PlaceablesLayer.TearDownOptions,
+  > extends PlaceablesLayer<"Wall", DrawOptions, TearDownOptions> {
+    /**
+     * A graphics layer used to display chained Wall selection
+     * @defaultValue `null`
+     */
+    chain: PIXI.Graphics | null;
+
+    /**
+     * Track whether we are currently within a chained placement workflow
+     * @defaultValue `false`
+     */
+    protected _chain: boolean;
+
+    /**
+     * Track the most recently created or updated wall data for use with the clone tool
+     * @defaultValue `null`
+     * @remarks This is intentional `public` because it is accessed from Wall
+     */
+    _cloneType: ReturnType<foundry.documents.BaseWall["toJSON"]> | null;
+
+    /**
+     * Reference the last interacted wall endpoint for the purposes of chaining
+     * @defaultValue
+     * ```
+     * {
+     *   point: null,
+     * }
+     * ```
+     */
+    protected last: {
+      point: Canvas.PointArray | null;
+    };
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["walls"];
+
+    /**
+     * @defaultValue
+     * ```js
+     * mergeObject(super.layerOptions, {
+     *  name: "walls"
+     *  controllableObjects: true,
+     *  zIndex: 700
+     * })
+     * ```
+     */
+    static override get layerOptions(): WallsLayer.LayerOptions;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: WallsLayer.LayerOptions;
+
+    static override documentName: "Wall";
+
+    override get hookName(): string;
+
+    /**
+     * An Array of Wall instances in the current Scene which act as Doors.
+     */
+    get doors(): Wall.ConfiguredInstance[];
+
+    override getSnappedPoint(point: Canvas.Point): Canvas.Point;
+
+    override _draw(options?: DrawOptions): Promise<void>;
+
+    override _deactivate(): void;
+
+    /**
+     * Given a point and the coordinates of a wall, determine which endpoint is closer to the point
+     * @param point - The origin point of the new Wall placement
+     * @param wall  - The existing Wall object being chained to
+     * @returns The [x,y] coordinates of the starting endpoint
+     */
+    static getClosestEndpoint(point: Canvas.Point, wall: Wall.ConfiguredInstance): Canvas.PointArray;
+
+    override releaseAll(options?: PlaceableObject.ReleaseOptions): number;
+
+    override _pasteObject(
+      copy: Wall.ConfiguredInstance,
+      offset: Canvas.Point,
+      options?: NullishProps<{ hidden: boolean; snap: boolean }>,
+    ): Document.ConfiguredSourceForName<"Wall">;
+
+    /**
+     * Pan the canvas view when the cursor position gets close to the edge of the frame
+     * @param event - The originating mouse movement event
+     * @param x     - The x-coordinate
+     * @param y     - The y-coordinate
+     */
+    protected _panCanvasEdge(event: MouseEvent, x: number, y: number): void | ReturnType<Canvas["animatePan"]>;
+
+    /**
+     * Get the wall endpoint coordinates for a given point.
+     * @param  point - The candidate wall endpoint.
+     * @returns The wall endpoint coordinates.
+     */
+    protected _getWallEndpointCoordinates(
+      point: Canvas.Point,
+      options?: NullishProps<{
+        /**
+         * Snap to the grid?
+         * @defaultValue `true`
+         */
+        snap: boolean;
+      }>,
+    ): Canvas.PointArray;
+
+    /**
+     * The Scene Controls tools provide several different types of prototypical Walls to choose from
+     * This method helps to translate each tool into a default wall data configuration for that type
+     * @param tool - The active canvas tool
+     */
+    protected _getWallDataFromActiveTool(tool: string):
+      | {
+          light: foundry.CONST.WALL_SENSE_TYPES;
+          sight: foundry.CONST.WALL_SENSE_TYPES;
+          sound: foundry.CONST.WALL_SENSE_TYPES;
+          move: foundry.CONST.WALL_SENSE_TYPES;
+          door?: foundry.CONST.WALL_DOOR_TYPES;
+        }
+      | this["_cloneType"];
+
+    /**
+     * Identify the interior enclosed by the given walls.
+     * @param  walls - The walls that enclose the interior.
+     * @returns The polygons of the interior.
+     * @remarks Marked \@license MIT
+     */
+    identifyInteriorArea(walls: Wall.ConfiguredInstance[]): PIXI.Polygon[];
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): ReturnType<Wall.ConfiguredInstance["draw"]>;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftCancel(event: PointerEvent): void;
+
+    protected override _onClickRight(event: PIXI.FederatedEvent): void;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "WallsLayer#checkCollision is obsolete. Prefer calls to testCollision from CONFIG.Canvas.polygonBackends[type]"
+     */
+    checkCollision(ray: Ray, options: Parameters<(typeof PointSourcePolygon)["testCollision"]>[2]): boolean;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "The WallsLayer#highlightControlledSegments function is deprecated in favor of calling wall.renderFlags.set(\"refreshHighlight\") on individual Wall objects"
+     */
+    highlightControlledSegments(): void;
+
+    /**
+     * Perform initialization steps for the WallsLayer whenever the composition of walls in the Scene is changed.
+     * Cache unique wall endpoints and identify interior walls using overhead roof tiles.
+     * @deprecated since v12 until v14
+     * @remarks "WallsLayer#initialize is deprecated in favor of Canvas#edges#initialize"
+     */
+    initialize(): void;
+
+    /**
+     * Identify walls which are treated as "interior" because they are contained fully within a roof tile.
+     * @deprecated since v12 until v14
+     * @remarks "WallsLayer#identifyInteriorWalls has been deprecated. It has no effect anymore and there's no replacement."
+     */
+    identifyInteriorWalls(): void;
+
+    /**
+     * Initialization to identify all intersections between walls.
+     * These intersections are cached and used later when computing point source polygons.
+     * @deprecated since v12 until v14
+     * @remarks "WallsLayer#identifyWallIntersections is deprecated in favor of foundry.canvas.edges.Edge.identifyEdgeIntersections and has no effect."
+     */
+    identifyWallIntersections(): void;
+  }
+
+  namespace WallsLayer {
+    type AnyConstructor = typeof AnyWallsLayer;
+
+    interface DrawOptions extends PlaceablesLayer.DrawOptions {}
+
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Wall"> {
+      name: "walls";
+      controllableObjects: true;
+      objectClass: typeof Wall;
+      quadtree: true;
+      sheetClass: ConstructorOf<FormApplication>;
+      sortActiveTop: boolean;
+      zIndex: number;
+    }
+  }
+}
+
+declare abstract class AnyWallsLayer extends WallsLayer {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/perception/clockwise-sweep.d.mts

@@ -0,0 +1,157 @@
+import type Edge from "../../../client-esm/canvas/edges/edge.d.mts";
+
+declare global {
+  type VertexMap = Map<number, foundry.canvas.edges.PolygonVertex>;
+
+  type EdgeSet = Set<Edge>;
+
+  interface PolygonRay extends Ray {
+    result: foundry.canvas.edges.CollisionResult;
+  }
+
+  /**
+   * A PointSourcePolygon implementation that uses CCW (counter-clockwise) geometry orientation.
+   * Sweep around the origin, accumulating collision points based on the set of active walls.
+   * This algorithm was created with valuable contributions from https://github.com/caewok
+   */
+  class ClockwiseSweepPolygon extends PointSourcePolygon {
+    /**
+     * A mapping of vertices which define potential collision points
+     */
+    vertices: VertexMap;
+
+    /**
+     * The set of edges which define potential boundaries of the polygon
+     */
+    edges: EdgeSet;
+
+    /**
+     * A collection of rays which are fired at vertices
+     */
+    // @ts-expect-error Getter/setter routine is deprecated functionality as of v11, removed in v13
+    rays: PolygonRay[];
+
+    override initialize(origin: Canvas.Point, config: PointSourcePolygonConfig): void;
+
+    clone(): this;
+
+    protected override _compute(): void;
+
+    /**
+     * Get the super-set of walls which could potentially apply to this polygon.
+     * Define a custom collision test used by the Quadtree to obtain candidate Walls.
+     */
+    protected _identifyEdges(): void;
+
+    /**
+     * Determine the edge types and their manner of inclusion for this polygon instance
+     */
+    protected _determineEdgeTypes(): Record<Edge.EdgeTypes, 0 | 1 | 2>;
+
+    /**
+     * Test whether a wall should be included in the computed polygon for a given origin and type
+     * @param edge      - The Edge being considered
+     * @param edgeTypes - Which types of edges are being used? 0=no, 1=maybe, 2=always
+     * @param bounds    - The overall bounding box
+     * @returns Should the edge be included?
+     */
+    protected _testEdgeInclusion(
+      edge: Edge,
+      edgeTypes: Record<Edge.EdgeTypes, 0 | 1 | 2>,
+      bounds: PIXI.Rectangle,
+    ): boolean;
+
+    /**
+     * Compute the aggregate bounding box which is the intersection of all boundary shapes.
+     * Round and pad the resulting rectangle by 1 pixel to ensure it always contains the origin.
+     */
+    protected _defineBoundingBox(): PIXI.Rectangle;
+
+    /**
+     * Consolidate all vertices from identified edges and register them as part of the vertex mapping.
+     */
+    protected _identifyVertices(): void;
+
+    /**
+     * Add additional vertices for intersections between edges.
+     */
+    protected _identifyIntersections(wallEdgeMap: Map<string, Edge>): void;
+
+    /**
+     * Execute the sweep over wall vertices
+     * @internal
+     */
+    protected _executeSweep(): void;
+
+    /**
+     * Determine the initial set of active edges as those which intersect with the initial ray
+     * @returns A set of initially active edges
+     * @internal
+     */
+    protected _initializeActiveEdges(): EdgeSet;
+
+    /**
+     * Sort vertices clockwise from the initial ray (due west).
+     * @returns The array of sorted vertices
+     * @internal
+     */
+    protected _sortVertices(): foundry.canvas.edges.PolygonVertex[];
+
+    /**
+     * Test whether a target vertex is behind some closer active edge.
+     * If the vertex is to the left of the edge, is must be behind the edge relative to origin.
+     * If the vertex is collinear with the edge, it should be considered "behind" and ignored.
+     * We know edge.VertexA is ccw to edge.VertexB because of the logic in _identifyVertices.
+     * @param vertex      - The target vertex
+     * @param activeEdges - The set of active edges
+     * @returns Is the target vertex behind some closer edge?
+     * @internal
+     */
+    protected _isVertexBehindActiveEdges(
+      vertex: foundry.canvas.edges.PolygonVertex,
+      activeEdges: EdgeSet,
+    ): { isBehind: boolean; wasLimited: boolean };
+
+    /**
+     * Determine the result for the sweep at a given vertex
+     * @param vertex        - The target vertex
+     * @param activeEdges   - The set of active edges
+     * @param hasCollinear  - Are there collinear vertices behind the target vertex?
+     * @internal
+     */
+    protected _determineSweepResult(
+      vertex: foundry.canvas.edges.PolygonVertex,
+      activeEdges: EdgeSet,
+      hasCollinear: boolean,
+    ): void;
+
+    /**
+     * Switch to a new active edge.
+     * Moving from the origin, a collision that first blocks a side must be stored as a polygon point.
+     * Subsequent collisions blocking that side are ignored. Once both sides are blocked, we are done.
+     *
+     * Collisions that limit a side will block if that side was previously limited.
+     *
+     * If neither side is blocked and the ray internally collides with a non-limited edge, n skip without adding polygon
+     * endpoints. Sight is unaffected before this edge, and the internal collision can be ignored.
+     * @internal
+     *
+     * @param result      - The pending collision result
+     * @param activeEdges - The set of currently active edges
+     */
+    _switchEdge(result: foundry.canvas.edges.CollisionResult, activeEdges: EdgeSet): void;
+
+    protected override _testCollision<Mode extends PointSourcePolygon.CollisionModes>(
+      ray: Ray,
+      mode: Mode,
+    ): PointSourcePolygon.TestCollision<Mode>;
+
+    override visualize(): PIXI.Graphics | undefined;
+
+    /**
+     * Visualize the polygon, displaying its computed area, rays, and collision points
+     * @internal
+     */
+    protected _visualizeCollision(ray: Ray, collisions: foundry.canvas.edges.PolygonVertex[]): void;
+  }
+}