@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.5

package/src/foundry/client-esm/canvas/edges/collision.d.mts

@@ -1,57 +1,62 @@
+import type { Identity, NullishProps } from "#utils";
+import type Edge from "./edge.d.mts";
+import type PolygonVertex from "./vertex.d.mts";
+
 /**
  * A specialized object that contains the result of a collision in the context of the ClockwiseSweepPolygon.
  * This class is not designed or intended for use outside of that context.
- * @internal
  */
 declare class CollisionResult {
-  constructor(values?: {
-    target?: foundry.canvas.edges.PolygonVertex;
-    collisions?: foundry.canvas.edges.PolygonVertex[];
-    cwEdges?: EdgeSet;
-    ccwEdges?: EdgeSet;
-    isBehind?: boolean;
-    isLimited?: boolean;
-    wasLimited?: boolean;
-  });
+  constructor({
+    target,
+    collisions,
+    cwEdges,
+    ccwEdges,
+    isBehind,
+    isLimited,
+    wasLimited,
+  }?: CollisionResult.ConstructorValues);
 
   /**
    * The vertex that was the target of this result
-   * @defaultValue `null`
    */
-  target: foundry.canvas.edges.PolygonVertex | null;
+  target: PolygonVertex;
 
   /**
    * The array of collision points which apply to this result
    * @defaultValue `[]`
    */
-  collisions: foundry.canvas.edges.PolygonVertex[];
+  collisions: PolygonVertex[];
 
   /**
    * The set of edges connected to the target vertex that continue clockwise
    * @defaultValue `new Set()`
    */
-  cwEdges: EdgeSet;
+  cwEdges: Set<Edge>;
 
   /**
    * The set of edges connected to the target vertex that continue counter-clockwise
    * @defaultValue `new Set()`
    */
-  ccwEdges: EdgeSet;
+  ccwEdges: Set<Edge>;
 
   /**
    * Is the target vertex for this result behind some closer active edge?
+   * @remarks Set directly from the constructor, so possibly was passed nullish
    */
-  isBehind: boolean | undefined;
+  isBehind: boolean | undefined | null;
 
   /**
    * Does the target vertex for this result impose a limited collision?
+   * @remarks Set directly from the constructor, so possibly was passed nullish
    */
-  isLimited: boolean | undefined;
+  isLimited: boolean | undefined | null;
 
   /**
    * Has the set of collisions for this result encountered a limited edge?
+   * @remarks Set directly from the constructor, so possibly was passed nullish
    */
-  wasLimited: boolean | undefined;
+  wasLimited: boolean | undefined | null;
 
   /**
    * Is this result limited in the clockwise direction?
@@ -90,4 +95,50 @@ declare class CollisionResult {
   blockedCCWPrev: boolean;
 }
 
+declare namespace CollisionResult {
+  interface Any extends AnyCollisionResult {}
+  interface AnyConstructor extends Identity<typeof AnyCollisionResult> {}
+
+  type _ConstructorValues = NullishProps<{
+    /**
+     * The set of edges connected to the target vertex that continue clockwise
+     * @defaultValue `new Set()`
+     */
+    cwEdges: Set<Edge>;
+
+    /**
+     * The set of edges connected to the target vertex that continue counter-clockwise
+     * @defaultValue `new Set()`
+     */
+    ccwEdges: Set<Edge>;
+
+    /** Is the target vertex for this result behind some closer active edge? */
+    isBehind: boolean;
+
+    /** Does the target vertex for this result impose a limited collision? */
+    isLimited: boolean;
+
+    /** Has the set of collisions for this result encountered a limited edge? */
+    wasLimited: boolean;
+  }>;
+
+  interface ConstructorValues extends _ConstructorValues {
+    /**
+     * The vertex that was the target of this result
+     */
+    target: PolygonVertex;
+
+    /**
+     * The array of collision points which apply to this result
+     * @defaultValue `[]`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
+    collisions?: PolygonVertex[] | undefined;
+  }
+}
+
+declare abstract class AnyCollisionResult extends CollisionResult {
+  constructor(...args: never);
+}
+
 export default CollisionResult;

package/src/foundry/client-esm/canvas/edges/edge.d.mts

@@ -1,4 +1,6 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type PolygonVertex from "./vertex.d.mts";
+import type { LineIntersection } from "../../../common/utils/geometry.d.mts";
+import type { Identity, NullishProps } from "#utils";
 import type { WallThresholdData } from "../../../common/documents/_types.d.mts";
 
 /**
@@ -12,33 +14,8 @@ declare class Edge {
    * @param b - The second endpoint of the edge
    * @param options - Additional options which describe the edge
    */
-  constructor(
-    a: Canvas.Point,
-    b: Canvas.Point,
-    options?: InexactPartial<{
-      /** A string used to uniquely identify this edge */
-      id?: string;
-      /** A PlaceableObject that is responsible for this edge, if any */
-      object?: PlaceableObject;
-      /** The type of edge */
-      type?: Edge.EdgeTypes;
-      /** How this edge restricts light */
-      light?: foundry.CONST.WALL_SENSE_TYPES;
-      /** How this edge restricts movement */
-      move?: foundry.CONST.WALL_SENSE_TYPES;
-      /** How this edge restricts sight */
-      sight?: foundry.CONST.WALL_SENSE_TYPES;
-      /** How this edge restricts sound */
-      sound?: foundry.CONST.WALL_SENSE_TYPES;
-      /**
-       * A direction of effect for the edge
-       * @defaultValue `0`
-       */
-      direction?: foundry.CONST.WALL_DIRECTIONS;
-      /** Configuration of threshold data for this edge */
-      threshold?: WallThresholdData;
-    }>,
-  );
+  // options: not null (destructured)
+  constructor(a: Canvas.Point, b: Canvas.Point, options?: Edge.ConstructorOptions);
 
   /**
    * The first endpoint of the edge.
@@ -52,11 +29,20 @@ declare class Edge {
 
   /**
    * A string used to uniquely identify this edge.
+   * @defaultValue `object?.id ?? undefined`
    */
-  id: string;
+  id: string | undefined;
 
-  object: PlaceableObject;
+  /**
+   * A PlaceableObject that is responsible for this edge, if any
+   * @remarks This property is never read by Foundry, so it being nullish won't break anything as of 12.331
+   */
+  object: PlaceableObject.Any | undefined | null;
 
+  /**
+   * The type of edge
+   * @defaultValue `"wall"`
+   */
   type: Edge.EdgeTypes;
 
   /**
@@ -66,28 +52,33 @@ declare class Edge {
 
   /**
    * How this edge restricts light.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   light: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * How this edge restricts movement.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   move: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * How this edge restricts sight.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   sight: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * How this edge restricts sound.
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
    */
   sound: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * Specialized threshold data for this edge.
+   * @remarks Foundry only accesses this in nullish-safe ways as of 12.331
    */
-  threshold: WallThresholdData;
+  threshold: WallThresholdData | undefined | null;
 
   /**
    * The endpoint of the edge which is oriented towards the top-left.
@@ -107,37 +98,38 @@ declare class Edge {
   /**
    * Record other edges which this one intersects with.
    */
-  intersections: {
-    edge: Edge;
-    intersection: foundry.utils.LineIntersection;
-  }[];
+  intersections: Edge.IntersectionEntry[];
 
   /**
    * A PolygonVertex instance.
    * Used as part of ClockwiseSweepPolygon computation.
+   * @defaultValue `undefined`
+   * @remarks Only set in {@link ClockwiseSweepPolygon._identifyVertices | `ClockwiseSweepPolygon#_identifyVertices`} (part of CSP initialization)
    */
-  vertexA: foundry.canvas.edges.PolygonVertex;
+  vertexA: PolygonVertex | undefined;
 
   /**
    * A PolygonVertex instance.
    * Used as part of ClockwiseSweepPolygon computation.
+   * @defaultValue `undefined`
+   * @remarks Only set in {@link ClockwiseSweepPolygon._identifyVertices | `ClockwiseSweepPolygon#_identifyVertices`} (part of CSP initialization)
    */
-  vertexB: foundry.canvas.edges.PolygonVertex;
+  vertexB: PolygonVertex | undefined;
 
   /**
    * Is this edge limited for a particular type?
    */
-  isLimited(type: "direction" | "light" | "move" | "sight" | "sound"): boolean;
+  isLimited(type: foundry.CONST.WALL_RESTRICTION_TYPES): boolean;
 
   /**
    * Create a copy of the Edge which can be safely mutated.
    */
-  clone(): Edge;
+  clone(): this;
 
   /**
    * Get an intersection point between this Edge and another.
    */
-  getIntersection(other: Edge): foundry.utils.LineIntersection | void;
+  getIntersection(other: Edge): LineIntersection | void;
 
   /**
    * Test whether to apply a proximity threshold to this edge.
@@ -149,7 +141,11 @@ declare class Edge {
    * @returns True if the edge has a threshold greater than 0 for the source type,
    *          and the source type is within that distance.
    */
-  applyThreshold(sourceType: string, sourceOrigin: Canvas.Point, externalRadius?: number): boolean;
+  applyThreshold(
+    sourceType: Edge.AttenuationTypes,
+    sourceOrigin: Canvas.Point,
+    externalRadius?: number | null,
+  ): boolean;
 
   /**
    * Determine the orientation of this Edge with respect to a reference point.
@@ -178,7 +174,80 @@ declare class Edge {
 }
 
 declare namespace Edge {
+  interface Any extends AnyEdge {}
+  interface AnyConstructor extends Identity<typeof AnyEdge> {}
+
+  /** @internal */
+  type _ConstructorOptions = NullishProps<{
+    /**
+     * A string used to uniquely identify this edge
+     *
+     */
+    id: string | null;
+
+    /**
+     * A PlaceableObject that is responsible for this edge, if any
+     * @remarks `Edge#object` is never read by Foundry, so this being nullish won't break anything as of 12.331
+     */
+    object: PlaceableObject.Any;
+
+    /**
+     * The type of edge
+     * @defaultValue `"wall"`
+     */
+    type: Edge.EdgeTypes;
+
+    /**
+     * How this edge restricts light
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    light: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * How this edge restricts movement
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    move: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * How this edge restricts sight
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    sight: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * How this edge restricts sound
+     * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+     */
+    sound: foundry.CONST.WALL_SENSE_TYPES;
+
+    /**
+     * A direction of effect for the edge
+     * @defaultValue `CONST.WALL_DIRECTIONS.BOTH`
+     */
+    direction: foundry.CONST.WALL_DIRECTIONS;
+
+    /**
+     * Configuration of threshold data for this edge
+     * @remarks Foundry only accesses this in nullish-safe ways as of 12.331
+     */
+    threshold: WallThresholdData;
+  }>;
+
+  interface ConstructorOptions extends _ConstructorOptions {}
+
   type EdgeTypes = "wall" | "darkness" | "innerBounds" | "outerBounds";
+
+  type AttenuationTypes = Exclude<foundry.CONST.WALL_RESTRICTION_TYPES, "move">;
+
+  interface IntersectionEntry {
+    edge: Edge;
+    intersection: LineIntersection;
+  }
+}
+
+declare abstract class AnyEdge extends Edge {
+  constructor(...args: never);
 }
 
 export default Edge;

package/src/foundry/client-esm/canvas/edges/edges.d.mts

@@ -1,3 +1,4 @@
+import type { Identity } from "../../../../utils/index.d.mts";
 import type Edge from "./edge.d.mts";
 
 /**
@@ -20,4 +21,13 @@ declare class CanvasEdges extends Map<string, Edge> {
   refresh(): void;
 }
 
+declare namespace CanvasEdges {
+  interface Any extends AnyCanvasEdges {}
+  interface AnyConstructor extends Identity<typeof AnyCanvasEdges> {}
+}
+
+declare abstract class AnyCanvasEdges extends CanvasEdges {
+  constructor(...args: never);
+}
+
 export default CanvasEdges;

package/src/foundry/client-esm/canvas/edges/vertex.d.mts

@@ -1,55 +1,71 @@
+import type { Identity, NullishProps } from "#utils";
 import type Edge from "./edge.d.mts";
 
 /**
  * A specialized point data structure used to represent vertices in the context of the ClockwiseSweepPolygon.
  * This class is not designed or intended for use outside of that context.
- * @internal
  */
 declare class PolygonVertex {
-  constructor(x: number, y: number, { distance, index }?: PolygonVertex.Options);
+  constructor(x: number, y: number, { distance, index }?: PolygonVertex.ConstructorOptions);
 
   x: number;
 
   y: number;
 
+  /** @defaultValue `PolygonVertex.getKey(this.x, this.y)` */
   key: number;
 
-  protected _distance: number | undefined;
+  /**
+   * @defaultValue `undefined`
+   * @remarks Accessed externally in {@link ClockwiseSweepPolygon._testCollision | `ClockwiseSweepPolygon#_testCollision`}
+   */
+  _distance: number | undefined | null;
 
-  protected _d2: undefined;
+  /**
+   * @defaultValue `undefined`
+   * @remarks Set to `undefined` in the constructor, otherwise only set externally in `ClockwiseSweepPolygon` methods
+   */
+  _d2: number | undefined;
 
-  protected _index: number | undefined;
+  /**
+   * @defaultValue `undefined`
+   * @remarks Accessed externally in `ClockwiseSweepPolygon` methods
+   */
+  _index: number | undefined | null;
+
+  /**
+   * Determine the sort key to use for this vertex, arranging points from north-west to south-east.
+   * @param x - The x-coordinate
+   * @param y - The y-coordinate
+   * @returns The key used to identify the vertex
+   */
+  static getKey(x: number, y: number): number;
 
   /**
    * 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;
+  edges: Set<Edge>;
 
   /**
    * The subset of edges which continue clockwise from this vertex.
    * @defaultValue `new Set()`
    */
-  cwEdges: EdgeSet;
+  cwEdges: Set<Edge>;
 
   /**
    * The subset of edges which continue counter-clockwise from this vertex.
    * @defaultValue `new Set()`
    */
-  ccwEdges: EdgeSet;
+  ccwEdges: Set<Edge>;
 
   /**
    * The set of vertices collinear to this vertex
+   * @defaultValue `new Set()`
    */
   collinearVertices: Set<PolygonVertex>;
 
-  /**
-   * The maximum restriction type of this vertex
-   * @defaultValue `null`
-   */
-  type: number | null;
-
   /**
    * Is this vertex an endpoint of one or more edges?
    */
@@ -83,17 +99,17 @@ declare class PolygonVertex {
 
   /**
    * The maximum restriction imposed by this vertex.
-   * @defaultValue `0`
-   * @remarks Possibly tied to `CONST.WALL_SENSE_TYPES`?
+   * @defaultValue `CONST.WALL_SENSE_TYPES.NONE`
+   * @remarks Actually initialized to `0` literal, but is meant as a `WALL_SENSE_TYPES`
    */
-  restriction: number;
+  restriction: foundry.CONST.WALL_SENSE_TYPES;
 
   /**
    * Record whether this PolygonVertex has been visited in the sweep
    * @defaultValue `false`
-   * @internal
+   * @remarks Foundry marked `@internal`, set externally during `ClockwiseSweepPolygon` initialization
    */
-  _visited: boolean;
+  protected _visited: boolean;
 
   /**
    * Is this vertex limited in type?
@@ -106,14 +122,17 @@ declare class PolygonVertex {
    * @param orientation - The orientation of the edge with respect to the origin
    * @param type        - The restriction type of the polygon being created
    */
-  attachEdge(edge: Edge, orientation: number, type: string): void;
+  attachEdge(edge: Edge, orientation: number, type: foundry.CONST.WALL_RESTRICTION_TYPES): void;
 
   /**
    * Is this vertex terminal (at the maximum radius)
    */
   get isTerminal(): boolean;
 
-  /**declareme point?
+  /**
+   * Is this vertex the same point as some other vertex?
+   * @param other - Some other vertex
+   * @returns Are they the same point?
    */
   equals(other: PolygonVertex): boolean;
 
@@ -123,14 +142,25 @@ declare class PolygonVertex {
    * @param options - Additional options that apply to this vertex
    * @returns The constructed vertex
    */
-  static fromPoint(point: Canvas.Point, options?: PolygonVertex.Options): PolygonVertex;
+  // options: not null (destructured when passed to `new this()`)
+  static fromPoint(point: Canvas.Point, options?: PolygonVertex.ConstructorOptions): PolygonVertex;
 }
 
 declare namespace PolygonVertex {
-  interface Options {
-    distance: PolygonVertex["_distance"];
-    index: PolygonVertex["_index"];
-  }
+  interface Any extends AnyPolygonVertex {}
+  interface AnyConstructor extends Identity<typeof AnyPolygonVertex> {}
+
+  /** @internal */
+  type _ConstructorOptions = NullishProps<{
+    distance: number;
+    index: number;
+  }>;
+
+  interface ConstructorOptions extends _ConstructorOptions {}
+}
+
+declare abstract class AnyPolygonVertex extends PolygonVertex {
+  constructor(...args: never);
 }
 
 export default PolygonVertex;

package/src/foundry/client-esm/canvas/regions/_module.d.mts

@@ -1,14 +1,9 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
-/* eslint-disable import/no-unresolved */ // TODO: Remove when the files are instantiated
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
-// This `export {}` can be removed when something is exported.
-export {};
-
-// TODO: Implement these files.
-// export { default as RegionGeometry } from "./geometry.mjs";
-// export { default as RegionMesh } from "./mesh.mjs";
-// export { default as RegionPolygonTree } from "./polygon-tree.mjs";
-// export { default as RegionShape } from "./shape.mjs";
+export { default as RegionGeometry } from "./geometry.mjs";
+export { default as RegionMesh } from "./mesh.mjs";
+export { default as RegionPolygonTree } from "./polygon-tree.mjs";
+export { default as RegionShape } from "./shape.mjs";

package/src/foundry/client-esm/canvas/regions/geometry.d.mts

@@ -0,0 +1,38 @@
+/**
+ * The geometry of a {@link Region | `Region`}.
+ * - Vertex Attribute: `aVertexPosition` (`vec2`)
+ * - Draw Mode: `PIXI.DRAW_MODES.TRIANGLES`
+ */
+declare class RegionGeometry extends PIXI.Geometry {
+  /**
+   * Create a RegionGeometry
+   * @remarks Foundry marked `@internal`
+   */
+  constructor(region: Region.Object);
+
+  /** The Region this geometry belongs to */
+  get region(): Region.Object;
+
+  /**
+   * Update the buffers
+   * @remarks Foundry marked `@internal`, is exclusively called externally in `Region##updateShapes`
+   */
+  protected _clearBuffers(): void;
+
+  /**
+   * Update the buffers
+   * @remarks Foundry marked `@internal`, is exclusively called externally in `Region##updateShapes`
+   */
+  protected _updateBuffers(): void;
+}
+
+declare namespace RegionGeometry {
+  interface Any extends AnyRegionGeometry {}
+  type AnyConstructor = typeof AnyRegionGeometry;
+}
+
+declare abstract class AnyRegionGeometry extends RegionGeometry {
+  constructor(...args: never);
+}
+
+export default RegionGeometry;

package/src/foundry/client-esm/canvas/regions/mesh.d.mts

@@ -0,0 +1,72 @@
+/** A mesh of a {@link Region | `Region`} */
+declare class RegionMesh extends PIXI.Container {
+  /**
+   * Create a RegionMesh
+   * @param region        - The Region to create the RegionMesh from.
+   * @param shaderClass   - The shader class to use. (default: `RegionShader`)
+   */
+  // shaderClass: not null (parameter default only)
+  constructor(region: Region.Object, shaderClass?: AbstractBaseShader.AnyConstructor);
+
+  /** The Region of this RegionMesh */
+  get region(): Region.Object;
+
+  /** The shader bound to this RegionMesh */
+  get shader(): AbstractBaseShader;
+
+  /** The blend mode assigned tot his RegionMesh */
+  get blendMode(): PIXI.BLEND_MODES;
+  set blendMode(value);
+
+  /**
+   * The tint applied to the mesh. This is a hex value.
+   *
+   * A value of 0xFFFFFF will remove any tint effect.
+   * @defaultValue `0xFFFFFF`
+   */
+  get tint(): number;
+  set tint(value);
+
+  /** The tint applied to the mesh. This is a hex value. A value of 0xFFFFFF will remove any tint effect. */
+  protected _tintColor: PIXI.Color;
+
+  /**
+   * Cached tint value for the shader uniforms
+   * @remarks Foundry marked `@internal`
+   */
+  protected _cachedTint: Color.RGBAColorVector;
+
+  /** Used to track a tint or alpha change to execute a recomputation of _cachedTint. */
+  protected _tintAlphaDirty: boolean;
+
+  /**
+   * Initialize shader based on the shader class type.
+   * @param shaderClass - The shader class, which must inherit from {@link AbstractBaseShader | `AbstractBaseShader`}.
+   */
+  setShaderClass(shaderClass: AbstractBaseShader.AnyConstructor): void;
+
+  override updateTransform(): void;
+
+  protected override _render(renderer: PIXI.Renderer): void;
+
+  protected override _calculateBounds(): void;
+
+  /**
+   * Tests if a point is inside this RegionMesh.
+   * @privateRemarks The rare instance of Foundry using the PIXI interface in *their* types
+   */
+  containsPoint(point: PIXI.IPointData): boolean;
+
+  override destroy(options?: PIXI.IDestroyOptions | boolean): void;
+}
+
+declare namespace RegionMesh {
+  interface Any extends AnyRegionMesh {}
+  type AnyConstructor = typeof AnyRegionMesh;
+}
+
+declare abstract class AnyRegionMesh extends RegionMesh {
+  constructor(...args: never);
+}
+
+export default RegionMesh;