@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

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

@@ -1,5 +1,5 @@
-import type { ArrayOverlaps, HandleEmptyObject, NullishProps } from "fvtt-types/utils";
-import type Document from "../../../../common/abstract/document.d.mts";
+import type { HandleEmptyObject, Identity, NullishProps } from "fvtt-types/utils";
+import type Document from "#common/abstract/document.d.mts";
 
 declare global {
   /**
@@ -9,9 +9,9 @@ declare global {
     /**
      * The current index position in the tab cycle
      * @defaultValue `null`
-     * @remarks Foundry marked \@private but accesses it from Canvas
+     * @remarks Foundry marked `@private` but sets it `null` in  {@link Canvas#_onDragRightMove}
      */
-    _tabIndex: number | null;
+    protected _tabIndex: number | null;
 
     /**
      * @privateRemarks This is not overridden in foundry but reflects the real behavior.
@@ -39,24 +39,25 @@ declare global {
     static override documentName: "Token";
 
     /**
-     * The set of tokens that trigger occlusion (a union of {@link CONST.TOKEN_OCCLUSION_MODES}).
+     * The set of tokens that trigger occlusion (a union of {@link CONST.TOKEN_OCCLUSION_MODES | `CONST.TOKEN_OCCLUSION_MODES`}).
      */
-    set occlusionMode(value: number);
+    set occlusionMode(value: foundry.CONST.OCCLUSION_MODES);
 
-    get occlusionMode(): number;
+    get occlusionMode();
 
-    override get hookName(): string;
+    override get hookName(): "TokenLayer";
 
     /**
      * Token objects on this layer utilize the TokenHUD
      */
-    get hud(): TokenHUD;
+    get hud(): NonNullable<Canvas["hud"]>["token"];
 
     /**
      * An Array of tokens which belong to actors which are owned
      */
-    get ownedTokens(): ReturnType<this["placeables"]["filter"]>;
+    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>;
@@ -67,36 +68,46 @@ declare global {
 
     protected override _deactivate(): void;
 
-    override _pasteObject(
-      copy: Token.ConfiguredInstance,
+    protected override _pasteObject(
+      copy: Token.Implementation,
       offset: Canvas.Point,
-      options?: NullishProps<{ hidden: boolean; snap: boolean }>,
-    ): Document.ConfiguredSourceForName<"Token">;
+      options?: PlaceablesLayer.PasteOptions, // not:null (destructured)
+    ): Omit<TokenDocument.Source, "_id">;
 
-    protected override _getMovableObjects<const T>(
-      ids?: ArrayOverlaps<T, string>,
-      includeLocked?: boolean,
-    ): Token.ConfiguredInstance[];
+    /** @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.
+     * @param options   - Additional options to configure targeting behaviour.
+     * @returns The number of Token instances which were targeted.
      */
-    targetObjects(rectangle: Canvas.Rectangle, options?: NullishProps<PlaceableObject.ControlOptions>): number;
+    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, reset: boolean): Token.ConfiguredInstance | null;
+    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.ConfiguredInstance[];
+    protected _getCycleOrder(): Token.Implementation[];
 
     /**
      * Immediately conclude the animation of any/all tokens
@@ -112,29 +123,30 @@ declare global {
      * 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[];
+    protected _getOccludableTokens(): Token.Implementation[];
 
-    override storeHistory(
-      type: PlaceablesLayer.HistoryEventType,
-      data: Document.ConfiguredSourceForName<"Token">[],
+    /** @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.ConfiguredInstance>;
+    ): Promise<ReturnType<foundry.applications.ui.Notifications["warn"]> | false | TokenDocument.Implementation>;
 
-    //TODO: use configured ruler type once it exists
-    protected override _onClickLeft(event: PIXI.FederatedEvent): void; // ReturnType<CONFIG.Canvas["rulerClass"]["_onClickLeft"]>;
+    protected override _onClickLeft(event: PIXI.FederatedEvent): void;
 
-    protected override _onMouseWheel(event: WheelEvent): ReturnType<this["rotateMany"]>;
+    protected override _onMouseWheel(event: WheelEvent): Promise<Token.Implementation[] | void>;
 
     /**
      * @deprecated since v12 until v14
-     * @remarks "TokenLayer#toggleCombat is deprecated in favor of TokenDocument.implementation.createCombatants and TokenDocument.implementation.deleteCombatants"
+     * @remarks "TokenLayer#gridPrecision is deprecated. Use TokenLayer#getSnappedPoint instead of GridLayer#getSnappedPosition and TokenLayer#gridPrecision."
      */
     override get gridPrecision(): 1;
 
@@ -149,28 +161,21 @@ declare global {
      * @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[]>;
+      state?: boolean | null,
+      combat?: Combat.Implementation | null,
+      options?: TokenLayer.ToggleCombatOptions, // not:null (destructured)
+    ): Promise<Combatant.Implementation[]>;
   }
 
   namespace TokenLayer {
-    type AnyConstructor = typeof AnyTokenLayer;
+    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"> {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<Token.ImplementationClass> {
       name: "tokens";
       controllableObjects: true;
       rotatableObjects: true;
@@ -181,9 +186,25 @@ declare global {
       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 {}
   }
 }
 
 declare abstract class AnyTokenLayer extends TokenLayer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,5 +1,4 @@
-import type { HandleEmptyObject, NullishProps } from "fvtt-types/utils";
-import type Document from "../../../../common/abstract/document.d.mts";
+import type { Coalesce, HandleEmptyObject, Identity, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -9,6 +8,7 @@ declare global {
     /**
      * A graphics layer used to display chained Wall selection
      * @defaultValue `null`
+     * @remarks Only `null` prior to first draw
      */
     chain: PIXI.Graphics | null;
 
@@ -21,18 +21,14 @@ declare global {
     /**
      * 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
+     * @remarks Foundry marked `@private`, is set via {@link Wall#_onCreate} and {@link Wall#_onUpdate}
      */
-    _cloneType: ReturnType<foundry.documents.BaseWall["toJSON"]> | null;
+    protected _cloneType: WallDocument.Source | null;
 
     /**
      * Reference the last interacted wall endpoint for the purposes of chaining
-     * @defaultValue
-     * ```
-     * {
-     *   point: null,
-     * }
-     * ```
+     * @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;
@@ -55,25 +51,23 @@ declare global {
      */
     static override get layerOptions(): WallsLayer.LayerOptions;
 
-    /**
-     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
-     */
+    /** @privateRemarks This is not overridden in foundry but reflects the real behavior. */
     override options: WallsLayer.LayerOptions;
 
     static override documentName: "Wall";
 
-    override get hookName(): string;
+    override get hookName(): "WallsLayer";
 
     /**
      * An Array of Wall instances in the current Scene which act as Doors.
      */
-    get doors(): Wall.ConfiguredInstance[];
+    get doors(): Wall.Implementation[];
 
     override getSnappedPoint(point: Canvas.Point): Canvas.Point;
 
-    override _draw(options: HandleEmptyObject<WallsLayer.DrawOptions>): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<WallsLayer.DrawOptions>): Promise<void>;
 
-    override _deactivate(): void;
+    protected override _deactivate(): void;
 
     /**
      * Given a point and the coordinates of a wall, determine which endpoint is closer to the point
@@ -81,65 +75,55 @@ declare global {
      * @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.PointTuple;
+    static getClosestEndpoint(point: Canvas.Point, wall: Wall.Implementation): Canvas.PointTuple;
 
     override releaseAll(options?: PlaceableObject.ReleaseOptions): number;
 
-    override _pasteObject(
-      copy: Wall.ConfiguredInstance,
+    /** @remarks `options` is unused */
+    protected override _pasteObject(
+      copy: Wall.Implementation,
       offset: Canvas.Point,
-      options?: NullishProps<{ hidden: boolean; snap: boolean }>,
-    ): Document.ConfiguredSourceForName<"Wall">;
+      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): void | ReturnType<Canvas["animatePan"]>;
+    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?: NullishProps<{
-        /**
-         * Snap to the grid?
-         * @defaultValue `true`
-         */
-        snap: boolean;
-      }>,
+      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: 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"];
+    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 Marked \@license MIT
+     * @remarks Foundry marked `@license MIT`
      */
-    identifyInteriorArea(walls: Wall.ConfiguredInstance[]): PIXI.Polygon[];
+    identifyInteriorArea(walls: Wall.Implementation[]): PIXI.Polygon[];
 
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    protected override _onDragLeftStart(event: PIXI.FederatedEvent): Promise<Wall.ConfiguredInstance>;
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): Promise<Wall.Implementation>;
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
@@ -153,7 +137,10 @@ declare global {
      * @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;
+    checkCollision<Mode extends PointSourcePolygon.CollisionModes | undefined = undefined>(
+      ray: Ray,
+      options: PointSourcePolygon.TestCollisionConfig<Mode>,
+    ): PointSourcePolygon.TestCollision<Coalesce<Mode, "all">>;
 
     /**
      * @deprecated since v11, will be removed in v13
@@ -186,22 +173,34 @@ declare global {
   }
 
   namespace WallsLayer {
-    type AnyConstructor = typeof AnyWallsLayer;
+    interface Any extends AnyWallsLayer {}
+    interface AnyConstructor extends Identity<typeof AnyWallsLayer> {}
 
     interface DrawOptions extends PlaceablesLayer.DrawOptions {}
 
-    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Wall"> {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<Wall.ImplementationClass> {
       name: "walls";
       controllableObjects: true;
-      objectClass: typeof Wall;
-      quadtree: true;
-      sheetClass: FormApplication.AnyConstructor;
-      sortActiveTop: boolean;
-      zIndex: number;
+      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 {}
   }
 }
 
 declare abstract class AnyWallsLayer extends WallsLayer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,16 +1,11 @@
-import type { IntentionalPartial } from "fvtt-types/utils";
-import type Edge from "../../../client-esm/canvas/edges/edge.d.mts";
+import type { Identity, IntentionalPartial } from "fvtt-types/utils";
+import type Edge from "#client-esm/canvas/edges/edge.d.mts";
 
 declare global {
-  interface PolygonRay extends Ray {
-    /**
-     * @remarks Only set in `ClockwiseSweepPolygon#_switchEdge` and only consumed in `#visualize`,
-     * despite unrelated method(s) having parameters claiming to want a `PolygonRay`
-     *
-     * Tested for truthiness in `#visualize` before use, so a nullish value is fine but never attains in core
-     */
-    result?: foundry.canvas.edges.CollisionResult | undefined | null;
-  }
+  /**
+   * @deprecated {@link ClockwiseSweepPolygon.Ray | `ClockwiseSweepPolygon.Ray`}
+   */
+  type PolygonRay = ClockwiseSweepPolygon.Ray;
 
   /**
    * A PointSourcePolygon implementation that uses CCW (counter-clockwise) geometry orientation.
@@ -38,9 +33,9 @@ declare global {
      * 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[];
+    rays: ClockwiseSweepPolygon.Ray[];
 
-    override initialize(origin: Canvas.Point, config?: PointSourcePolygon.Config): void;
+    override initialize(origin: Canvas.Point, config: PointSourcePolygon.Config): void;
 
     clone(): this;
 
@@ -167,20 +162,31 @@ declare global {
 
   namespace ClockwiseSweepPolygon {
     interface Any extends AnyClockwiseSweepPolygon {}
-    type AnyConstructor = typeof AnyClockwiseSweepPolygon;
+    interface AnyConstructor extends Identity<typeof AnyClockwiseSweepPolygon> {}
 
     interface StoredConfig extends PointSourcePolygon.StoredConfig {
       /** The computed bounding box for the polygon */
       boundingBox: PIXI.Rectangle;
     }
+
     /**
-     * @privateRemarks Foundry types this as `Record<Edge.EdgeTypes, 0 | 1 | 2>`, but some keys are mutually exclusive,
+     * @remarks Foundry types this as `Record<Edge.EdgeTypes, 0 | 1 | 2>`, but some keys are mutually exclusive,
      * and none are ever set to `0`, they're simply omitted and then tested for truthiness in `#_testEdgeInclusion`
      */
     type DetermineEdgesReturn = IntentionalPartial<Record<Edge.EdgeTypes, 1 | 2>>;
+
+    interface Ray extends globalThis.Ray {
+      /**
+       * @remarks Only set in `ClockwiseSweepPolygon#_switchEdge` and only consumed in `#visualize`,
+       * despite unrelated method(s) having parameters claiming to want a `PolygonRay`
+       *
+       * Tested for truthiness in `#visualize` before use, so a nullish value is fine but never attains in core
+       */
+      result?: foundry.canvas.edges.CollisionResult | undefined | null;
+    }
   }
 }
 
 declare abstract class AnyClockwiseSweepPolygon extends ClockwiseSweepPolygon {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }