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

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

@@ -1,207 +0,0 @@
-import type { HandleEmptyObject, NullishProps } from "fvtt-types/utils";
-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 extends PlaceablesLayer<"Wall"> {
-    /**
-     * 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.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(): 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: HandleEmptyObject<WallsLayer.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.PointTuple;
-
-    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.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
-     */
-    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[];
-
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    protected override _onDragLeftStart(event: PIXI.FederatedEvent): Promise<Wall.ConfiguredInstance>;
-
-    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: FormApplication.AnyConstructor;
-      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

@@ -1,186 +0,0 @@
-import type { 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;
-  }
-
-  /**
-   * 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 {
-    // This does not appear in Foundry code, it's a necessary type override
-    static override create(origin: Canvas.Point, config: PointSourcePolygon.Config): ClockwiseSweepPolygon;
-
-    // This does not appear in foundry code, it's a necessary type override
-    override config: ClockwiseSweepPolygon.StoredConfig;
-
-    /**
-     * A mapping of vertices which define potential collision points
-     */
-    vertices: Map<number, foundry.canvas.edges.PolygonVertex>;
-
-    /**
-     * The set of edges which define potential boundaries of the polygon
-     */
-    edges: Set<Edge>;
-
-    /**
-     * 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?: PointSourcePolygon.Config): 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(): ClockwiseSweepPolygon.DetermineEdgesReturn;
-
-    /**
-     * 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: ClockwiseSweepPolygon.DetermineEdgesReturn,
-      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(edgeMap: Map<string, Edge>): void;
-
-    /**
-     * Execute the sweep over wall vertices
-     * @privateRemarks Foundry marked `@private`
-     */
-    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
-     * @privateRemarks Foundry marked `@private`
-     */
-    protected _initializeActiveEdges(): Set<Edge>;
-
-    /**
-     * Sort vertices clockwise from the initial ray (due west).
-     * @returns The array of sorted vertices
-     * @privateRemarks Foundry marked `@private`
-     */
-    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?
-     * @privateRemarks Foundry marked `@private`
-     */
-    protected _isVertexBehindActiveEdges(
-      vertex: foundry.canvas.edges.PolygonVertex,
-      activeEdges: Set<Edge>,
-    ): { 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?
-     *                        default: `false`
-     * @privateRemarks Foundry marked `@private`
-     */
-    protected _determineSweepResult(
-      vertex: foundry.canvas.edges.PolygonVertex,
-      activeEdges: Set<Edge>,
-      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.
-     *
-     * @param result      - The pending collision result
-     * @param activeEdges - The set of currently active edges
-     * @privateRemarks Foundry marked `@private`
-     */
-    protected _switchEdge(result: foundry.canvas.edges.CollisionResult, activeEdges: Set<Edge>): void;
-
-    protected override _testCollision<Mode extends PointSourcePolygon.CollisionModes>(
-      ray: Ray,
-      mode: Mode,
-    ): PointSourcePolygon.TestCollision<Mode>;
-
-    override visualize(): PIXI.Graphics;
-
-    /**
-     * Visualize the polygon, displaying its computed area, rays, and collision points
-     * @privateRemarks Foundry marked `@private`
-     */
-    protected _visualizeCollision(ray: Ray, collisions: foundry.canvas.edges.PolygonVertex[]): void;
-  }
-
-  namespace ClockwiseSweepPolygon {
-    interface Any extends AnyClockwiseSweepPolygon {}
-    type AnyConstructor = 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,
-     * 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>>;
-  }
-}
-
-declare abstract class AnyClockwiseSweepPolygon extends ClockwiseSweepPolygon {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/perception/detection-mode.d.mts

@@ -1,214 +0,0 @@
-import type { InexactPartial, ValueOf } from "fvtt-types/utils";
-import type { fields } from "../../../common/data/_module.d.mts";
-import type { TokenDetectionMode } from "../../../common/documents/_types.d.mts";
-
-type DataSchema = foundry.data.fields.DataSchema;
-
-declare global {
-  namespace DetectionMode {
-    interface Schema extends DataSchema {
-      id: fields.StringField<{ blank: false }>;
-      label: fields.StringField<{ blank: false }>;
-      tokenConfig: fields.BooleanField<{ initial: true }>;
-      walls: fields.BooleanField<{ initial: true }>;
-      angle: fields.BooleanField<{ initial: true }>;
-      type: fields.NumberField<{
-        initial: typeof DetectionMode.DETECTION_TYPES.SIGHT;
-        choices: ValueOf<typeof DetectionMode.DETECTION_TYPES>[];
-      }>;
-    }
-  }
-
-  /**
-   * A Detection Mode which can be associated with any kind of sense/vision/perception.
-   * A token could have multiple detection modes.
-   */
-  class DetectionMode extends foundry.abstract.DataModel<DetectionMode.Schema> {
-    static override defineSchema(): DetectionMode.Schema;
-
-    /**
-     * Get the detection filter pertaining to this mode.
-     */
-    static getDetectionFilter(): PIXI.Filter | undefined;
-
-    /**
-     * An optional filter to apply on the target when it is detected with this mode.
-     */
-    static _detectionFilter: PIXI.Filter | undefined;
-
-    /**
-     * The type of the detection mode.
-     * @see CONST.WALL_RESTRICTION_TYPES
-     */
-    static DETECTION_TYPES: {
-      /** Sight, and anything depending on light perception */
-      SIGHT: 0;
-      /** What you can hear. Includes echolocation for bats per example */
-      SOUND: 1;
-      /** This is mostly a sense for touch and vibration, like tremorsense, movement detection, etc. */
-      MOVE: 2;
-      /** Can't fit in other types (smell, life sense, trans-dimensional sense, sense of humor...) */
-      OTHER: 3;
-    };
-
-    /**
-     * The identifier of the basic sight detection mode.
-     */
-    static BASIC_MODE_ID: "basicSight";
-
-    /**
-     * Test visibility of a target object or array of points for a specific vision source.
-     * @param visionSource  - The vision source being tested
-     * @param mode          - The detection mode configuration
-     * @param config        - The visibility test configuration
-     * @returns   Is the test target visible?
-     */
-    testVisibility(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      mode: TokenDetectionMode,
-      { object, tests }: InexactPartial<CanvasVisibilityTestConfig>,
-    ): boolean;
-
-    /**
-     * Can this VisionSource theoretically detect a certain object based on its properties?
-     * This check should not consider the relative positions of either object, only their state.
-     * @param visionSource - The vision source being tested
-     * @param target       - The target object being tested
-     * @returns Can the target object theoretically be detected by this vision source?
-     */
-    protected _canDetect(visionSource: foundry.canvas.sources.PointVisionSource.Any, target: PlaceableObject): boolean;
-
-    /**
-     * Evaluate a single test point to confirm whether it is visible.
-     * Standard detection rules require that the test point be both within LOS and within range.
-     * @param visionSource - The vision source being tested
-     * @param mode         - The detection mode configuration
-     * @param target       - The target object being tested
-     * @param test         - The test case being evaluated
-     */
-    protected _testPoint(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
-    ): boolean;
-
-    /**
-     * Test whether the line-of-sight requirement for detection is satisfied.
-     * Always true if the detection mode bypasses walls, otherwise the test point must be contained by the LOS polygon.
-     * The result of is cached for the vision source so that later checks for other detection modes do not repeat it.
-     * @param visionSource    - The vision source being tested
-     * @param mode            - The detection mode configuration
-     * @param target          - The target object being tested
-     * @param test            - The test case being evaluated
-     * @returns Is the LOS requirement satisfied for this test?
-     */
-    protected _testLOS(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
-    ): boolean;
-
-    /**
-     * Test whether the target is within the vision angle.
-     * @param visionSource    - The vision source being tested
-     * @param mode            - The detection mode configuration
-     * @param target          - The target object being tested
-     * @param test            - The test case being evaluated
-     * @returns Is the point within the vision angle?
-     */
-    protected _testAngle(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
-    ): boolean;
-
-    /**
-     * Verify that a target is in range of a source.
-     * @param visionSource    - The vision source being tested
-     * @param mode            - The detection mode configuration
-     * @param target          - The target object being tested
-     * @param test            - The test case being evaluated
-     * @returns Is the target within range?
-     */
-    protected _testRange(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
-    ): boolean;
-  }
-
-  /**
-   * This detection mode tests whether the target is visible due to being illuminated by a light source.
-   * By default tokens have light perception with an infinite range if light perception isn't explicitely
-   * configured.
-   */
-  class DetectionModeLightPerception extends DetectionMode {
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
-    ): boolean;
-
-    protected override _testPoint(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      mode: TokenDetectionMode,
-      target: PlaceableObject,
-      test: CanvasVisibilityTest,
-    ): boolean;
-  }
-
-  /**
-   * A special detection mode which models a form of darkvision (night vision).
-   * This mode is the default case which is tested first when evaluating visibility of objects.
-   * It is also a special case, in that it is the only detection mode which considers the area of distant light sources.
-   */
-  class DetectionModeBasicSight extends DetectionMode {
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
-    ): boolean;
-  }
-
-  /**
-   * Detection mode that see invisible creatures.
-   * This detection mode allows the source to:
-   * - See/Detect the invisible target as if visible.
-   * - The "See" version needs sight and is affected by blindness
-   */
-  class DetectionModeInvisibility extends DetectionMode {
-    static override getDetectionFilter(): PIXI.Filter | undefined;
-
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
-    ): boolean;
-  }
-
-  /**
-   * Detection mode that see creatures in contact with the ground.
-   */
-  class DetectionModeTremor extends DetectionMode {
-    static override getDetectionFilter(): PIXI.Filter | undefined;
-
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
-    ): boolean;
-  }
-
-  /**
-   * Detection mode that see ALL creatures (no blockers).
-   * If not constrained by walls, see everything within the range.
-   */
-  class DetectionModeAll extends DetectionMode {
-    static override getDetectionFilter(): PIXI.Filter | undefined;
-
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: PlaceableObject,
-    ): boolean;
-  }
-}