@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/client/canvas/layers/tokens.d.mts

@@ -0,0 +1,218 @@
+import type { HandleEmptyObject, Identity, NullishProps } from "#utils";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type Document from "#common/abstract/document.d.mts";
+import type { PlaceablesLayer } from "./_module.d.mts";
+import type { PlaceableObject, Token } from "#client/canvas/placeables/_module.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface PlaceablesLayerConfig {
+      TokenLayer: TokenLayer.Any;
+    }
+  }
+}
+
+/**
+ * The Tokens Container
+ */
+declare class TokenLayer extends PlaceablesLayer<"Token"> {
+  /**
+   * The current index position in the tab cycle
+   * @defaultValue `null`
+   * @remarks Foundry marked `@private` but sets it `null` in  {@link Canvas#_onDragRightMove}
+   */
+  protected _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 {@linkcode CONST.TOKEN_OCCLUSION_MODES}).
+   */
+  set occlusionMode(value: foundry.CONST.OCCLUSION_MODES);
+
+  get occlusionMode();
+
+  override get hookName(): "TokenLayer";
+
+  /**
+   * Token objects on this layer utilize the TokenHUD
+   */
+  get hud(): NonNullable<Canvas["hud"]>["token"];
+
+  /**
+   * An Array of tokens which belong to actors which are owned
+   */
+  get ownedTokens(): Token.Implementation[];
+
+  /** @remarks Forces top left corner snapping */
+  override getSnappedPoint(point: Canvas.Point): Canvas.Point;
+
+  protected override _draw(options: HandleEmptyObject<TokenLayer.DrawOptions>): Promise<void>;
+
+  protected override _tearDown(options: HandleEmptyObject<TokenLayer.TearDownOptions>): Promise<void>;
+
+  protected override _activate(): void;
+
+  protected override _deactivate(): void;
+
+  protected override _pasteObject(
+    copy: Token.Implementation,
+    offset: Canvas.Point,
+    options?: PlaceablesLayer.PasteOptions, // not:null (destructured)
+  ): Omit<TokenDocument.Source, "_id">;
+
+  /** @remarks Returns `[]` if the ruler is currently measuring */
+  protected override _getMovableObjects(ids?: string[] | null, includeLocked?: boolean | null): Token.Implementation[];
+
+  /**
+   * Target all Token instances which fall within a coordinate rectangle.
+   * @param rectangle - The selection rectangle.
+   * @param options   - Additional options to configure targeting behaviour.
+   * @returns The number of Token instances which were targeted.
+   */
+  targetObjects(
+    rectangle: Canvas.Rectangle,
+    options?: TokenLayer.TargetObjectsOptions, // not:null (destructured)
+  ): 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?
+   * @returns The Token object which was cycled to, or null
+   * @remarks Neither parameter has a default, so a call with no arguments cycles backward without resetting
+   *
+   * Also selects the returned token if any, and pans the camera to its center
+   */
+  cycleTokens(forwards?: boolean | null, reset?: boolean | null): Token.Implementation | null;
+
+  /**
+   * Get the tab cycle order for tokens by sorting observable tokens based on their distance from top-left.
+   * @remarks Foundry marked `@private`
+   */
+  protected _getCycleOrder(): Token.Implementation[];
+
+  /**
+   * 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.Implementation[];
+
+  /** @remarks "Clean actorData and delta updates from the history so changes to those fields are not undone" */
+  override storeHistory<Operation extends Document.Database.Operation>(
+    type: Operation,
+    data: PlaceablesLayer.HistoryDataFor<Operation, "Token">,
+  ): void;
+
+  /**
+   * Handle dropping of Actor data onto the Scene canvas
+   * @remarks Foundry marked `@private`
+   */
+  protected _onDropActorData(
+    event: DragEvent,
+    data: TokenLayer.DropData,
+  ): Promise<ReturnType<foundry.applications.ui.Notifications["warn"]> | false | TokenDocument.Implementation>;
+
+  protected override _onClickLeft(event: Canvas.Event.Pointer): void;
+
+  protected override _onMouseWheel(event: Canvas.Event.Wheel): Promise<Token.Implementation[] | void>;
+
+  /**
+   * @deprecated since v12 until v14
+   * @remarks "TokenLayer#gridPrecision is deprecated. Use TokenLayer#getSnappedPoint instead of GridLayer#getSnappedPosition and TokenLayer#gridPrecision."
+   */
+  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 | null,
+    combat?: Combat.Implementation | null,
+    options?: TokenLayer.ToggleCombatOptions, // not:null (destructured)
+  ): Promise<Combatant.Implementation[]>;
+}
+
+declare namespace TokenLayer {
+  interface Any extends AnyTokenLayer {}
+  interface AnyConstructor extends Identity<typeof AnyTokenLayer> {}
+
+  interface DrawOptions extends PlaceablesLayer.DrawOptions {}
+
+  interface TearDownOptions extends PlaceablesLayer.TearDownOptions {}
+
+  interface LayerOptions extends PlaceablesLayer.LayerOptions<Token.ImplementationClass> {
+    name: "tokens";
+    controllableObjects: true;
+    rotatableObjects: true;
+    zIndex: 200;
+  }
+
+  interface DropData extends Canvas.DropPosition {
+    type: "Actor";
+    uuid: string;
+  }
+
+  /** @internal */
+  // TODO: the NP should probably be on the PO side, update once PO has been done
+  type _TargetObjectsOptions = NullishProps<PlaceableObject.ControlOptions>;
+
+  interface TargetObjectsOptions extends _TargetObjectsOptions {}
+
+  /** @internal */
+  type _ToggleCombatOptions = NullishProps<{
+    /**
+     * A specific Token which is the origin of the group toggle request
+     * @defaultValue `null`
+     */
+    token: Token.Implementation;
+  }>;
+  interface ToggleCombatOptions extends _ToggleCombatOptions {}
+}
+
+export default TokenLayer;
+
+declare abstract class AnyTokenLayer extends TokenLayer {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/layers/walls.d.mts

@@ -0,0 +1,218 @@
+import type { Coalesce, HandleEmptyObject, Identity, NullishProps } from "#utils";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { Ray, PointSourcePolygon } from "#client/canvas/geometry/_module.d.mts";
+import type { PlaceablesLayer } from "./_module.d.mts";
+import type { PlaceableObject, Wall } from "#client/canvas/placeables/_module.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface PlaceablesLayerConfig {
+      WallsLayer: WallsLayer.Any;
+    }
+  }
+}
+
+/**
+ * The Walls canvas layer which provides a container for Wall objects within the rendered Scene.
+ */
+declare class WallsLayer extends PlaceablesLayer<"Wall"> {
+  /**
+   * A graphics layer used to display chained Wall selection
+   * @defaultValue `null`
+   * @remarks Only `null` prior to first draw
+   */
+  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 Foundry marked `@private`, is set via {@link Wall#_onCreate} and {@link Wall#_onUpdate}
+   */
+  protected _cloneType: WallDocument.Source | null;
+
+  /**
+   * Reference the last interacted wall endpoint for the purposes of chaining
+   * @defaultValue `{ point: null }`
+   * @remarks Foundry marked `@private`, is set via {@link Wall#_onHoverIn}, {@link Wall#_onHoverOut}, and {@link Wall#_prepareDragLeftDropUpdates}
+   */
+  protected last: {
+    point: Canvas.PointTuple | 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(): "WallsLayer";
+
+  /**
+   * An Array of Wall instances in the current Scene which act as Doors.
+   */
+  get doors(): Wall.Implementation[];
+
+  override getSnappedPoint(point: Canvas.Point): Canvas.Point;
+
+  protected override _draw(options: HandleEmptyObject<WallsLayer.DrawOptions>): Promise<void>;
+
+  protected 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.Implementation): Canvas.PointTuple;
+
+  override releaseAll(options?: PlaceableObject.ReleaseOptions): number;
+
+  /** @remarks `options` is unused */
+  protected override _pasteObject(
+    copy: Wall.Implementation,
+    offset: Canvas.Point,
+    options?: PlaceablesLayer.PasteOptions | null,
+  ): Omit<WallDocument.Source, "_id">;
+
+  /**
+   * 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
+   * @remarks Foundry marked `@private`
+   */
+  protected _panCanvasEdge(event: MouseEvent, x: number, y: number): Promise<boolean> | void;
+
+  /**
+   * Get the wall endpoint coordinates for a given point.
+   * @param  point - The candidate wall endpoint.
+   * @returns The wall endpoint coordinates.
+   * @remarks Foundry marked `@internal`, is called externally in {@link Wall#_onDragLeftMove} and {@link Wall#_prepareDragLeftDropUpdates}
+   */
+  protected _getWallEndpointCoordinates(
+    point: Canvas.Point,
+    options?: WallsLayer.GetWallEndpointCoordinatesOptions, // not:null (destructured)
+  ): Canvas.PointTuple;
+
+  /**
+   * 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
+   * @remarks If a tool is not provided, returns an object with `light`, `sight`, `sound`, and `move` keys, all with the value `CONST.WALL_SENSE_TYPES.NORMAL`
+   */
+  protected _getWallDataFromActiveTool(tool?: WallsLayer.WallTools | null): WallDocument.Source;
+
+  /**
+   * Identify the interior enclosed by the given walls.
+   * @param  walls - The walls that enclose the interior.
+   * @returns The polygons of the interior.
+   * @remarks Foundry marked `@license MIT`
+   */
+  identifyInteriorArea(walls: Wall.Implementation[]): PIXI.Polygon[];
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  protected override _onDragLeftStart(event: Canvas.Event.Pointer): Promise<Wall.Implementation>;
+
+  protected override _onDragLeftMove(event: Canvas.Event.Pointer): void;
+
+  protected override _onDragLeftDrop(event: Canvas.Event.Pointer): void;
+
+  protected override _onDragLeftCancel(event: Canvas.Event.Pointer): void;
+
+  protected override _onClickRight(event: Canvas.Event.Pointer): void;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks "WallsLayer#checkCollision is obsolete. Prefer calls to testCollision from CONFIG.Canvas.polygonBackends[type]"
+   */
+  checkCollision<Mode extends PointSourcePolygon.CollisionModes | undefined = undefined>(
+    ray: Ray,
+    options: PointSourcePolygon.TestCollisionOptions<Mode>,
+  ): PointSourcePolygon.TestCollision<Coalesce<Mode, "all">>;
+
+  /**
+   * @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.geometry.edges.Edge.identifyEdgeIntersections and has no effect."
+   */
+  identifyWallIntersections(): void;
+}
+
+declare namespace WallsLayer {
+  interface Any extends AnyWallsLayer {}
+  interface AnyConstructor extends Identity<typeof AnyWallsLayer> {}
+
+  interface DrawOptions extends PlaceablesLayer.DrawOptions {}
+
+  interface LayerOptions extends PlaceablesLayer.LayerOptions<Wall.ImplementationClass> {
+    name: "walls";
+    controllableObjects: true;
+    objectClass: Wall.ImplementationClass;
+    zIndex: 700;
+  }
+
+  /** @internal */
+  type _Snap = NullishProps<{
+    /**
+     * Snap to the grid?
+     * @defaultValue `true`
+     */
+    snap: boolean;
+  }>;
+
+  /** @remarks The types handled by {@link Wall#_getWallDataFromActiveTool} */
+  type WallTools = "clone" | "invisible" | "terrain" | "ethereal" | "doors" | "secret" | "window";
+
+  interface GetWallEndpointCoordinatesOptions extends _Snap {}
+}
+
+export default WallsLayer;
+
+declare abstract class AnyWallsLayer extends WallsLayer {
+  constructor(...args: never);
+}