@league-of-foundry-developers/foundry-vtt-types 12.331.2-beta → 13.340.0

package/src/foundry/client-esm/audio/timeout.d.mts

@@ -51,7 +51,7 @@ declare class AudioTimeout<CallbackReturn = unknown> {
    * @param delayMS - A desired delay timing in milliseconds
    * @param options - Additional options which modify timeout behavior
    */
-  constructor(delayMS: number, options?: AudioTimeout.Options<CallbackReturn>)
+  constructor(delayMS: number, options?: AudioTimeout.Options<CallbackReturn>);
 
   /**
    * Is the timeout complete?
@@ -76,7 +76,10 @@ declare class AudioTimeout<CallbackReturn = unknown> {
    * @param options - Additional options which modify timeout behavior
    * @returns A promise which resolves as a returned value of the callback or void
    */
-  static wait<CallbackReturn = unknown>(delayMS: number, options?: AudioTimeout.Options<CallbackReturn>): Promise<CallbackReturn>;
+  static wait<CallbackReturn = unknown>(
+    delayMS: number,
+    options?: AudioTimeout.Options<CallbackReturn>,
+  ): Promise<CallbackReturn>;
 }
 
 export default AudioTimeout;

package/src/foundry/client-esm/av/_module.d.mts

@@ -0,0 +1,10 @@
+// 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-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export * as clients from "./clients/_module.mjs";
+
+export { default as AVClient } from "./client.mjs";
+export { default as AVMaster } from "./master.mjs";
+export { default as AVSettings } from "./settings.mjs";

package/src/foundry/client-esm/av/client.d.mts

@@ -0,0 +1,18 @@
+import type AVMaster from "./master.d.mts";
+import type AVSettings from "./settings.d.mts";
+
+/**
+ * An interface for an Audio/Video client which is extended to provide broadcasting functionality.
+ * @remarks TODO: Stub
+ */
+declare class AVClient {
+  /**
+   * @param master   - The master orchestration instance
+   * @param settings - The audio/video settings being used
+   */
+  constructor(master: AVMaster, settings: AVSettings);
+}
+
+declare namespace AVClient {}
+
+export default AVClient;

package/src/foundry/client-esm/av/clients/_module.d.mts

@@ -0,0 +1,6 @@
+// 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-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export { default as SimplePeerAVClient } from "./simplepeer.mjs";

package/src/foundry/client-esm/av/clients/simplepeer.d.mts

@@ -0,0 +1,11 @@
+import type AVClient from "../client.d.mts";
+
+/**
+ * An implementation of the AVClient which uses the simple-peer library and the Foundry socket server for signaling.
+ * Credit to bekit#4213 for identifying simple-peer as a viable technology and providing a POC implementation.
+ */
+declare class SimplePeerAVClient extends AVClient {}
+
+declare namespace SimplePeerAVClient {}
+
+export default SimplePeerAVClient;

package/src/foundry/client-esm/av/master.d.mts

@@ -0,0 +1,12 @@
+/**
+ * The master Audio/Video controller instance.
+ * This is available as the singleton game.webrtc
+ * @remarks TODO: Stub
+ */
+declare class AVMaster {
+  constructor();
+}
+
+declare namespace AVMaster {}
+
+export default AVMaster;

package/src/foundry/client-esm/av/settings.d.mts

@@ -0,0 +1,30 @@
+/**
+ * @remarks TODO: Stub
+ */
+declare class AVSettings {
+  constructor();
+}
+
+declare namespace AVSettings {
+  interface Data {
+    /**
+     * Whether this user has muted themselves.
+     * @remarks non-nullish due to use of `in`
+     */
+    muted?: boolean;
+
+    /**
+     * Whether this user has hidden their video.
+     * @remarks non-nullish due to use of `in`
+     */
+    hidden?: boolean;
+
+    /**
+     * Whether the user is broadcasting audio.
+     * @remarks non-nullish due to use of `in`
+     */
+    speaking?: boolean;
+  }
+}
+
+export default AVSettings;

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

@@ -1,7 +1,7 @@
 // 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 */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export { default as SceneManager } from "./scene-manager.mjs";
 export { default as SMAAFilter } from "./smaa/smaa.mjs";

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

@@ -1,7 +1,7 @@
 // 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 */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export { default as CanvasEdges } from "./edges.mjs";
 export { default as CollisionResult } from "./collision.mjs";

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

@@ -1,57 +1,54 @@
+import type { NullishProps } from "../../../../utils/index.d.mts";
+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(values?: 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 +87,50 @@ declare class CollisionResult {
   blockedCCWPrev: boolean;
 }
 
+declare namespace CollisionResult {
+  interface Any extends AnyCollisionResult {}
+  type AnyConstructor = 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(arg0: never, ...args: never[]);
+}
+
 export default CollisionResult;

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

@@ -1,5 +1,7 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
-import type { WallThresholdData } from "../../../common/documents/_types.d.mts";
+import type PolygonVertex from "./vertex.d.mts";
+import type { LineIntersection } from "@common/utils/geometry.d.mts";
+import type { NullishProps } from "fvtt-types/utils";
+import type { WallThresholdData } from "@common/documents/_types.d.mts";
 
 /**
  * A data structure used to represent potential edges used by the ClockwiseSweepPolygon.
@@ -12,33 +14,7 @@ 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;
-    }>,
-  );
+  constructor(a: Canvas.Point, b: Canvas.Point, options?: Edge.ConstructorOptions);
 
   /**
    * The first endpoint of the edge.
@@ -52,11 +28,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 +51,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 +97,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} (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} (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 +140,7 @@ 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): boolean;
 
   /**
    * Determine the orientation of this Edge with respect to a reference point.
@@ -178,7 +169,80 @@ declare class Edge {
 }
 
 declare namespace Edge {
+  interface Any extends AnyEdge {}
+  type AnyConstructor = 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(arg0: never, ...args: never[]);
 }
 
 export default Edge;

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

@@ -20,4 +20,13 @@ declare class CanvasEdges extends Map<string, Edge> {
   refresh(): void;
 }
 
+declare namespace CanvasEdges {
+  interface Any extends AnyCanvasEdges {}
+  type AnyConstructor = typeof AnyCanvasEdges;
+}
+
+declare abstract class AnyCanvasEdges extends CanvasEdges {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default CanvasEdges;

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

@@ -1,3 +1,4 @@
+import type { NullishProps } from "../../../../utils/index.d.mts";
 import type Edge from "./edge.d.mts";
 
 /**
@@ -6,50 +7,66 @@ import type Edge from "./edge.d.mts";
  * @internal
  */
 declare class PolygonVertex {
-  constructor(x: number, y: number, { distance, index }?: PolygonVertex.Options);
+  constructor(x: number, y: number, options?: 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}
+   */
+  _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,15 +100,16 @@ 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 Set externally during `ClockwiseSweeepPolygon` initialization
+   * @privateRemarks Foundry marked `@internal`
    */
   _visited: boolean;
 
@@ -106,7 +124,7 @@ 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)
@@ -123,14 +141,24 @@ 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;
+  static fromPoint(point: Canvas.Point, options?: PolygonVertex.ConstructorOptions): PolygonVertex;
 }
 
 declare namespace PolygonVertex {
-  interface Options {
-    distance: PolygonVertex["_distance"];
-    index: PolygonVertex["_index"];
-  }
+  interface Any extends AnyPolygonVertex {}
+  type AnyConstructor = typeof AnyPolygonVertex;
+
+  /** @internal */
+  type _ConstructorOptions = NullishProps<{
+    distance: number;
+    index: number;
+  }>;
+
+  interface ConstructorOptions extends _ConstructorOptions {}
+}
+
+declare abstract class AnyPolygonVertex extends PolygonVertex {
+  constructor(arg0: never, ...args: never[]);
 }
 
 export default PolygonVertex;

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

@@ -1,8 +1,7 @@
 // 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 */
 
 export { default as RegionGeometry } from "./geometry.mjs";
 export { default as RegionMesh } from "./mesh.mjs";