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

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

@@ -1,192 +0,0 @@
-import type { Identity, IntentionalPartial } from "fvtt-types/utils";
-import type Edge from "#client-esm/canvas/edges/edge.d.mts";
-
-declare global {
-  /**
-   * @deprecated {@link ClockwiseSweepPolygon.Ray | `ClockwiseSweepPolygon.Ray`}
-   */
-  type PolygonRay = ClockwiseSweepPolygon.Ray;
-
-  /**
-   * 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: ClockwiseSweepPolygon.Ray[];
-
-    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 {}
-    interface AnyConstructor extends Identity<typeof AnyClockwiseSweepPolygon> {}
-
-    interface StoredConfig extends PointSourcePolygon.StoredConfig {
-      /** The computed bounding box for the polygon */
-      boundingBox: PIXI.Rectangle;
-    }
-
-    /**
-     * @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(...args: never);
-}

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

@@ -1,286 +0,0 @@
-import type { Brand, Identity, NullishProps } from "fvtt-types/utils";
-import type { fields } from "#common/data/_module.d.mts";
-import type { TokenDetectionMode } from "#common/documents/_types.d.mts";
-import type { DataSchema } from "#common/data/fields.d.mts";
-
-declare global {
-  /**
-   * 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 {@link CONST.WALL_RESTRICTION_TYPES | `CONST.WALL_RESTRICTION_TYPES`}
-     * @remarks Set via `Object.defineProperty` with a frozen object, so `readonly` is justified both here and for the interface properties
-     */
-    static readonly DETECTION_TYPES: DetectionMode.DetectionTypes;
-
-    /**
-     * The identifier of the basic sight detection mode.
-     */
-    static readonly 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 }: DetectionMode.TestConfig, // not:null (destructured)
-    ): 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: CanvasVisibility.TestObject,
-    ): 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: CanvasVisibility.TestObject,
-      test: CanvasVisibility.Test,
-    ): 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: CanvasVisibility.TestObject,
-      test: CanvasVisibility.Test,
-    ): 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: CanvasVisibility.TestObject,
-      test: CanvasVisibility.Test,
-    ): 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: CanvasVisibility.TestObject,
-      test: CanvasVisibility.Test,
-    ): boolean;
-  }
-
-  namespace DetectionMode {
-    interface Any extends AnyDetectionMode {}
-    interface AnyConstructor extends Identity<typeof AnyDetectionMode> {}
-
-    interface Schema extends DataSchema {
-      id: fields.StringField<{ blank: false }>;
-
-      label: fields.StringField<{ blank: false }>;
-
-      /** If this DM is available in Token Config UI */
-      tokenConfig: fields.BooleanField<{ initial: true }>;
-
-      /** If this DM is constrained by walls */
-      walls: fields.BooleanField<{ initial: true }>;
-
-      /** If this DM is constrained by the vision angle */
-      angle: fields.BooleanField<{ initial: true }>;
-
-      type: fields.NumberField<{
-        initial: DetectionMode.DETECTION_TYPES;
-        choices: DetectionMode.DETECTION_TYPES[];
-      }>;
-    }
-
-    /** @see CanvasVisibility.TestConfig */
-    interface TestConfig
-      extends CanvasVisibility._TestConfigRequired,
-        NullishProps<CanvasVisibility._TestConfigOptional> {}
-
-    type DETECTION_TYPES = Brand<number, "DetectionMode.DETECTION_TYPES">;
-
-    interface DetectionTypes {
-      /** Sight, and anything depending on light perception */
-      readonly SIGHT: 0 & DETECTION_TYPES;
-      /** What you can hear. Includes echolocation for bats per example */
-      readonly SOUND: 1 & DETECTION_TYPES;
-      /** This is mostly a sense for touch and vibration, like tremorsense, movement detection, etc. */
-      readonly MOVE: 2 & DETECTION_TYPES;
-      /** Can't fit in other types (smell, life sense, trans-dimensional sense, sense of humor...) */
-      readonly OTHER: 3 & DETECTION_TYPES;
-    }
-  }
-
-  /**
-   * 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: CanvasVisibility.TestObject,
-    ): boolean;
-
-    protected override _testPoint(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      mode: TokenDetectionMode,
-      target: CanvasVisibility.TestObject,
-      test: CanvasVisibility.Test,
-    ): boolean;
-  }
-
-  namespace DetectionModeLightPerception {
-    interface Any extends AnyDetectionModeLightPerception {}
-    interface AnyConstructor extends Identity<typeof AnyDetectionModeLightPerception> {}
-  }
-
-  /**
-   * 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: CanvasVisibility.TestObject,
-    ): boolean;
-  }
-
-  namespace DetectionModeBasicSight {
-    interface Any extends AnyDetectionModeBasicSight {}
-    interface AnyConstructor extends Identity<typeof AnyDetectionModeBasicSight> {}
-  }
-
-  /**
-   * 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;
-
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: CanvasVisibility.TestObject,
-    ): boolean;
-  }
-
-  namespace DetectionModeInvisibility {
-    interface Any extends AnyDetectionModeInvisibility {}
-    interface AnyConstructor extends Identity<typeof AnyDetectionModeInvisibility> {}
-  }
-
-  /**
-   * Detection mode that see creatures in contact with the ground.
-   */
-  class DetectionModeTremor extends DetectionMode {
-    static override getDetectionFilter(): PIXI.Filter;
-
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: CanvasVisibility.TestObject,
-    ): boolean;
-  }
-
-  namespace DetectionModeTremor {
-    interface Any extends AnyDetectionModeTremor {}
-    interface AnyConstructor extends Identity<typeof AnyDetectionModeTremor> {}
-  }
-
-  /**
-   * 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;
-
-    protected override _canDetect(
-      visionSource: foundry.canvas.sources.PointVisionSource.Any,
-      target: CanvasVisibility.TestObject,
-    ): boolean;
-  }
-
-  namespace DetectionModeAll {
-    interface Any extends AnyDetectionModeAll {}
-    interface AnyConstructor extends Identity<typeof AnyDetectionModeAll> {}
-  }
-}
-
-declare abstract class AnyDetectionMode extends DetectionMode {
-  constructor(...args: never);
-}
-
-declare abstract class AnyDetectionModeLightPerception extends DetectionModeLightPerception {
-  constructor(...args: never);
-}
-
-declare abstract class AnyDetectionModeBasicSight extends DetectionModeBasicSight {
-  constructor(...args: never);
-}
-
-declare abstract class AnyDetectionModeInvisibility extends DetectionModeInvisibility {
-  constructor(...args: never);
-}
-
-declare abstract class AnyDetectionModeTremor extends DetectionModeTremor {
-  constructor(...args: never);
-}
-
-declare abstract class AnyDetectionModeAll extends DetectionModeAll {
-  constructor(...args: never);
-}

package/src/foundry/client/pixi/perception/fog.d.mts

@@ -1,154 +0,0 @@
-import type EventEmitterMixin from "#common/utils/event-emitter.mjs";
-import type { FixedInstanceType, Identity } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * A fog of war management class which is the singleton canvas.fog instance.
-   */
-  class FogManager extends EventEmitterMixin() {
-    /**
-     * The FogExploration document which applies to this canvas view
-     * @defaultValue `null`
-     */
-    exploration: FogExploration.Implementation | null;
-
-    /**
-     * Track whether we have pending fog updates which have not yet been saved to the database
-     * @defaultValue `false`
-     * @remarks Foundry marked `@internal`
-     */
-    protected _updated: boolean;
-
-    /**
-     * Texture extractor
-     * @remarks Only `undefined` before first `#initialize()`ation. Set to `null` if `TextureExtractor` creation fails, and will not retry from that state.
-     */
-    get extractor(): TextureExtractor | undefined | null;
-
-    /**
-     * Define the number of fog refresh needed before the fog texture is extracted and pushed to the server.
-     * @defaultValue `70`
-     */
-    static COMMIT_THRESHOLD: number;
-
-    /**
-     * The exploration SpriteMesh which holds the fog exploration texture.
-     */
-    get sprite(): SpriteMesh;
-
-    /**
-     * The configured options used for the saved fog-of-war texture.
-     * @remarks Only `undefined` prior to the first time the canvas visibility layer is `#draw()`n
-     */
-    get textureConfiguration(): CanvasVisibility.TextureConfiguration | undefined;
-
-    /**
-     * Does the currently viewed Scene support Token field of vision?
-     */
-    // TODO: make `Scene.Implementation["tokenVision"]` when docsv2 is done
-    get tokenVision(): boolean;
-
-    /**
-     * Does the currently viewed Scene support fog of war exploration?
-     */
-    // TODO: make `Scene.Implementation["fog"]["exploration"]` when docsv2 is done
-    get fogExploration(): boolean;
-
-    /**
-     * Create the exploration display object with or without a provided texture.
-     * @privateRemarks Despite Foundry only typing this as returning `DisplayObject` in 12.331, it always returns a `SpriteMesh`
-     */
-    protected _createExplorationObject(tex?: PIXI.Texture | PIXI.RenderTexture | null): SpriteMesh;
-
-    /**
-     * Initialize fog of war - resetting it when switching scenes or re-drawing the canvas
-     */
-    initialize(): Promise<void>;
-
-    /**
-     * Clear the fog and reinitialize properties (commit and save in non reset mode)
-     */
-    clear(): Promise<void>;
-
-    /**
-     * Once a new Fog of War location is explored, composite the explored container with the current staging sprite.
-     * Once the number of refresh is \> to the commit threshold, save the fog texture to the database.
-     */
-    commit(): void;
-
-    /**
-     * Load existing fog of war data from local storage and populate the initial exploration sprite
-     */
-    load(): Promise<PIXI.Texture | void>;
-
-    /**
-     * Dispatch a request to reset the fog of war exploration status for all users within this Scene.
-     * Once the server has deleted existing FogExploration documents, the _onReset handler will re-draw the canvas.
-     */
-    reset(): Promise<void>;
-
-    /**
-     * Request a fog of war save operation.
-     * Note: if a save operation is pending, we're waiting for its conclusion.
-     */
-    save(): Promise<void>;
-
-    /**
-     * Extract fog data as a base64 string
-     */
-    protected _extractBase64(): Promise<string>;
-
-    /**
-     * Prepare the data that will be used to update the FogExploration document.
-     * @param base64Image - The extracted base64 image data
-     * @returns Exploration data to update
-     */
-    protected _prepareFogUpdateData(base64Image: string): FogExploration.UpdateData;
-
-    /**
-     * If fog of war data is reset from the server, deactivate the current fog and initialize the exploration.
-     * @remarks Foundry marked `@internal`, called externally in the `fogReset` socket handler
-     */
-    protected _handleReset(): Promise<void>;
-
-    /**
-     * @deprecated since v11, will be removed in v13
-     * @remarks "pending is deprecated and redirected to the exploration container"
-     */
-    get pending(): CanvasVisibility["explored"];
-
-    /**
-     * @deprecated since v11, will be removed in v13
-     * @remarks "revealed is deprecated and redirected to the exploration container"
-     */
-    get revealed(): CanvasVisibility["explored"];
-
-    /**
-     * @deprecated since v11, will be removed in v13
-     * @remarks "update is obsolete and always returns true. The fog exploration does not record position anymore."
-     *
-     * Both parameters are unused
-     */
-    update(source: any, force?: boolean | null): true;
-
-    /**
-     * @deprecated since v11, will be removed in v13
-     * @remarks "resolution is deprecated and redirected to CanvasVisibility#textureConfiguration"
-     *
-     * Probable Bug Note: Returns the entire `textureConfiguration` object, not just its `resolution` property
-     */
-    get resolution(): CanvasVisibility["textureConfiguration"];
-  }
-
-  namespace FogManager {
-    interface Any extends AnyFogManager {}
-    interface AnyConstructor extends Identity<typeof AnyFogManager> {}
-
-    type ConfiguredClass = CONFIG["Canvas"]["fogManager"];
-    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
-  }
-}
-
-declare abstract class AnyFogManager extends FogManager {
-  constructor(...args: never);
-}

package/src/foundry/client/pixi/perception/index.d.mts

@@ -1,6 +0,0 @@
-import "./clockwise-sweep.d.mts";
-import "./detection-mode.d.mts";
-import "./fog.d.mts";
-import "./perception-manager.d.mts";
-import "./vision-mode.d.mts";
-import "./weiler-atherton-clipping.d.mts";