@league-of-foundry-developers/foundry-vtt-types 9.255.3 → 9.268.2

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/wallsLayer.d.ts → client/pixi/layers/walls.d.ts}

@@ -1,5 +1,5 @@
-import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../../../types/helperTypes';
-import { PasteOptions } from '../placeablesLayer';
+import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../types/helperTypes';
+import { PasteOptions } from '../placeables';
 
 declare global {
   /**
@@ -11,17 +11,16 @@ declare global {
     constructor();
 
     /**
-     * A graphics layer used to display chained Wall selection
-     * @defaultValue `null`
+     * An array of Wall objects which represent the boundaries of the canvas.
+     * @defaultValue `new Set()`
      */
-    chain: PIXI.Graphics | null;
+    boundaries: Set<Wall>;
 
     /**
-     * An array of all the unique perception-blocking endpoints which are present in the layer
-     * We keep this array cached for faster sight polygon computations
-     * @defaultValue `[]`
+     * A graphics layer used to display chained Wall selection
+     * @defaultValue `null`
      */
-    endpoints: PointArray[];
+    chain: PIXI.Graphics | null;
 
     /**
      * Track whether we are currently within a chained placement workflow
@@ -47,13 +46,11 @@ declare global {
      * @defaultValue
      * ```
      * {
-     *   id: null,
      *   point: null,
      * }
      * ```
      */
     protected last: {
-      id: string | null;
       point: PointArray | null;
     };
 
@@ -63,24 +60,19 @@ declare global {
     static get instance(): Canvas['walls'];
 
     /**
-     * @override
      * @defaultValue
      * ```
      * mergeObject(super.layerOptions, {
      *  name: "walls"
      *  controllableObjects: true,
-     *  objectClass: Wall,
-     *  quadtree: true,
-     *  sheetClass: WallConfig,
      *  sortActiveTop: true,
      *  zIndex: 40
      * })
      * ```
      */
-    static get layerOptions(): WallsLayer.LayerOptions;
+    static override get layerOptions(): WallsLayer.LayerOptions;
 
-    /** @override */
-    static documentName: 'Wall';
+    static override documentName: 'Wall';
 
     /**
      * An Array of Wall instances in the current Scene which act as Doors.
@@ -93,13 +85,9 @@ declare global {
      */
     get gridPrecision(): number;
 
-    /**
-     * @override
-     */
-    draw(): Promise<this>;
+    override draw(): Promise<this>;
 
-    /** @override */
-    deactivate(): this;
+    override deactivate(): this;
 
     /**
      * Perform initialization steps for the WallsLayer whenever the composition of walls in the Scene is changed.
@@ -107,6 +95,12 @@ declare global {
      */
     initialize(): void;
 
+    /**
+     * Initialization to identify all intersections between walls.
+     * These intersections are cached and used later when computing point source polygons.
+     */
+    identifyWallIntersections(): void;
+
     /**
      * Identify walls which are treated as "interior" because they are contained fully within a roof tile.
      */
@@ -120,31 +114,21 @@ declare global {
      */
     static getClosestEndpoint(point: Point, wall: InstanceType<ConfiguredObjectClassForName<'Wall'>>): PointArray;
 
-    /**
-     * Given an array of Wall instances, identify the unique endpoints across all walls.
-     * @param walls   - An array of Wall instances
-     * @param options - Additional options which modify the set of endpoints identified
-     *                  (defaultValue: `{}`)
-     * @returns An array of endpoints
-     */
-    static getUniqueEndpoints(
-      walls:
-        | InstanceType<ConfiguredObjectClassForName<'Wall'>>[]
-        | Set<InstanceType<ConfiguredObjectClassForName<'Wall'>>>,
-      options?: EndpointOptions
-    ): PointArray[];
-
     /**
      * Test whether movement along a given Ray collides with a Wall.
      * @param ray     - The attempted movement
      * @param options - Options which customize how collision is tested
-     * @returns Does a collision occur?
+     * @returns False if there are no Walls
+     *          True if the Ray is outside the Canvas
+     *          Whether any collision occurred if mode is "any"
+     *          An array of collisions, if mode is "all"
+     *          The closest collision, if mode is "closest"
      */
-    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'all' }): boolean | RayIntersection[];
-    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'closest' }): boolean | RayIntersection | null;
+    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'all' }): boolean | PolygonVertex[];
+    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'closest' }): boolean | PolygonVertex;
     checkCollision(ray: Ray, options: CollisionOptions & { mode: 'any' }): boolean;
     checkCollision(ray: Ray, options: Omit<CollisionOptions, 'mode'>): boolean;
-    checkCollision(ray: Ray, options: CollisionOptions): boolean | RayIntersection | null;
+    checkCollision(ray: Ray, options: CollisionOptions): boolean | PolygonVertex;
     checkCollision(ray: Ray, options?: CollisionOptions): boolean;
 
     /**
@@ -152,18 +136,19 @@ declare global {
      */
     highlightControlledSegments(): void;
 
-    /** @override */
-    releaseAll(options?: PlaceableObject.ReleaseOptions): number;
+    override releaseAll(options?: PlaceableObject.ReleaseOptions): number;
 
-    /**
-     * @override
-     * @param options - (unused)
-     */
-    pasteObjects(
+    override pasteObjects(
       position: Point,
       options?: PasteOptions
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseWall>>[]>;
 
+    /**
+     * Create temporary WallDocument instances which represent the rectangular boundaries of the canvas.
+     * @internal
+     */
+    protected _createBoundaries(): void;
+
     /**
      * Pan the canvas view when the cursor position gets close to the edge of the frame
      * @param event - The originating mouse movement event
@@ -189,53 +174,32 @@ declare global {
      */
     protected _getWallDataFromActiveTool(tool: string):
       | {
-          move: foundry.CONST.WALL_MOVEMENT_TYPES;
-          sense: foundry.CONST.WALL_SENSE_TYPES;
+          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'];
 
-    /** @override */
-    protected _onDragLeftStart(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftStart(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftDrop(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftDrop(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftCancel(event: PointerEvent): void;
+    protected override _onDragLeftCancel(event: PointerEvent): void;
 
-    /** @override */
-    protected _onClickRight(event: PIXI.InteractionEvent): void;
+    protected override _onClickRight(event: PIXI.InteractionEvent): void;
 
-    /**
-     * Compute source polygons of a requested type for a given origin position and maximum radius.
-     * This method returns two polygons, one which is unrestricted by the provided radius, and one that is constrained
-     * by the maximum radius.
-     *
-     * @param origin  - An point with coordinates x and y representing the origin of the test
-     * @param radius  - A distance in canvas pixels which reflects the visible range
-     * @param options - Additional options which modify the sight computation
-     *                  (default: `{}`)
-     * @returns The computed rays and polygons
-     */
+    /** @deprecated since v9 */
     computePolygon(
       origin: Point,
       radius: number,
       options?: ComputePolygonOptions
     ): { rays: Ray[]; los: PIXI.Polygon; fov: PIXI.Polygon };
 
-    /**
-     * Get the set of wall collisions for a given Ray
-     * @param ray     - The Ray being tested
-     * @param options - Options which customize how collision is tested
-     *                  (default: `{}`)
-     * @returns An array of collisions, if mode is "all"
-     *          The closest collision, if mode is "closest"
-     *          Whether any collision occurred if mode is "any"
-     */
+    /** @deprecated since v9 */
     getRayCollisions(ray: Ray, options: RayCollisionsOptions & { mode: 'all' }): RayIntersection[];
     getRayCollisions(ray: Ray, options: RayCollisionsOptions & { mode: 'closest' }): RayIntersection | null;
     getRayCollisions(ray: Ray, options: RayCollisionsOptions & { mode: 'any' }): boolean;
@@ -243,77 +207,26 @@ declare global {
     getRayCollisions(ray: Ray, options?: RayCollisionsOptions): RayIntersection[] | RayIntersection | boolean | null;
 
     /**
-     * A helper method responsible for casting rays at wall endpoints.
-     * Rays are restricted by limiting angles.
-     *
-     * @param x          - The origin x-coordinate
-     * @param y          - The origin y-coordinate
-     * @param distance   - The ray distance
-     * @param density    - The desired radial density
-     *                     (default: `4`)
-     * @param endpoints  - An array of endpoints to target
-     * @param limitAngle - Whether the rays should be cast subject to a limited angle of emission
-     *                     (default: `false`)
-     * @param aMin       - The minimum bounding angle
-     * @param aMax       - The maximum bounding angle
-     *
-     * @returns An array of Ray objects
-     */
-    static castRays(
-      x: number,
-      y: number,
-      distance: number,
-      {
-        density,
-        endpoints,
-        limitAngle,
-        aMin,
-        aMax
-      }?: { density?: number; endpoints?: PointArray[]; limitAngle?: boolean; aMin?: number; aMax?: number }
-    ): Ray[];
-
-    /**
-     * Test a single Ray against a single Wall
-     * @param ray  - The Ray being tested
-     * @param wall - The Wall against which to test
-     * @returns A RayIntersection if a collision occurred, or null
-     */
-    static testWall(ray: Ray, wall: InstanceType<ConfiguredObjectClassForName<'Wall'>>): RayIntersection | null;
-
-    /**
-     * Identify the closest collision point from an array of collisions
-     * @param collisions - An array of intersection points
-     * @returns The closest blocking intersection or null if no collision occurred
-     */
-    static getClosestCollision(collisions: RayIntersection[]): RayIntersection | null;
-
-    /**
-     * Normalize an angle to ensure it is baselined to be the smallest angle that is greater than a minimum.
-     * @param aMin  - The lower-bound minimum angle
-     * @param angle - The angle to adjust
-     * @returns The adjusted angle which is greater than or equal to aMin.
-     */
-    protected static _normalizeAngle(aMin: number, angle: number): number;
-
-    /**
-     * Map source types to wall collision types
-     * @param type - The source polygon type
-     * @returns The wall collision attribute
-     */
-    protected static _mapCollisionType(type: 'movement'): 'move';
-    protected static _mapCollisionType(type: 'light'): 'sense';
-    protected static _mapCollisionType(type: 'sight'): 'sense';
-    protected static _mapCollisionType(type: 'sound'): 'sound';
-
-    /**
-     * @deprecated since 0.8.0
+     * An array of all the unique perception-blocking endpoints which are present in the layer
+     * We keep this array cached for faster sight polygon computations
+     * @deprecated since v9
      */
-    get blockVision(): InstanceType<ConfiguredObjectClassForName<'Wall'>>[];
+    get endpoints(): PointArray[];
 
     /**
-     * @deprecated since 0.8.0
+     * Given an array of Wall instances, identify the unique endpoints across all walls.
+     * @param walls   - An array of Wall instances
+     * @param options - Additional options which modify the set of endpoints identified
+     *                  (defaultValue: `{}`)
+     * @returns An array of endpoints
+     * @deprecated since v9
      */
-    get blockMovement(): InstanceType<ConfiguredObjectClassForName<'Wall'>>[];
+    static getUniqueEndpoints(
+      walls:
+        | InstanceType<ConfiguredObjectClassForName<'Wall'>>[]
+        | Set<InstanceType<ConfiguredObjectClassForName<'Wall'>>>,
+      options?: EndpointOptions
+    ): PointArray[];
   }
 
   namespace WallsLayer {
@@ -345,9 +258,9 @@ interface EndpointOptions {
 interface CollisionOptions {
   /**
    * Which collision type to check: movement, sight, sound
-   * @defaultValue `'movement'`
+   * @defaultValue `'move'`
    */
-  type?: 'movement' | 'sight' | 'sound';
+  type?: 'move' | 'sight' | 'sound';
 
   /**
    * Which type of collisions are returned: any, closest, all

package/src/foundry/{foundry.js/pixi/polygons/pointSourcePolygons/clockwiseSweepPolygon.d.ts → client/pixi/perception/clockwise-sweep.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   type VertexMap = Map<number, PolygonVertex>;
@@ -114,14 +114,12 @@ declare global {
     ): ReturnType<ClockwiseSweepPolygon['compute']>;
 
     /**
-     * @override
      * @param origin - The provided polygon origin
      * @param config - The provided configuration object
      */
-    initialize(origin: Point, config: ClockwiseSweepPolygon.InitConfig): void;
+    override initialize(origin: Point, config: ClockwiseSweepPolygon.InitConfig): void;
 
-    /** @override */
-    protected _compute(): void;
+    protected override _compute(): void;
 
     /**
      * Round vertices of a ray segment
@@ -191,7 +189,6 @@ declare global {
     /**
      * Test whether a target vertex is behind some closer active edge
      * @param ray         - The ray being evaluated
-     *                      (unused)
      * @param vertex      - The target vertex
      * @param activeEdges - The set of active edges
      * @returns Is the target vertex behind some closer edge?
@@ -344,8 +341,7 @@ declare global {
      */
     static pointBetweenRays(vertex: PolygonVertex, rMin: PolygonRay, rMax: PolygonRay, angle: number): boolean;
 
-    /** @override */
-    visualize(): void;
+    override visualize(): void;
 
     /**
      * Check whether a given ray intersects with walls.

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

@@ -0,0 +1,2 @@
+import './clockwise-sweep';
+import './perception-manager';

package/src/foundry/{foundry.js/pixi/containers/placeableObject.d.ts → client/pixi/placeable.d.ts}

@@ -1,6 +1,6 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-import { Document } from '../../../common/abstract/module.mjs';
+import { ConfiguredDocumentClass } from '../../../types/helperTypes';
+import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
+import { Document } from '../../common/abstract/module.mjs';
 
 declare global {
   /**
@@ -124,59 +124,46 @@ declare global {
 
     /**
      * Can the User access the HUD for this Placeable Object?
-     * @param user  - (unused)
-     * @param event - (unused)
      */
     protected _canHUD(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to configure the Placeable Object?
-     * @param user  - (unused)
-     * @param event - (unused)
      */
     protected _canConfigure(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to control the Placeable Object?
-     * @param user  - (unused)
-     * @param event - (unused)
      */
     protected _canControl(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to view details of the Placeable Object?
-     * @param user  - (unused)
-     * @param event - (unused)
      */
     protected _canView(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to create the underlying Document?
-     * @param event - (unused)
      */
     protected _canCreate(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to drag this Placeable Object?
-     * @param event - (unused)
      */
     protected _canDrag(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to hover on this Placeable Object?
-     * @param event - (unused)
      */
     protected _canHover(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to update the underlying Document?
-     * @param event - (unused)
      */
     protected _canUpdate(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /**
      * Does the User have permission to delete the underlying Document?
-     * @param event - (unused)
      */
     protected _canDelete(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
@@ -195,8 +182,7 @@ declare global {
      */
     clone(): this;
 
-    /** @override */
-    destroy(options?: Parameters<PIXI.Container['destroy']>[0]): void;
+    override destroy(options?: Parameters<PIXI.Container['destroy']>[0]): void;
 
     /**
      * Draw the placeable object into its parent container
@@ -213,17 +199,11 @@ declare global {
 
     /**
      * Register pending canvas operations which should occur after a new PlaceableObject of this type is created
-     * @param data    - (unused)
-     * @param options - (unused)
-     * @param userId  - (unused)
-     * @remarks Second variant has been added because of `Token._onCreate()`
      */
     protected _onCreate(data: D['data']['_source'], options: DocumentModificationOptions, userId: string): void;
 
     /**
      * Define additional steps taken when an existing placeable object of this type is updated with new data
-     * @param options - (unused)
-     * @param userId  - (unused)
      * @remarks Called without options and userId in Drowing._onUpdate
      */
     protected _onUpdate(
@@ -234,8 +214,6 @@ declare global {
 
     /**
      * Define additional steps taken when an existing placeable object of this type is deleted
-     * @param options - (unused)
-     * @param userId  - (unused)
      */
     protected _onDelete(options: DocumentModificationOptions, userId: string): void;
 
@@ -250,7 +228,6 @@ declare global {
     /**
      * Additional events which trigger once control of the object is established
      * @param options - Optional parameters which apply for specific implementations
-     *                  (unused)
      */
     protected _onControl(options?: PlaceableObject.ControlOptions): void;
 
@@ -265,7 +242,6 @@ declare global {
     /**
      * Additional events which trigger once control of the object is released
      * @param options - Options which modify the releasing workflow
-     *                  (unused)
      */
     protected _onRelease(options?: PlaceableObject.ReleaseOptions): void;
 

package/src/foundry/{foundry.js/pixi/containers/placeableObjects → client/pixi/placeables}/drawing.d.ts

@@ -1,5 +1,5 @@
-import { ConfiguredDocumentClass, ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
+import { ConfiguredDocumentClass, ConfiguredDocumentClassForName } from '../../../../types/helperTypes';
+import { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
 
 declare global {
   /**
@@ -57,8 +57,7 @@ declare global {
      */
     protected _fixedPoints: Array<[x: number, y: number]>;
 
-    /** @override */
-    static embeddedName: 'Drawing';
+    static override embeddedName: 'Drawing';
 
     /**
      * The rate at which points are sampled (in milliseconds) during a freehand drawing workflow
@@ -66,8 +65,7 @@ declare global {
      */
     static FREEHAND_SAMPLE_RATE: number;
 
-    /** @override */
-    get bounds(): Rectangle;
+    override get bounds(): Rectangle;
 
     /**
      * A Boolean flag for whether or not the Drawing utilizes a tiled texture background
@@ -79,8 +77,7 @@ declare global {
      */
     get isPolygon(): boolean;
 
-    /** @override */
-    draw(): Promise<this>;
+    override draw(): Promise<this>;
 
     /**
      * Clean the drawing data to constrain its allowed position
@@ -105,8 +102,7 @@ declare global {
      */
     protected _createFrame(): void;
 
-    /** @override */
-    refresh(): void;
+    override refresh(): void;
 
     /**
      * Draw rectangular shapes
@@ -176,14 +172,11 @@ declare global {
      */
     protected _removePoint(): void;
 
-    /** @override */
-    protected _onControl(options: PlaceableObject.ControlOptions & { isNew?: boolean }): void;
+    protected override _onControl(options: PlaceableObject.ControlOptions & { isNew?: boolean }): void;
 
-    /** @override */
-    protected _onRelease(options: PlaceableObject.ReleaseOptions): void;
+    protected override _onRelease(options: PlaceableObject.ReleaseOptions): void;
 
-    /** @override */
-    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
+    protected override _onDelete(options: DocumentModificationOptions, userId: string): void;
 
     /**
      * Handle text entry in an active text tool
@@ -191,24 +184,20 @@ declare global {
      */
     protected _onDrawingTextKeydown(event: KeyboardEvent): void;
 
-    /** @override */
-    protected _onUpdate(data: DeepPartial<foundry.data.DrawingData['_source']>): void;
+    protected override _onUpdate(data: DeepPartial<foundry.data.DrawingData['_source']>): void;
 
     /**
-     * @override
      * @param event - unused
      */
-    protected _canControl(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
+    protected override _canControl(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
     /**
-     * @override
      * @param user  - unused
      * @param event - unused
      */
-    protected _canConfigure(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
+    protected override _canConfigure(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
-    /** @override */
-    activateListeners(): void;
+    override activateListeners(): void;
 
     /**
      * Handle mouse movement which modifies the dimensions of the drawn shape
@@ -216,17 +205,13 @@ declare global {
      */
     protected _onMouseDraw(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftStart(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftStart(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftDrop(event: PIXI.InteractionEvent): Promise<unknown>;
+    protected override _onDragLeftDrop(event: PIXI.InteractionEvent): Promise<unknown>;
 
-    /** @override */
-    protected _onDragLeftCancel(event: MouseEvent): void;
+    protected override _onDragLeftCancel(event: MouseEvent): void;
 
     /**
      * Handle mouse-over event on a control handle

package/src/foundry/{foundry.js/pixi/containers/placeableObjects → client/pixi/placeables}/index.d.ts

@@ -1,8 +1,8 @@
-import './ambientLight';
-import './ambientSound';
 import './drawing';
-import './measuredTemplate';
+import './light';
 import './note';
+import './sound';
+import './template';
 import './tile';
 import './token';
 import './wall';