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

package/src/foundry/client/pixi/core/shapes/source-polygon.d.mts

@@ -1,24 +1,20 @@
-import type { ConstructorOf, InexactPartial } from "../../../../../types/utils.d.mts";
+import type { Brand, Coalesce, Identity, InexactPartial, NullishProps } from "#utils";
 import type PointEffectSourceMixin from "../../../../client-esm/canvas/sources/point-effect-source.d.mts";
 
 declare global {
-  interface PointSourcePolygonConfig extends PointSourcePolygon._Config {
-    /** The type of polygon being computed */
-    type: PointSourcePolygon.PolygonType;
-  }
-
   /**
    * An extension of the default PIXI.Polygon which is used to represent the line of sight for a point source.
    */
   abstract class PointSourcePolygon extends PIXI.Polygon {
+    /**
+     * @remarks This is protected because `new PointSourcePolygon` does not sufficiently initialize the class; Use the static `create` method instead.
+     */
+    protected constructor(...args: ConstructorParameters<typeof PIXI.Polygon>);
+
     /**
      * Customize how wall direction of one-way walls is applied
      */
-    static readonly WALL_DIRECTION_MODES: Readonly<{
-      NORMAL: 0;
-      REVERSED: 1;
-      BOTH: 2;
-    }>;
+    static WALL_DIRECTION_MODES: PointSourcePolygon.WallDirectionModes;
 
     /**
      * The rectangular bounds of this polygon
@@ -28,14 +24,15 @@ declare global {
 
     /**
      * The origin point of the source polygon.
+     * @remarks Not initialized to any value, but immediately set by `PointSourcePolygon#initialize`
      */
     origin: Canvas.Point;
 
     /**
      * The configuration of this polygon.
-     * @defaultValue `{}`
+     * @remarks Initialized as `{}` but immediately filled by `PointSourcePolygon#initialize`
      */
-    config: PointSourcePolygonConfig;
+    config: PointSourcePolygon.StoredConfig;
 
     /**
      * An indicator for whether this polygon is constrained by some boundary shape?
@@ -48,20 +45,18 @@ declare global {
      * @param origin     - The origin point to benchmark
      * @param config     - The polygon configuration to benchmark
      */
-    static benchmark(iterations: number, origin: Canvas.Point, config: PointSourcePolygonConfig): Promise<void>;
+    static benchmark(iterations: number, origin: Canvas.Point, config: PointSourcePolygon.Config): Promise<void>;
 
     /**
      * Compute the polygon given a point origin and radius
      * @param origin - The origin source point
      * @param config - Configuration options which customize the polygon computation
-     *                 (default: `{}`)
      * @returns The computed polygon instance
+     * @remarks Subclasses must implement a `.create` override to accurately type the return.
+     *
+     * Despite being a `={}` parameter, a `config` object with a valid `type` property must be passed
      */
-    static create<T extends ConstructorOf<PointSourcePolygon>>(
-      this: T,
-      origin: Canvas.Point,
-      config?: Parameters<InstanceType<NoInfer<T>>["initialize"]>[1],
-    ): InstanceType<T>;
+    static create(origin: Canvas.Point, config: PointSourcePolygon.Config): unknown;
 
     /**
      * Create a clone of this polygon.
@@ -86,7 +81,7 @@ declare global {
      * @param origin - The provided polygon origin
      * @param config - The provided configuration object
      */
-    initialize(origin: Canvas.Point, config: PointSourcePolygonConfig): void;
+    initialize(origin: Canvas.Point, config: PointSourcePolygon.Config): void;
 
     /**
      * Apply a constraining boundary shape to an existing PointSourcePolygon.
@@ -97,11 +92,18 @@ declare global {
      * @returns A new constrained polygon
      */
     applyConstraint(
-      constraint: PIXI.Circle | PIXI.Rectangle | PIXI.Polygon,
-      intersectionOptions?: Record<string, unknown>,
-    ): PointSourcePolygon;
+      constraint: PIXI.Polygon,
+      intersectionOptions?: PIXI.Polygon.IntersectPolygonOptions, // not:null (property set on it via `??=`)
+    ): this;
+    applyConstraint(constraint: PIXI.Circle, intersectionOptions?: PIXI.Circle.WACIntersectPolygonOptions): this;
+    applyConstraint(constraint: PIXI.Circle, intersectionOptions?: PIXI.Circle.ClipperLibIntersectPolygonOptions): this;
+    applyConstraint(constraint: PIXI.Rectangle, intersectionOptions?: PIXI.Rectangle.WACIntersectPolygonOptions): this;
+    applyConstraint(
+      constraint: PIXI.Rectangle,
+      intersectionOptions?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
+    ): this;
 
-    contains(x: number, y: number): boolean;
+    override contains(x: number, y: number): boolean;
 
     /**
      * Constrain polygon points by applying boundary shapes.
@@ -117,27 +119,17 @@ declare global {
      * @param mode        - The collision mode to test: "any", "all", or "closest"
      *                      (default: "all")
      * @returns The collision result depends on the mode of the test:
-     *          * any: returns a boolean for whether any collision occurred
-     *          * all: returns a sorted array of PolygonVertex instances
-     *          * closest: returns a PolygonVertex instance or null
+     *          - any: returns a boolean for whether any collision occurred
+     *          - all: returns a sorted array of PolygonVertex instances
+     *          - closest: returns a PolygonVertex instance or null
+     * @remarks Despite being an `={}` parameter, `options` is required as it must be a valid
+     * `PointSourcePolygon.Config`, which has a required property (`type`)
      */
-    static testCollision<Mode extends PointSourcePolygon.CollisionModes>(
+    static testCollision<Mode extends PointSourcePolygon.CollisionModes | undefined = undefined>(
       origin: Canvas.Point,
       destination: Canvas.Point,
-      {
-        mode,
-        ...config
-      }: {
-        /**
-         * The collision mode to test: "any", "all", or "closest"
-         * (default: "all")
-         */
-        mode?: Mode;
-
-        /** The configuration that defines a certain Polygon type */
-        config?: PointSourcePolygonConfig;
-      },
-    ): PointSourcePolygon.TestCollision<Mode>;
+      { mode, ...config }: PointSourcePolygon.TestCollisionConfig<Mode>,
+    ): PointSourcePolygon.TestCollision<Coalesce<Mode, "all">>;
 
     /**
      * Determine the set of collisions which occurs for a Ray.
@@ -166,8 +158,9 @@ declare global {
      * Augment a PointSourcePolygon by adding additional coverage for shapes permitted by threshold walls.
      * @param polygon - The computed polygon
      * @returns The augmented polygon
+     * @remarks Mutates and returns the same reference it's passed, not a new polygon
      */
-    static applyThresholdAttenuation(polygon: PointSourcePolygon): PointSourcePolygon;
+    static applyThresholdAttenuation<PolyType extends PointSourcePolygon>(polygon: PolyType): PolyType;
 
     /**
      * @deprecated since v11, will be removed in v13
@@ -180,22 +173,109 @@ declare global {
   }
 
   namespace PointSourcePolygon {
+    interface Any extends AnyPointSourcePolygon {}
+    interface AnyConstructor extends Identity<typeof AnyPointSourcePolygon> {}
+
+    type WALL_DIRECTION_MODES = Brand<number, "PointSourcePolygon.WALL_DIRECTION_MODES">;
+
+    interface WallDirectionModes {
+      readonly NORMAL: 0 & WALL_DIRECTION_MODES;
+      readonly REVERSED: 1 & WALL_DIRECTION_MODES;
+      readonly BOTH: 2 & WALL_DIRECTION_MODES;
+    }
+
     /** @internal */
-    type _Config = InexactPartial<{
-      /** The angle of emission, if limited */
-      angle: number;
+    type _TestCollisionConfig<Mode> = InexactPartial<{
+      /**
+       * The collision mode to test: "any", "all", or "closest"
+       * @defaultValue `"all"`
+       * @remarks Can't be `null` as it only has a parameter default
+       */
+      mode: Mode;
+    }>;
 
-      /** The desired density of padding rays, a number per PI */
-      density: number;
+    interface TestCollisionConfig<Mode> extends _TestCollisionConfig<Mode>, Config {}
+
+    /**
+     * @internal
+     * @privateRemarks Properties of the config that get set in `#initialize` or elsewhere with no respect to their passed value
+     */
+    interface _ComputedConfig {
+      /**
+       * Does this polygon have a limited radius?
+       * @remarks `true` if `(cfg.radius > 0) && (cfg.radius < canvas.dimensions.maxR)`
+       */
+      hasLimitedRadius: boolean;
+
+      /**
+       * Does this polygon have a limited angle?
+       * @remarks `true` if `cfg.angle !== 360`
+       */
+      hasLimitedAngle: boolean;
+    }
+
+    /**
+     * @internal
+     * @privateRemarks Properties of the config that might be omitted but can't be explicitly `undefined`
+     */
+    interface _OptionalOnlyConfig {
+      /**
+       * The object (if any) that spawned this polygon.
+       * @remarks Not guaranteed by `PointSourcePolygon#initialize` but will exist in all configs created by `PointEffectSourceMixin` subclasses. No default provided
+       * @privateRemarks Foundry types this as `PointSource` which is neither a typedef nor a class, not even a mixin class name. The type here matches usage and tracks with what they probably meant.
+       */
+      source?: PointEffectSourceMixin.AnyMixed;
+
+      /**
+       * The external radius of the source
+       * @remarks Can't be `undefined` or `null` or its use in math would produce `NaN`s.
+       *
+       * Not guaranteed by `PointSourcePolygon#initialize` but will exist in all configs created by `PointEffectSourceMixin` subclasses.
+       */
+      externalRadius?: number;
+    }
 
-      /** A limited radius of the resulting polygon */
+    /**
+     * @internal
+     * @privateRemarks Properties of the config that have defaults for nullish values in `#initialize`, and thus are guaranteed in the stored config
+     */
+    interface _BaseConfig {
+      /**
+       * A limited radius of the resulting polygon
+       * @defaultValue `canvas.dimensions.maxR`
+       */
       radius: number;
 
-      /** The direction of facing, required if the angle is limited */
+      /**
+       * The desired density of padding rays, a number per PI
+       * @defaultValue `PIXI.Circle.approximateVertexDensity(cfg.radius)`
+       */
+      density: number;
+
+      /**
+       * The angle of emission, if limited
+       * @defaultValue `360`
+       */
+      angle: number;
+
+      /**
+       * The direction of facing, required if the angle is limited
+       * @defaultValue `0`
+       */
       rotation: number;
 
-      /** Customize how wall direction of one-way walls is applied */
-      wallDirectionMode: number;
+      /**
+       * Does this polygon use the Scene inner or outer bounding rectangle
+       * @defaultValue `true` if `type === "sight"` and the origin point is inside `canvas.dimensions.sceneRect` else `false`
+       * @remarks Computed if not provided or passed nullish.
+       */
+      useInnerBounds: boolean;
+
+      /**
+       * Customize how wall direction of one-way walls is applied
+       * @defaultValue `PointSourcePolygon.WALL_DIRECTION_MODES.NORMAL`
+       */
+      wallDirectionMode: PointSourcePolygon.WALL_DIRECTION_MODES;
 
       /**
        * Compute the polygon with threshold wall constraints applied
@@ -209,41 +289,56 @@ declare global {
        */
       includeDarkness: boolean;
 
-      /** Priority when it comes to ignore edges from darkness sources */
-      priority: number;
-
-      /** Display debugging visualization and logging for the polygon */
-      debug: boolean;
+      /**
+       * Limiting polygon boundary shapes
+       * @defaultValue `[]`
+       * @remarks Never passed in Foundry practice
+       */
+      boundaryShapes: Array<BoundaryShapes>;
 
-      /** The object (if any) that spawned this polygon. */
-      source: PointEffectSourceMixin.AnyMixed;
+      /**
+       * Display debugging visualization and logging for the polygon
+       * @remarks Overridden `true` if `CONFIG.debug.polygons` is truthy
+       */
+      debug?: boolean;
 
-      /** Limiting polygon boundary shapes */
-      boundaryShapes: Array<PIXI.Rectangle | PIXI.Circle | PIXI.Polygon>;
+      /**
+       * Priority when it comes to ignore edges from darkness sources
+       * @remarks This is listed in the typedef, but is not in use by Foundry in 12.331
+       */
+      priority?: number;
+    }
 
-      /** Does this polygon use the Scene inner or outer bounding rectangle */
-      readonly useInnerBounds: boolean;
+    /**
+     * @internal
+     * @privateRemarks The only property required in all configs
+     */
+    interface _RequiredConfig {
+      /** The type of polygon being computed */
+      type: PolygonType;
+    }
 
-      /** Does this polygon have a limited radius? */
-      readonly hasLimitedRadius: boolean;
+    interface StoredConfig extends _RequiredConfig, _BaseConfig, _OptionalOnlyConfig, _ComputedConfig {}
 
-      /** Does this polygon have a limited angle? */
-      readonly hasLimitedAngle: boolean;
+    interface Config extends _RequiredConfig, NullishProps<_BaseConfig>, _OptionalOnlyConfig {}
 
-      /** The computed bounding box for the polygon */
-      readonly boundingBox: PIXI.Rectangle;
-    }>;
+    type BoundaryShapes = PIXI.Rectangle | PIXI.Circle | PIXI.Polygon;
 
     type PolygonType = "light" | "sight" | "sound" | "move" | "universal";
 
     type CollisionModes = "any" | "all" | "closest";
 
-    interface CollisionTypes {
+    /** @internal */
+    interface _CollisionTypesReturnMap {
       any: boolean;
-      closest: foundry.canvas.edges.PolygonVertex;
-      all: foundry.canvas.edges.PolygonVertex[] | null;
+      closest: foundry.canvas.edges.PolygonVertex | null;
+      all: foundry.canvas.edges.PolygonVertex[];
     }
 
-    type TestCollision<Mode extends CollisionModes> = CollisionTypes[Mode];
+    type TestCollision<Mode extends CollisionModes> = _CollisionTypesReturnMap[Mode];
   }
 }
+
+declare abstract class AnyPointSourcePolygon extends PointSourcePolygon {
+  constructor(...args: never);
+}

package/src/foundry/client/pixi/extensions/circle.d.mts

@@ -1,140 +1,143 @@
-import type { NullishProps } from "../../../../types/utils.d.mts";
+import type { NullishProps } from "#utils";
 import type { LineCircleIntersection } from "../../../common/utils/geometry.d.mts";
+import * as _PIXI from "pixi.js";
 
-declare module "pixi.js" {
-  interface Circle {
-    /**
-     * Determine the center of the circle.
-     * Trivial, but used to match center method for other shapes.
-     */
-    get center(): PIXI.Point;
-
-    /**
-     * Determine if a point is on or nearly on this circle.
-     * @param point   - Point to test
-     * @param epsilon - Tolerated margin of error
-     *                  (default: `1e-08`)
-     * @returns Is the point on the circle within the allowed tolerance?
-     */
-    pointIsOn(point: Canvas.Point, epsilon: number): boolean;
-
-    /**
-     * Get all intersection points on this circle for a segment A|B
-     * Intersections are sorted from A to B.
-     * @param a - The first endpoint on segment A|B
-     * @param b - The second endpoint on segment A|B
-     * @returns Points where the segment A|B intersects the circle
-     */
-    segmentIntersections(a: Canvas.Point, b: Canvas.Point): LineCircleIntersection["intersections"];
-
-    /**
-     * Calculate an x,y point on this circle's circumference given an angle
-     * 0: due east
-     * π / 2: due south
-     * π or -π: due west
-     * -π/2: due north
-     * @param angle - Angle of the point, in radians
-     * @returns The point on the circle at the given angle
-     */
-    pointAtAngle(angle: number): Canvas.Point;
-
-    /**
-     * Get all the points for a polygon approximation of this circle between two points.
-     * The two points can be anywhere in 2d space. The intersection of this circle with the line from this circle center
-     * to the point will be used as the start or end point, respectively.
-     * This is used to draw the portion of the circle (the arc) between two intersection points on this circle.
-     * @param a       - Point in 2d space representing the start point
-     * @param b       - Point in 2d space representing the end point
-     * @param options - Options passed on to the pointsForArc method
-     * @returns An array of points arranged clockwise from start to end
-     */
-    pointsBetween(a: Canvas.Point, b: Canvas.Point, options?: Circle.PointsForArcOptions): Canvas.Point[];
-
-    /**
-     * Get the points that would approximate a circular arc along this circle, given a starting and ending angle.
-     * Points returned are clockwise. If from and to are the same, a full circle will be returned.
-     * @param fromAngle - Starting angle, in radians. π is due north, π/2 is due east
-     * @param toAngle   - Ending angle, in radians
-     * @param options   - Options which affect how the circle is converted
-     * @returns An array of points along the requested arc
-     */
-    pointsForArc(fromAngle: number, toAngle: number, options?: Circle.PointsForArcOptions): Canvas.Point[];
-
-    /**
-     * Approximate this PIXI.Circle as a PIXI.Polygon
-     * @param options - Options forwarded on to the pointsForArc method
-     * @returns The Circle expressed as a PIXI.Polygon
-     */
-    toPolygon(options?: Circle.PointsForArcOptions): PIXI.Polygon;
-
-    /**
-     * The recommended vertex density for the regular polygon approximation of a circle of a given radius.
-     * Small radius circles have fewer vertices. The returned value will be rounded up to the nearest integer.
-     * See the formula described at:
-     * https://math.stackexchange.com/questions/4132060/compute-number-of-regular-polgy-sides-to-approximate-circle-to-defined-precision
-     * @param radius  - Circle radius
-     * @param epsilon - The maximum tolerable distance between an approximated line segment and the true radius.
-     *                  A larger epsilon results in fewer points for a given radius. (default: `1`)
-     * @returns The number of points for the approximated polygon
-     */
-    approximateVertexDensity(radius: number, epsilon?: number): number;
-
-    /**
-     * Intersect this PIXI.Circle with a PIXI.Polygon.
-     * @param polygon - A PIXI.Polygon
-     * @param options - Options which configure how the intersection is computed
-     * @returns The intersected polygon
-     */
-    intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.WACIntersectPolygonOptions): PIXI.Polygon;
-    intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.ClipperLibIntersectPolygonOptions): PIXI.Polygon;
-    intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.IntersectClipperOptions): PIXI.Polygon;
-
-    /**
-     * Intersect this PIXI.Circle with an array of ClipperPoints.
-     * Convert the circle to a Polygon approximation and use intersectPolygon.
-     * In the future we may replace this with more specialized logic which uses the line-circle intersection formula.
-     * @param clipperPoints - Array of ClipperPoints generated by PIXI.Polygon.toClipperPoints()
-     * @param options       - Options which configure how the intersection is computed
-     * @returns The intersected polygon
-     */
-    intersectClipper(
-      clipperPoints: PIXI.Polygon.ClipperPoint[],
-      options?: PIXI.Circle.IntersectClipperOptions,
-    ): PIXI.Polygon;
-  }
+declare global {
+  namespace PIXI {
+    interface Circle {
+      /**
+       * Determine the center of the circle.
+       * Trivial, but used to match center method for other shapes.
+       */
+      get center(): PIXI.Point;
 
-  namespace Circle {
-    interface WACIntersectPolygonOptions extends PIXI.Rectangle.WACIntersectPolygonOptions {}
+      /**
+       * Determine if a point is on or nearly on this circle.
+       * @param point   - Point to test
+       * @param epsilon - Tolerated margin of error
+       *                  (default: `1e-08`)
+       * @returns Is the point on the circle within the allowed tolerance?
+       */
+      pointIsOn(point: Canvas.Point, epsilon?: number): boolean;
 
-    /** @privateRemarks Property description intentionally omitted to avoid redundant intellisense on overloaded method */
-    interface ClipperLibIntersectPolygonOptions extends PIXI.Rectangle.ClipperLibIntersectPolygonOptions {
-      density: number;
-    }
+      /**
+       * Get all intersection points on this circle for a segment A|B
+       * Intersections are sorted from A to B.
+       * @param a - The first endpoint on segment A|B
+       * @param b - The second endpoint on segment A|B
+       * @returns Points where the segment A|B intersects the circle
+       */
+      segmentIntersections(a: Canvas.Point, b: Canvas.Point): LineCircleIntersection["intersections"];
 
-    /** @privateRemarks Property description intentionally omitted to avoid redundant intellisense on overloaded method */
-    interface IntsectPolygonOptions extends PIXI.Rectangle.IntersectPolygonOptions {
-      density: number;
-    }
+      /**
+       * Calculate an x,y point on this circle's circumference given an angle
+       * 0: due east
+       * π / 2: due south
+       * π or -π: due west
+       * -π/2: due north
+       * @param angle - Angle of the point, in radians
+       * @returns The point on the circle at the given angle
+       */
+      pointAtAngle(angle: number): Canvas.Point;
 
-    /** @internal Helper type to simplify use of optionality- and nullish-permissiveness-modifying helpers */
-    type _PointsForArcOptions = NullishProps<{
       /**
-       * The number of points which defines the density of approximation
-       * @defaultValue `this.constructor.approximateVertexDensity(this.radius)`
+       * Get all the points for a polygon approximation of this circle between two points.
+       * The two points can be anywhere in 2d space. The intersection of this circle with the line from this circle center
+       * to the point will be used as the start or end point, respectively.
+       * This is used to draw the portion of the circle (the arc) between two intersection points on this circle.
+       * @param a       - Point in 2d space representing the start point
+       * @param b       - Point in 2d space representing the end point
+       * @param options - Options passed on to the pointsForArc method
+       * @returns An array of points arranged clockwise from start to end
        */
-      density: number;
+      pointsBetween(a: Canvas.Point, b: Canvas.Point, options?: Circle.PointsForArcOptions): Canvas.Point[];
 
       /**
-       * Whether to include points at the circle where the arc starts and ends
-       * @defaultValue `true`
+       * Get the points that would approximate a circular arc along this circle, given a starting and ending angle.
+       * Points returned are clockwise. If from and to are the same, a full circle will be returned.
+       * @param fromAngle - Starting angle, in radians. π is due north, π/2 is due east
+       * @param toAngle   - Ending angle, in radians
+       * @param options   - Options which affect how the circle is converted
+       * @returns An array of points along the requested arc
        */
-      includeEndpoints: boolean;
-    }>;
+      pointsForArc(fromAngle: number, toAngle: number, options?: Circle.PointsForArcOptions): Canvas.Point[];
 
-    interface PointsForArcOptions extends _PointsForArcOptions {}
+      /**
+       * Approximate this PIXI.Circle as a PIXI.Polygon
+       * @param options - Options forwarded on to the pointsForArc method
+       * @returns The Circle expressed as a PIXI.Polygon
+       */
+      toPolygon(options?: Circle.PointsForArcOptions): PIXI.Polygon;
 
-    interface IntersectClipperOptions
-      extends PIXI.Polygon.IntersectClipperOptions,
-        Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
+      /**
+       * Intersect this PIXI.Circle with a PIXI.Polygon.
+       * @param polygon - A PIXI.Polygon
+       * @param options - Options which configure how the intersection is computed
+       * @returns The intersected polygon
+       * @remarks Slightly bugged in v12; if `options.weilerAtherton` is falsey, it will not pass on `options.clipType` to `PIXI.Polygon#intersectPolygon`,
+       * forcing the default of `ClipperLib.ClipTypes.ctIntersection`
+       */
+      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.WACIntersectPolygonOptions): PIXI.Polygon;
+      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Circle.ClipperLibIntersectPolygonOptions): PIXI.Polygon;
+
+      /**
+       * Intersect this PIXI.Circle with an array of ClipperPoints.
+       * Convert the circle to a Polygon approximation and use intersectPolygon.
+       * In the future we may replace this with more specialized logic which uses the line-circle intersection formula.
+       * @param clipperPoints - Array of ClipperPoints generated by PIXI.Polygon.toClipperPoints()
+       * @param options       - Options which configure how the intersection is computed
+       * @returns The intersected polygon
+       */
+      intersectClipper(
+        clipperPoints: PIXI.Polygon.ClipperPoint[],
+        options?: PIXI.Circle.IntersectClipperOptions,
+      ): PIXI.Polygon;
+    }
+
+    namespace Circle {
+      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is true (or not provided) */
+      interface WACIntersectPolygonOptions extends PIXI.Rectangle.WACIntersectPolygonOptions {}
+
+      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is false. */
+      interface ClipperLibIntersectPolygonOptions
+        extends PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
+          Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
+
+      /** @internal Helper type to simplify use of optionality- and nullish-permissiveness-modifying helpers */
+      type _PointsForArcOptions = NullishProps<{
+        /**
+         * The number of points which defines the density of approximation
+         * @defaultValue `PIXI.Circle.approximateVertexDensity(this.radius)`
+         * @remarks Default provided by `??=` in `pointsForArc` function body
+         */
+        density: number;
+
+        /**
+         * Whether to include points at the circle where the arc starts and ends
+         * @defaultValue `true`
+         */
+        includeEndpoints: boolean;
+      }>;
+
+      interface PointsForArcOptions extends _PointsForArcOptions {}
+
+      interface IntersectClipperOptions
+        extends PIXI.Polygon.IntersectClipperOptions,
+          Pick<PIXI.Circle.PointsForArcOptions, "density"> {}
+    }
+
+    class Circle extends _PIXI.Circle {
+      /**
+       * The recommended vertex density for the regular polygon approximation of a circle of a given radius.
+       * Small radius circles have fewer vertices. The returned value will be rounded up to the nearest integer.
+       * See the formula described at:
+       * https://math.stackexchange.com/questions/4132060/compute-number-of-regular-polgy-sides-to-approximate-circle-to-defined-precision
+       * @param radius  - Circle radius
+       * @param epsilon - The maximum tolerable distance between an approximated line segment and the true radius.
+       *                  A larger epsilon results in fewer points for a given radius. (default: `1`)
+       * @returns The number of points for the approximated polygon
+       */
+      static approximateVertexDensity(radius: number, epsilon?: number): number;
+    }
   }
 }

package/src/foundry/client/pixi/extensions/graphics.d.mts

@@ -3,7 +3,9 @@ export {};
 declare global {
   namespace PIXI {
     namespace Graphics {
-      type Path = [number[] | PIXI.IPointData[] | PIXI.Polygon] | Array<number | PIXI.IPointData>;
+      type Path =
+        | [points: number[] | PIXI.IPointData[] | PIXI.Polygon, smoothingFactor?: number]
+        | Array<number | PIXI.IPointData>;
     }
   }
 }

package/src/foundry/client/pixi/extensions/observable-transform.d.mts

@@ -1,11 +1,11 @@
-import type { AnyObject } from "../../../../types/utils.d.mts";
+import type { Identity } from "#utils";
 
 declare global {
   /**
    * A custom Transform class allowing to observe changes with a callback.
    * @privateRemarks Scope extends object is intentional; `"The scope bound to an ObservableTransform class must be a valid object/class."`
    */
-  class ObservableTransform<CB extends (this: Scope) => unknown, Scope extends AnyObject> extends PIXI.Transform {
+  class ObservableTransform<CB extends (this: Scope) => unknown, Scope extends object> extends PIXI.Transform {
     /**
      *
      * @param callback - The callback called to observe changes.
@@ -28,10 +28,11 @@ declare global {
     protected override updateSkew(): void;
   }
   namespace ObservableTransform {
-    type AnyConstructor = typeof AnyObservableTransform;
+    interface Any extends AnyObservableTransform {}
+    interface AnyConstructor extends Identity<typeof AnyObservableTransform> {}
   }
 }
 
 declare abstract class AnyObservableTransform extends ObservableTransform<any, any> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }