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

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,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,31 @@
+/**
+ * The geometry of a {@link Region}.
+ * - Vertex Attribute: `aVertexPosition` (`vec2`)
+ * - Draw Mode: `PIXI.DRAW_MODES.TRIANGLES`
+ */
+declare class RegionGeometry extends PIXI.Geometry {
+  /**
+   * Create a RegionGeometry
+   * @internal
+   */
+  constructor(region: Region.ConfiguredInstance);
+
+  /** The Region this geometry belongs to */
+  get region(): Region.ConfiguredInstance;
+
+  /**
+   * Update the buffers
+   * @internal
+   */
+  protected _clearBuffers(): void;
+
+  /**
+   * Update the buffers
+   * @internal
+   */
+  protected _updateBuffers(): void;
+
+  #regionGeometry: true;
+}
+
+export default RegionGeometry;

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

@@ -0,0 +1,61 @@
+/** A mesh of a {@link Region} */
+declare class RegionMesh extends PIXI.Container {
+  #regionMesh: true;
+
+  /**
+   * Create a RegionMesh
+   * @param region        - The Region to create the RegionMesh from.
+   * @param shaderClass   - The shader class to use. @defaultValue `RegionShader`
+   */
+  constructor(region: Region.ConfiguredInstance, shaderClass?: AbstractBaseShader);
+
+  /** The Region of this RegionMesh */
+  get region(): Region.ConfiguredInstance;
+
+  /** The shader bound to this RegionMesh */
+  get shader(): AbstractBaseShader;
+
+  /** The blend mode assigned tot his RegionMesh */
+  get blendMode(): PIXI.BLEND_MODES;
+  set blendMode(value: PIXI.BLEND_MODES);
+
+  /**
+   * 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: number);
+
+  /** 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
+   * @internal
+   */
+  protected _cachedTint: [red: number, green: number, blue: number, alpha: number];
+
+  /** 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}.
+   */
+  setShaderClass(shaderClass: typeof AbstractBaseShader): void;
+
+  override updateTransform(): void;
+
+  protected override _render(renderer: PIXI.Renderer): void;
+
+  protected override _calculateBounds(): void;
+
+  /** Tests if a point is indie this RegionMesh */
+  containsPoint(point: PIXI.IPointData): boolean;
+
+  override destroy(options?: PIXI.IDestroyOptions | boolean): void;
+}
+
+export default RegionMesh;

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

@@ -0,0 +1,101 @@
+import type { Point } from "@common/_types.d.mts";
+
+/** The node of a {@link RegionPolygonTree}.*/
+declare class RegionPolygonTreeNode {
+  #regionPolygonTreeNode: true;
+
+  /**
+   * Create a RegionPolygonTreeNode.
+   * @param parent    - The parent node.
+   * @internal
+   */
+  constructor(parent: RegionPolygonTreeNode | null);
+
+  /**
+   * Create a node from the Clipper path and add it to the children of the parent.
+   * @param clipperPath   - The clipper path of this node.
+   * @param parent        - The parent node or `null` if root.
+   * @internal
+   */
+  static _fromClipperPath(
+    clipperPath: ClipperLib.IntPoint[],
+    parent: RegionPolygonTreeNode | null,
+  ): RegionPolygonTreeNode;
+
+  /** The parent of this node or `null` if this is the root node. */
+  get parent(): RegionPolygonTreeNode | null;
+
+  /** The children of this node. */
+  get children(): ReadonlyArray<RegionPolygonTreeNode>;
+
+  /**
+   * The depth of this node.
+   * The depth of the root node is 0.
+   */
+  get depth(): number;
+
+  /**
+   * Is this a hole?
+   * The root node is a hole.
+   */
+  get isHole(): boolean;
+
+  /**
+   * The Clipper path of this node.
+   * It is empty in case of the root node.
+   */
+  get clipperPath(): ReadonlyArray<ClipperLib.IntPoint> | null;
+
+  /**
+   * The polygon of this node.
+   * It is `null` in case of the root node.
+   */
+  get polygon(): PIXI.Polygon | null;
+
+  /**
+   * The points of the polygon ([x0, y0, x1, y1, ...]).
+   * They are `null` in case of the root node.
+   */
+  get points(): ReadonlyArray<number> | null;
+
+  /**
+   * The bounds of the polygon.
+   * They are `null` in case of the root node.
+   */
+  get bounds(): PIXI.Rectangle | null;
+
+  [Symbol.iterator](): Generator<RegionPolygonTreeNode>;
+
+  /**
+   * Test whether given point is contained within this node.
+   * @param point     - The point.
+   */
+  testPoint(point: Point): boolean;
+
+  /**
+   * Test circle containment/intersection with this node.
+   * @param center    - The center point of the circle.
+   * @param radius    - The radius of the circle.
+   * @returns         - -1: the circle is in the exterior and does not intersect the boundary.
+   *                  - 0: the circle is intersects the boundary.
+   *                  - 1: the circle is in the interior and does not intersect the boundary.
+   */
+  testCircle(center: Point, radius: number): -1 | 0 | 1;
+}
+
+/** The polygon tree of a {@link Region}. */
+declare class RegionPolygonTree extends RegionPolygonTreeNode {
+  /**
+   * Create a RegionPolygonTree
+   * @internal
+   */
+  constructor();
+
+  /**
+   * Create the tree from a Clipper polygon tree.
+   * @internal
+   */
+  static _fromClipperPolyTree(clipperPolyTree: ClipperLib.PolyTree): RegionPolygonTree;
+}
+
+export default RegionPolygonTree;

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

@@ -0,0 +1,118 @@
+import type { CircleShapeData, EllipseShapeData, PolygonShapeData, RectangleShapeData } from "../../data/_module.d.mts";
+
+declare namespace RegionShape {
+  type Any = RegionShape<any>;
+
+  type ShapeData = CircleShapeData | EllipseShapeData | PolygonShapeData | RectangleShapeData;
+  type ShapeType = ShapeData["type"];
+
+  type CreatedRegionShape<ShapeData extends RegionShape.ShapeData> = _CreateReturnType<ShapeData, ShapeData["type"]>;
+
+  /** @internal */
+  type _CreateReturnType<ShapeData extends RegionShape.ShapeData, ShapeType extends RegionShape.ShapeType> =
+    | (ShapeType extends "circle" ? RegionCircle<ShapeData> : never)
+    | (ShapeType extends "ellipse" ? RegionEllipse<ShapeData> : never)
+    | (ShapeType extends "polygon" ? RegionPolygon<ShapeData> : never)
+    | (ShapeType extends "rectangle" ? RegionRectangle<ShapeData> : never);
+}
+
+/** A shape of a {@link Region} */
+declare abstract class RegionShape<ShapeData extends RegionShape.ShapeData> {
+  #regionShape: true;
+
+  /**
+   * Create the RegionShape from the shape data.
+   * @param data    - The shape data.
+   */
+  constructor(data: ShapeData);
+
+  /**
+   * Create the RegionShape from the shape data.
+   * @param data    - The shape data.
+   */
+  static create<ShapeData extends RegionShape.ShapeData>(data: ShapeData): RegionShape.CreatedRegionShape<ShapeData>;
+
+  /**
+   * The data of this shape.
+   * It is owned by the shape and must not be modified.
+   */
+  get data(): ShapeData;
+
+  /** Is this a hole? */
+  get isHole(): boolean;
+
+  /**
+   * The Clipper paths of this shape.
+   * The winding numbers are 1 or 0.
+   */
+  get clipperPaths(): ReadonlyArray<ReadonlyArray<ClipperLib.IntPoint>>;
+
+  /** The Clipper polygon tree of this shape */
+  get clipperPolyTree(): ClipperLib.PolyTree;
+
+  /**
+   * Create the Clipper polygon tree of this shape.
+   * This function may return a single positively-orientated and non-selfintersecting Clipper path instead of a tree,
+   * which is automatically converted to a Clipper polygon tree.
+   * This function is called only once. It is not called if the shape is empty.
+   */
+  protected abstract _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+
+  /**
+   * Draw shape into the graphics.
+   * @param graphics      - The graphics to draw the shape into.
+   * @internal
+   */
+  protected abstract _drawShape(graphics: PIXI.Graphics): void;
+}
+
+/**
+ * A circle of a {@link Region}
+ * @privateRemarks Technically `ShapeData` should extend `CircleShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
+ */
+declare class RegionCircle<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
+  #regionCircle: true;
+
+  constructor(data: ShapeData);
+
+  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+/**
+ * An ellipse of a {@link Region}
+ * @privateRemarks Technically `ShapeData` should extend `EllipseShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
+ */
+declare class RegionEllipse<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
+  #regionEllipse: true;
+
+  constructor(data: ShapeData);
+
+  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+/**
+ * A polygon of a {@link Region}
+ * @privateRemarks Technically `ShapeData` should extend `PolygonShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
+ */
+declare class RegionPolygon<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
+  constructor(params: ShapeData);
+
+  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+/**
+ * A rectangle of a {@link Region}
+ * @privateRemarks Technically `ShapeData` should extend `RectangleShapeData`, but it's easier to instantiate if it's `RegionShape.ShapeData`.
+ */
+declare class RegionRectangle<ShapeData extends RegionShape.ShapeData> extends RegionShape<ShapeData> {
+  constructor(params: ShapeData);
+
+  protected override _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.IntPoint[];
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+
+export default RegionShape;

package/src/foundry/client-esm/canvas/scene-manager.d.mts

@@ -90,4 +90,13 @@ declare class SceneManager {
   protected _deactivateHooks(): void;
 }
 
+declare namespace SceneManager {
+  type Any = AnySceneManager;
+  type AnyConstructor = typeof AnySceneManager;
+}
+
+declare abstract class AnySceneManager extends SceneManager {
+  constructor(arg0: never, ...args: never[]);
+}
+
 export default SceneManager;

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

@@ -1,6 +1,6 @@
 import type { CLEAR_MODES, FilterState, FilterSystem, RenderTexture } from "pixi.js";
 
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 
 declare class SMAAFilter extends PIXI.Filter {
   /**
@@ -16,8 +16,7 @@ declare class SMAAFilter extends PIXI.Filter {
    */
   static get PRESETS(): Record<string, SMAAFilter.SMAAFilterConfig>;
 
-  /** @override */
-  apply(
+  override apply(
     filterManager: FilterSystem,
     input: RenderTexture,
     output: RenderTexture,

package/src/foundry/client-esm/canvas/sources/_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 BaseEffectSource } from "./base-effect-source.mjs";
 export { default as BaseLightSource } from "./base-light-source.mjs";

package/src/foundry/client-esm/canvas/sources/base-effect-source.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { NullishProps, IntentionalPartial } from "fvtt-types/utils";
 
 /**
  * TODO - Re-document after ESM refactor.
@@ -14,15 +14,16 @@ import type { InexactPartial } from "../../../../types/utils.d.mts";
  * ```
  * @privateRemarks The TODO is foundry's
  */
-declare class BaseEffectSource<
-  SourceData extends BaseEffectSource.BaseEffectSourceData,
+declare abstract class BaseEffectSource<
+  SourceData extends BaseEffectSource.SourceData,
   SourceShape extends PIXI.Polygon,
 > {
   /**
    * An effect source is constructed by providing configuration options.
    * @param options - Options which modify the base effect source instance
+   * @remarks Passing a PlaceableObject is deprecated, and will be removed in v13
    */
-  constructor(options?: BaseEffectSource.BaseEffectSourceOptions);
+  constructor(options?: BaseEffectSource.SourceOptions | PlaceableObject);
 
   /**
    * The type of source represented by this data structure.
@@ -47,17 +48,19 @@ declare class BaseEffectSource<
    * }
    * ```
    */
-  static defaultData: BaseEffectSource.BaseEffectSourceData;
+  static defaultData: BaseEffectSource.SourceData;
 
   /**
    * Some other object which is responsible for this source.
+   * @privateRemarks In Foundry practice this appears to only ever be `null`, `Token.ConfiguredInstance`, or `EffectsCanvasGroup` in v12
    */
-  object: PlaceableObject | null;
+  object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed | null;
 
   /**
    * The source id linked to this effect source.
+   * @remarks Foundry types this as Readonly<string>, but does nothing to that effect at runtime
    */
-  readonly sourceId: string;
+  sourceId: string | undefined;
 
   /**
    * The data of this source.
@@ -66,8 +69,9 @@ declare class BaseEffectSource<
 
   /**
    * The geometric shape of the effect source which is generated later.
+   * @remarks This only isn't `undefined` in subclasses implementing `_createShapes()`, usually via {@link PointEffectSourceMixin}
    */
-  shape: SourceShape;
+  shape: SourceShape | undefined;
 
   /**
    * A collection of boolean flags which control rendering and refresh behavior for the source.
@@ -129,14 +133,14 @@ declare class BaseEffectSource<
    * @returns The initialized source
    */
   initialize(
-    data?: InexactPartial<SourceData>,
-    options?: InexactPartial<{
-      // The type def references a behaviors object that is not even passed into the function
+    data?: NullishProps<SourceData>,
+    /** @privateRemarks Foundry describes an `options.behaviors` key, but it is neither checked for nor used at runtime */
+    options?: NullishProps<{
       /**
        * Should source data be reset to default values before applying changes?
        * @defaultValue `false`
        */
-      reset?: boolean;
+      reset: boolean;
     }>,
   ): this;
 
@@ -144,7 +148,10 @@ declare class BaseEffectSource<
    * Subclass specific data initialization steps.
    * @param data - Provided data for configuration
    */
-  _initialize(data: Partial<SourceData>): void;
+  _initialize(
+    /** @remarks IntentionalPartial because `this.initialize` has filtered invalid keys and replaced any nullish values before calling this */
+    data: IntentionalPartial<SourceData>,
+  ): void;
 
   /**
    * Create the polygon shape (or shapes) for this source using configured data.
@@ -155,8 +162,9 @@ declare class BaseEffectSource<
    * Subclass specific configuration steps. Occurs after data initialization and shape computation.
    * Only called if the source is attached and not disabled.
    * @param changes - Changes to the source data which were applied
+   * @remarks This is actually passed *flattened* partial data
    */
-  protected _configure(changes: Partial<SourceData>): void;
+  protected _configure(changes: IntentionalPartial<SourceData>): void;
 
   /**
    * Refresh the state and uniforms of the source.
@@ -211,19 +219,25 @@ declare class BaseEffectSource<
 declare namespace BaseEffectSource {
   type AnyConstructor = typeof AnyBaseEffectSource;
 
-  interface BaseEffectSourceOptions {
+  /** @internal */
+  type _SourceOptions = NullishProps<{
     /**
      * An optional PlaceableObject which is responsible for this source
      */
-    object?: PlaceableObject | undefined;
+    object: PlaceableObject;
+  }>;
+
+  interface SourceOptions extends _SourceOptions {
     /**
      * A unique ID for this source. This will be set automatically if an
      * object is provided, otherwise is required.
+     * @remarks The above is misleading; sourceId will *not* be inferred if you pass in `{object: PlaceableObject}`,
+     * only if you pass a `PlaceableObject` *instead* of an options object to the constructor.
      */
-    sourceId?: string | undefined;
+    sourceId?: string;
   }
 
-  interface BaseEffectSourceData {
+  interface SourceData {
     /**
      * The x-coordinate of the source location
      */