@league-of-foundry-developers/foundry-vtt-types 9.268.0 → 9.269.0

package/src/foundry/client/pixi/core/shapes/polygon-helpers.d.ts

@@ -0,0 +1,263 @@
+import type { ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
+
+declare global {
+  /**
+   * An internal data structure for polygon vertices
+   * @internal
+   */
+  class PolygonVertex {
+    constructor(x: number, y: number, { distance, index }?: PolygonVertexOptions);
+
+    x: number;
+
+    y: number;
+
+    key: number;
+
+    protected _distance: number | undefined;
+
+    protected _d2: undefined;
+
+    protected _index: number | undefined;
+
+    /** @defaultValue `false` */
+    protected _inLimitedAngle: boolean;
+
+    /**
+     * The set of edges which connect to this vertex.
+     * This set is initially empty and populated later after vertices are de-duplicated.
+     * @defaultValue `new Set()`
+     */
+    edges: EdgeSet;
+
+    /**
+     * The subset of edges which continue clockwise from this vertex.
+     * @defaultValue `new Set()`
+     */
+    cwEdges: EdgeSet;
+
+    /**
+     * The subset of edges which continue counter-clockwise from this vertex.
+     * @defaultValue `new Set()`
+     */
+    ccwEdges: EdgeSet;
+
+    /**
+     * The maximum restriction type of this vertex
+     * @defaultValue `null`
+     */
+    type: number | null;
+
+    /**
+     * Associate an edge with this vertex.
+     * @param edge        - The edge being attached
+     * @param orientation - The orientation of the edge with respect to the origin
+     */
+    attachEdge(edge: PolygonEdge, orientation: number): void;
+
+    /**
+     * Is this vertex limited in type?
+     */
+    get isLimited(): boolean;
+
+    /**
+     * Is this vertex terminal (at the maximum radius)
+     */
+    get isTerminal(): boolean;
+
+    /**
+     * Does this vertex have a limited edge connected to it?
+     */
+    get hasLimitedEdge(): boolean;
+
+    /**declareme point?
+     */
+    equals(other: PolygonVertex): boolean;
+
+    /**
+     * Construct a PolygonVertex instance from some other Point structure.
+     * @param point   - The point
+     * @param options - Additional options that apply to this vertex
+     * @returns The constructed vertex
+     */
+    static fromPoint(point: Point, options?: PolygonVertexOptions): PolygonVertex;
+  }
+
+  interface PolygonVertexOptions {
+    distance: PolygonVertex['_distance'];
+    index: PolygonVertex['_index'];
+  }
+
+  /**
+   * An internal data structure for polygon edges
+   * @internal
+   */
+  class PolygonEdge {
+    constructor(a: Point, b: Point, type: foundry.CONST.WALL_SENSE_TYPES, wall: Wall);
+
+    /**
+     * Is this edge limited in type?
+     */
+    get isLimited(): boolean;
+
+    /**
+     * Construct a PolygonEdge instance from a Wall placeable object.
+     * @param wall - The Wall from which to construct an edge
+     * @param type - The type of polygon being constructed
+     */
+    static fromWall(
+      wall: ConfiguredObjectClassForName<'Wall'> | WallDocument,
+      type: foundry.CONST.WALL_RESTRICTION_TYPES
+    ): PolygonEdge;
+  }
+
+  /**
+   * An object containing the result of a collision test.
+   * @internal
+   */
+  class CollisionResult {
+    constructor(values?: {
+      target?: PolygonVertex | null;
+      collisions?: PolygonVertex[];
+      cwEdges?: EdgeSet;
+      ccwEdges?: EdgeSet;
+      isBehind?: boolean;
+      isLimited?: boolean;
+      isRequired?: boolean;
+      wasLimited?: boolean;
+    });
+
+    /**
+     * The vertex that was the target of this result
+     * @defaultValue `null`
+     */
+    target: PolygonVertex | null;
+
+    /**
+     * The array of collision points which apply to this result
+     * @defaultValue `[]`
+     */
+    collisions: PolygonVertex[];
+
+    /**
+     * The set of edges connected to the target vertex that continue clockwise
+     * @defaultValue `new Set()`
+     */
+    cwEdges: EdgeSet;
+
+    /**
+     * The set of edges connected to the target vertex that continue counter-clockwise
+     * @defaultValue `new Set()`
+     */
+    ccwEdges: EdgeSet;
+
+    /**
+     * Is the target vertex for this result behind some closer active edge?
+     */
+    isBehind: boolean | undefined;
+
+    /**
+     * Does the target vertex for this result impose a limited collision?
+     */
+    isLimited: boolean | undefined;
+
+    /**
+     * Is this result required due to a limited angle?
+     */
+    isRequired: boolean | undefined;
+
+    /**
+     * Has the set of collisions for this result encountered a limited edge?
+     */
+    wasLimited: boolean | undefined;
+  }
+
+  /**
+   * A special subclass of PIXI.Point which is used for modeling Wall endpoints.
+   * A wall endpoint must have integer coordinates.
+   *
+   * This was used for the RadialSweepPolygon but can now be deleted once that is
+   * @deprecated since v9d2
+   */
+  class WallEndpoint extends PIXI.Point {
+    /**
+     * @param x - The integer x-coordinate
+     * @param y - The integer y-coordinate
+     */
+    constructor(x: number, y: number);
+
+    /**
+     * Express the point as a 32-bit integer with 16 bits allocated to x and 16 bits allocated to y
+     */
+    key: number;
+
+    /**
+     * The angle between this point and the polygon origin
+     * @defaultValue `undefined`
+     */
+    angle: number | undefined;
+
+    /**
+     * Record the set of walls which connect to this Endpoint
+     */
+    walls: Set<ConfiguredObjectClassForName<'Wall'>>;
+
+    /**
+     * Record whether this point is the endpoint of any Wall
+     * @defaultValue `false`
+     */
+    isEndpoint: boolean;
+
+    /**
+     * Record whether this point is a midpoint of any wall?
+     * @defaultValue `false`
+     */
+    isMidpoint: boolean;
+
+    /**
+     * Record whether this point is the termination of the Ray
+     * @defaultValue `false`
+     */
+    isTerminal: boolean;
+
+    /**
+     * Aggregate the maximum of each wall restriction type
+     */
+    types: Record<foundry.CONST.WALL_RESTRICTION_TYPES, number>;
+
+    /**
+     * An intermediate variable used to store the proportional distance of this point from a SightRay origin
+     * @defaultValue `undefined`
+     */
+    protected _r: number | undefined;
+
+    /**
+     * An intermediate variable used to cache the continuation attributes for a certain point
+     * @defaultValue `undefined`
+     */
+    protected _c: { left: boolean; right: boolean } | undefined;
+
+    attachWall(wall: ConfiguredObjectClassForName<'Wall'>): this;
+
+    /**
+     * Does this endpoint equal some other endpoint?
+     * @param other - Some other point with x and y coordinates
+     * @returns Are the points equal?
+     */
+    equals(other: Point): boolean;
+
+    /**
+     * Is this point one that provides only limited perspective?
+     * @param type - The perspective type being tested
+     * @returns Is perspective limited?
+     */
+    isLimited(type: foundry.CONST.WALL_RESTRICTION_TYPES): boolean;
+
+    /**
+     * Encode a x/y coordinate as a 32-bit integer
+     * @param x - The x-coordinate
+     * @param y - The y-coordinate
+     */
+    static getKey(x: number, y: number): number;
+  }
+}

package/src/foundry/{foundry.js → client/pixi/core/shapes}/ray.d.ts

@@ -1,4 +1,4 @@
-import type { LineIntersection } from '../common/utils/geometry.mjs';
+import type { LineIntersection } from '../../../../common/utils/geometry.mjs.js';
 
 declare global {
   interface RayIntersection {
@@ -162,4 +162,39 @@ declare global {
      */
     intersectSegment(coords: [x0: number, y0: number, x1: number, y1: number]): LineIntersection | null;
   }
+
+  /**
+   * A subclass of Ray that is used specifically for computing source polygons
+   *
+   * This was used for the RadialSweepPolygon but can now be deleted once that is
+   * @deprecated since v9d2
+   */
+  class SightRay extends Ray {
+    /**
+     * The array of sorted collision points which apply for this Ray.
+     */
+    collisions: WallEndpoint[];
+
+    /**
+     * The target endpoint at which this Ray was fired
+     */
+    endpoint: WallEndpoint | null;
+
+    /**
+     * The result objects which records the outcome of this Ray
+     */
+    result: {
+      collisions: unknown[];
+      continuation: unknown | undefined;
+      limitation: number;
+      superfluous: boolean;
+      stopped: boolean;
+      activeWalls: unknown | undefined;
+    };
+
+    /**
+     * The final collision point that this SightRay encountered.
+     */
+    get lastCollision(): WallEndpoint | null;
+  }
 }

package/src/foundry/{foundry.js/pixi/polygons/pointSourcePolygon.d.ts → client/pixi/core/shapes/source-polygon.d.ts}

@@ -98,3 +98,13 @@ declare abstract class PointSourcePolygon extends PIXI.Polygon {
    */
   visualize(): void;
 }
+
+/**
+ * Compare sight performance between different algorithms
+ * @param n    - The number of iterations
+ * @param args - Arguments passed to the polygon compute function
+ */
+declare function benchmarkSight(
+  n: number,
+  ...args: Parameters<typeof ClockwiseSweepPolygon['benchmark']>
+): Promise<void>;

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

@@ -0,0 +1,3 @@
+import './effects';
+import './interface';
+import './primary';

package/src/foundry/{foundry.js/pixi/containers/cachedContainers/primaryCanvasGroup.d.ts → client/pixi/groups/primary.d.ts}

@@ -26,10 +26,9 @@ declare class PrimaryCanvasGroup extends CachedContainer {
   static groupName: string;
 
   /**
-   * @override
    * @defaultValue `[0, 0, 0, 0]`
    */
-  clearColor: [r: number, g: number, b: number, a: number];
+  override clearColor: [r: number, g: number, b: number, a: number];
 
   /**
    * Create the member layers of the scene container
@@ -37,6 +36,5 @@ declare class PrimaryCanvasGroup extends CachedContainer {
    */
   protected _createLayers(): void;
 
-  /** @override */
-  render(renderer: Parameters<PIXI.Container['render']>[0]): void;
+  override render(renderer: Parameters<PIXI.Container['render']>[0]): void;
 }

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

@@ -0,0 +1,10 @@
+import './board';
+import './core';
+import './groups';
+import './layer';
+import './layers';
+import './perception';
+import './placeables';
+import './placeables/index';
+import './sources';
+import './webgl';

package/src/foundry/{foundry.js/pixi/containers → client/pixi/layers/controls}/cursor.d.ts

@@ -1,4 +1,4 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
+import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
 
 declare global {
   /**
@@ -22,7 +22,6 @@ declare global {
      */
     protected _animate(): void;
 
-    /** @override */
-    destroy(options?: Parameters<PIXI.Container['destroy']>[0]): void;
+    override destroy(options?: Parameters<PIXI.Container['destroy']>[0]): void;
   }
 }

package/src/foundry/{foundry.js/pixi/containers/doorControl.d.ts → client/pixi/layers/controls/door.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredDocumentClassForName, ConfiguredObjectClassForName } from '../../../../types/helperTypes';
+import type { ConfiguredDocumentClassForName, ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
 
 declare global {
   /**

package/src/foundry/{foundry.js/pixi/containers/objectHUD.d.ts → client/pixi/layers/controls/hud.d.ts}

@@ -1,3 +1,40 @@
+/**
+ * An extension of PIXI.Transform.
+ * This uses a different DisplayObject than the current parent as the reference for the worldTransform.
+ */
+declare class SynchronizedTransform extends PIXI.Transform {
+  constructor(transform: PIXI.Transform);
+
+  /**
+   * A list of attributes from the transform reference which should be synchronized
+   * @defaultValue
+   * ```javascript
+   * [
+   *   "localTransform", "position", "scale", "pivot", "skew", "_rotation",
+   *   "_cx", "_sx", "_cy", "_sy", "_localID", "_currentLocalID"
+   * ];
+   * ```
+   */
+  static synchronizedAttributes: string[];
+
+  /**
+   * A Transform instance which defines the reference point for the worldTransform
+   */
+  get reference(): PIXI.Transform;
+
+  set reference(value: PIXI.Transform);
+
+  /** @internal */
+  protected _reference: PIXI.Transform;
+
+  /** @internal */
+  protected _syncLocalID: number;
+
+  override updateTransform(parentTransform: PIXI.Transform): void;
+
+  override updateLocalTransform(): void;
+}
+
 /**
  * An extension of PIXI.Container used as the interface frame for a PlaceableObject on the ControlsLayer
  *
@@ -17,15 +54,13 @@ declare class ObjectHUD extends PIXI.Container {
    */
   transform: PIXI.Transform;
 
-  /** @override */
   // @ts-expect-error this is a property in `PIXI.Container` but foundry overrides it as an accessor.
-  get visible(): boolean;
-  set visible(value: boolean);
+  override get visible(): boolean;
+  override set visible(value: boolean);
 
-  /** @override */
   // @ts-expect-error this is a property in `PIXI.Container` but foundry overrides it as an accessor.
-  get renderable(): boolean;
-  set renderable(value: boolean);
+  override get renderable(): boolean;
+  override set renderable(value: boolean);
 
   /**
    * Display scrolling status text originating from this ObjectHUD container.

package/src/foundry/client/pixi/layers/controls/index.d.ts

@@ -0,0 +1,4 @@
+import './cursor';
+import './door';
+import './hud';
+import './ruler';

package/src/foundry/{foundry.js/pixi/containers → client/pixi/layers/controls}/ruler.d.ts

@@ -1,4 +1,4 @@
-import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../types/helperTypes';
+import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
 
 declare global {
   interface RulerData {

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/controlsLayer.d.ts → client/pixi/layers/controls.d.ts}

@@ -1,4 +1,4 @@
-import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
 
 declare global {
   /**
@@ -63,7 +63,6 @@ declare global {
     protected _rulers: Record<string, Ruler>;
 
     /**
-     * @override
      * @defaultValue
      * ```typescript
      * foundry.utils.mergeObject(super.layerOptions, {
@@ -72,7 +71,7 @@ declare global {
      * })
      * ```
      */
-    static get layerOptions(): ControlsLayer.LayerOptions;
+    static override get layerOptions(): ControlsLayer.LayerOptions;
 
     /**
      * A convenience accessor to the Ruler for the active game user
@@ -84,14 +83,12 @@ declare global {
      */
     getRulerForUser(userId: string): Ruler | null;
 
-    /** @override */
-    draw(): Promise<this>;
+    override draw(): Promise<this>;
 
     /**
-     * @override
      * @remarks This breaks polymorphism. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6939
      */
-    tearDown(): Promise<void>;
+    override tearDown(): Promise<void>;
 
     /**
      * Draw the cursors container
@@ -109,8 +106,7 @@ declare global {
      */
     drawSelect({ x, y, width, height }: { x: number; y: number; width: number; height: number }): void;
 
-    /** @override */
-    deactivate(): void;
+    override deactivate(): void;
 
     /**
      * Handle mousemove events on the game canvas to broadcast activity of the user's cursor position

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

@@ -9,7 +9,6 @@ declare class DrawingsLayer extends PlaceablesLayer<'Drawing', DrawingsLayer.Lay
   static get instance(): Canvas['drawings'];
 
   /**
-   * @override
    * @defaultValue
    * ```
    * mergeObject(super.layerOptions, {
@@ -21,10 +20,9 @@ declare class DrawingsLayer extends PlaceablesLayer<'Drawing', DrawingsLayer.Lay
    * })
    * ```
    */
-  static get layerOptions(): DrawingsLayer.LayerOptions;
+  static override get layerOptions(): DrawingsLayer.LayerOptions;
 
-  /** @override */
-  static documentName: 'Drawing';
+  static override documentName: 'Drawing';
 
   /**
    * The named game setting which persists default drawing configuration for the User
@@ -36,8 +34,7 @@ declare class DrawingsLayer extends PlaceablesLayer<'Drawing', DrawingsLayer.Lay
    */
   get gridPrecision(): 0 | 8 | 16;
 
-  /** @override */
-  get hud(): Exclude<Canvas['hud'], null>['drawing'];
+  override get hud(): Exclude<Canvas['hud'], null>['drawing'];
 
   /**
    * Render a configuration sheet to configure the default Drawing settings
@@ -59,28 +56,22 @@ declare class DrawingsLayer extends PlaceablesLayer<'Drawing', DrawingsLayer.Lay
    */
   _getNewDrawingData(origin: Point | {}): NewDrawingData;
 
-  /** @override */
-  protected _onClickLeft(event: PIXI.InteractionEvent): void;
+  protected override _onClickLeft(event: PIXI.InteractionEvent): void;
 
-  /** @override */
-  protected _onClickLeft2(event: PIXI.InteractionEvent): void | Promise<void>;
+  protected override _onClickLeft2(event: PIXI.InteractionEvent): void | Promise<void>;
 
-  /** @override */
-  protected _onDragLeftStart(event: PIXI.InteractionEvent): ReturnType<Drawing['draw']>;
+  protected override _onDragLeftStart(event: PIXI.InteractionEvent): ReturnType<Drawing['draw']>;
 
-  /** @override */
-  protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+  protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
   /**
    * Handling of mouse-up events which conclude a new object creation after dragging
    */
   protected _onDragLeftDrop(event: PIXI.InteractionEvent): Promise<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;
 }
 
 declare namespace DrawingsLayer {

package/src/foundry/client/pixi/layers/effects/index.d.ts

@@ -0,0 +1,4 @@
+import './effect';
+import './leaves';
+import './rain';
+import './snow';

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/weatherLayer.d.ts → client/pixi/layers/effects.d.ts}

@@ -42,11 +42,9 @@ declare class WeatherLayer extends CanvasLayer<WeatherLayer.LayerOptions> {
    */
   static get layerOptions(): WeatherLayer.LayerOptions;
 
-  /** @override */
-  tearDown(): Promise<this>;
+  override tearDown(): Promise<this>;
 
-  /** @override */
-  draw(): Promise<undefined>;
+  override draw(): Promise<undefined>;
 
   /**
    * Draw the weather container.

package/src/foundry/{foundry.js/pixi/containers/baseGrids/hexagonalGrid.d.ts → client/pixi/layers/grid/hex.d.ts}

@@ -27,8 +27,7 @@ declare class HexagonalGrid extends BaseGrid {
    */
   get hexPoints(): PointArray[];
 
-  /** @override */
-  draw(preview?: BaseGrid.Preview | undefined): this;
+  override draw(preview?: BaseGrid.Preview | undefined): this;
 
   /**
    * A convenience method for getting all the polygon points relative to a top-left [x,y] coordinate pair
@@ -62,35 +61,28 @@ declare class HexagonalGrid extends BaseGrid {
    */
   getGridPositionFromPixels(x: number, y: number, method?: 'floor' | 'ceil' | 'round'): PointArray;
 
-  /** @override */
-  getPixelsFromGridPosition(row: number, col: number): PointArray;
+  override getPixelsFromGridPosition(row: number, col: number): PointArray;
 
-  /** @override */
-  getCenter(x: number, y: number): PointArray;
+  override getCenter(x: number, y: number): PointArray;
 
   /**
-   * @override
    * @param interval - (default: `1`)
    */
-  getSnappedPosition(x: number, y: number, interval?: number | null): { x: number; y: number };
+  override getSnappedPosition(x: number, y: number, interval?: number | null): { x: number; y: number };
 
   /** @internal */
   protected _getClosestVertex(xc: number, yc: number, ox: number, oy: number): { x: number; y: number };
 
-  /** @override */
-  shiftPosition(x: number, y: number, dx: number, dy: number): PointArray;
+  override shiftPosition(x: number, y: number, dx: number, dy: number): PointArray;
 
   /**
-   * @override
    * @param options - (default: `{}`)
    */
-  highlightGridPosition(layer: GridHighlight, options?: BaseGrid.HighlightGridPositionOptions): void;
+  override highlightGridPosition(layer: GridHighlight, options?: BaseGrid.HighlightGridPositionOptions): void;
 
-  /** @override */
-  getNeighbors(row: number, col: number): PointArray[];
+  override getNeighbors(row: number, col: number): PointArray[];
 
-  /** @override */
-  measureDistances(segments: GridLayer.Segment[], options?: MeasureDistancesOptions): number[];
+  override measureDistances(segments: GridLayer.Segment[], options?: MeasureDistancesOptions): number[];
 
   /**
    * Convert an offset coordinate (row, col) into a cube coordinate (q, r, s).

package/src/foundry/{foundry.js/pixi/graphics/gridHighlight.d.ts → client/pixi/layers/grid/highlight.d.ts}

@@ -22,9 +22,7 @@ declare class GridHighlight extends PIXI.Graphics {
    */
   highlight(x: number, y: number): boolean;
 
-  /** @override */
-  clear(): this;
+  override clear(): this;
 
-  /** @override */
-  destroy(...args: Parameters<PIXI.Graphics['destroy']>): void;
+  override destroy(...args: Parameters<PIXI.Graphics['destroy']>): void;
 }