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

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

@@ -1,4 +1,4 @@
-export {};
+import type { Identity, InexactPartial } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -6,12 +6,12 @@ declare global {
    * The shape is defined by a point origin, radius, angle, and rotation.
    * The shape is further customized by a configurable density which informs the approximation.
    * An optional secondary externalRadius can be provided which adds supplementary visibility outside the primary angle.
+   * @param origin - The origin point for this polygon
+   * @param config - Configuration for the polygon.
+   * @remarks Despite `config` being an `={}` parameter, the `radius` key must be passed to avoid `NaN`s
    */
   class LimitedAnglePolygon extends PIXI.Polygon {
-    constructor(
-      origin: Canvas.Point,
-      { radius, angle, rotation, density, externalRadius }: LimitedAnglePolygon.ConstructorOptions,
-    );
+    constructor(origin: Canvas.Point, config: LimitedAnglePolygon.ConstructorOptions);
 
     /**
      * The origin point of the Polygon
@@ -59,6 +59,12 @@ declare global {
      */
     aMax: number;
 
+    /**
+     * The bounding box of the circle defined by the externalRadius, if any
+     * @privateRemarks Set in `##generatePoints`, which is called at the end of the constructor
+     */
+    externalBounds: PIXI.Rectangle;
+
     /**
      * Restrict the edges which should be included in a PointSourcePolygon based on this specialized shape.
      * We use two tests to jointly keep or reject edges.
@@ -67,9 +73,9 @@ declare global {
      * @param a - The first edge vertex
      * @param b - The second edge vertex
      * @returns Should the edge be included in the PointSourcePolygon computation?
-     * @internal
+     * @remarks Foundry marked `@internal`
      */
-    protected _includeEdge(a: Canvas.Point, b: Canvas.Point): boolean;
+    _includeEdge(a: Canvas.Point, b: Canvas.Point): boolean;
 
     /**
      * Test whether a vertex lies between two boundary rays.
@@ -81,39 +87,58 @@ declare global {
      * @param angle - The angle being tested, in degrees
      * @returns Is the vertex between the two rays?
      */
-    static pointBetweenRays(point: Canvas.Point, rMin: PolygonRay, rMax: PolygonRay, angle: number): boolean;
+    static pointBetweenRays(
+      point: Canvas.Point,
+      rMin: ClockwiseSweepPolygon.Ray,
+      rMax: ClockwiseSweepPolygon.Ray,
+      angle: number,
+    ): boolean;
   }
 
   namespace LimitedAnglePolygon {
-    interface ConstructorOptions {
-      /**
-       * The radius of the emitted cone.
-       */
-      radius: number;
+    interface Any extends AnyLimitedAnglePolygon {}
+    interface AnyConstructor extends Identity<typeof AnyLimitedAnglePolygon> {}
 
+    /** @internal */
+    type _ConstructorOptions = InexactPartial<{
       /**
        * The angle of the Polygon in degrees.
        * @defaultValue `360`
+       * @remarks Can't be `null` as it only has a parameter default
        */
-      angle?: number;
+      angle: number;
 
       /**
        * The direction of rotation at the center of the emitted angle in degrees.
        * @defaultValue `0`
+       * @remarks Can't be `null` as it only has a parameter default
        */
-      rotation?: number;
+      rotation: number;
 
       /**
        * The density of rays which approximate the cone, defined as rays per PI.
        * @defaultValue `PIXI.Circle.approximateVertexDensity(this.radius)`
        */
-      density?: number;
+      density: number | null;
 
       /**
        * An optional "external radius" which is included in the polygon for the supplementary area outside the cone.
        * @defaultValue `0`
+       * @remarks Only used if truthy
        */
-      externalRadius?: number;
+      externalRadius: number | null;
+    }>;
+
+    interface ConstructorOptions extends _ConstructorOptions {
+      /**
+       * The radius of the emitted cone.
+       * @privateRemarks This is given no default, but is directly used in multiplication and division, resulting in `NaN` if allowed to be `undefined`
+       */
+      radius: number;
     }
   }
 }
+
+declare abstract class AnyLimitedAnglePolygon extends LimitedAnglePolygon {
+  constructor(...args: never);
+}

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
+import type { Identity, IntentionalPartial } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -10,14 +10,13 @@ declare global {
      * @param poly    - Closed polygon to be processed and converted to a mesh
      *                  (array of points or PIXI Polygon)
      * @param options - Various options : normalizing, offsetting, add depth, ...
+     * @remarks `options` is `IntentionalPartial`'d because the constructor immediately does
+     * `this.options = {...this.constructor._defaultOptions, ...options}`, so explicit `undefined` would break things
      */
-    constructor(poly: number[] | PIXI.Polygon, options?: InexactPartial<PolygonMesherOptions>);
-
-    /** Contains options to apply during the meshing process */
-    options: PolygonMesherOptions;
+    constructor(poly: PIXI.Polygon.OrPointsFlat, options?: IntentionalPartial<PolygonMesher.Options>);
 
     /** Default options values */
-    static _defaultOptions: PolygonMesherOptions;
+    static _defaultOptions: PolygonMesher.Options;
 
     /**
      * Polygon mesh vertices
@@ -29,14 +28,20 @@ declare global {
      */
     indices: number[];
 
+    /** Contains options to apply during the meshing process */
+    options: PolygonMesher.Options;
+
     /**
      * Convert a flat points array into a 2 dimensional ClipperLib path
      * @param poly      - PIXI.Polygon or points flat array.
      * @param dimension - Dimension.
      *                    (default 2)
      * @returns The clipper lib path.
+     * @throws If `dimension < 2`
+     * @privateRemarks Foundry types this return as `number[] | undefined`, but it cannot return either of those;
+     * Either it will throw or return a (possibly empty) `ClipperLib.Path` (an array-like of `ClipperLib.IntPoint`s)
      */
-    static getClipperPathFromPoints(poly: number[] | PIXI.Polygon, dimension?: number): number[] | undefined;
+    static getClipperPathFromPoints(poly: PIXI.Polygon.OrPointsFlat, dimension?: number): ClipperLib.Path;
 
     /**
      * Execute the triangulation to create indices
@@ -46,65 +51,88 @@ declare global {
     triangulate(geometry: PIXI.Geometry): PIXI.Geometry;
   }
 
-  interface PolygonMesherOptions {
-    /**
-     * The position value in pixels
-     * @defaultValue `0`
-     */
-    offset: number;
-
-    /**
-     * Should the vertices be normalized?
-     * @defaultValue `false`
-     */
-    normalize: boolean;
-
-    /**
-     * The x origin
-     * @defaultValue `0`
-     */
-    x: number;
-
-    /**
-     * The y origin
-     * @defaultValue `0`
-     */
-    y: number;
-
-    /**
-     * The radius
-     * @defaultValue `0`
-     */
-    radius: number;
-
-    /**
-     * The depth value on the outer polygon
-     * @defaultValue `0`
-     */
-    depthOuter: number;
-
-    /**
-     * The depth value on the inner polygon
-     * @defaultValue `1`
-     */
-    depthInner: number;
+  namespace PolygonMesher {
+    interface Any extends AnyPolygonMesher {}
+    interface AnyConstructor extends Identity<typeof AnyPolygonMesher> {}
 
     /**
-     * Constant multiplier to avoid floating point imprecision with ClipperLib
-     * @defaultValue `10e8`
+     *  @remarks These properties all have non-nullish values in `_defaultOptions`, and explicit `undefined` breaks
+     * things that aren't `boolean` due to math and object spread syntax in the constructor. `null` has been allowed
+     * where its casting to `0` or `false` doesn't break things.
      */
-    scale: number;
-
-    /**
-     * Distance of the miter limit, when sharp angles are cut during offsetting.
-     * @defaultValue `7`
-     */
-    miterLimit: number;
-
-    /**
-     * Should the vertex data be interleaved into one VBO?
-     * @defaultValue `false`
-     */
-    interleaved: boolean;
+    interface Options {
+      /**
+       * The position value in pixels
+       * @defaultValue `0`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      offset: number | null;
+
+      /**
+       * Should the vertices be normalized?
+       * @defaultValue `false`
+       */
+      normalize: boolean | undefined | null;
+
+      /**
+       * The x origin
+       * @defaultValue `0`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      x: number | null;
+
+      /**
+       * The y origin
+       * @defaultValue `0`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      y: number | null;
+
+      /**
+       * The radius
+       * @defaultValue `0`
+       * @remarks Can't be `null` because of an `=== 0` check, nor `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      radius: number;
+
+      /**
+       * The depth value on the outer polygon
+       * @defaultValue `0`
+       * @remarks Can't be `null` as it can be pushed directly into a `number[]`, nor `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      depthOuter: number;
+
+      /**
+       * The depth value on the inner polygon
+       * @defaultValue `1`
+       * @remarks Can't be `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      depthInner: number | null;
+
+      /**
+       * Constant multiplier to avoid floating point imprecision with ClipperLib
+       * @defaultValue `10e8`
+       * @remarks Not allowing `null` because a zero value here defeats the purpose, and `undefined` because the default is provided by spread operator and the value is used directly in math
+       */
+      scale: number;
+
+      /**
+       * Distance of the miter limit, when sharp angles are cut during offsetting.
+       * @defaultValue `7`
+       * @remarks Allowed to be `undefined` but not `null` because it is passed to
+       * `new ClipperLib.ClipperOffset()`, which provides its own default if `=== undefined`
+       */
+      miterLimit: number | undefined;
+
+      /**
+       * Should the vertex data be interleaved into one VBO?
+       * @defaultValue `false`
+       */
+      interleaved: boolean | undefined | null;
+    }
   }
 }
+
+declare abstract class AnyPolygonMesher extends PolygonMesher {
+  constructor(...args: never);
+}

package/src/foundry/client/pixi/core/shapes/precise-text.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity, InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -6,22 +6,40 @@ declare global {
    * At default resolution Text often looks blurry or fuzzy.
    */
   class PreciseText extends PIXI.Text {
-    /**
-     * @param options - Additional options merged with the default TextStyle
-     */
     constructor(...args: ConstructorParameters<typeof PIXI.Text>);
 
+    /** @defaultValue `false` */
+    override _autoResolution: boolean;
+
+    /** @defaultValue `2` */
+    override _resolution: number;
     /**
      * Prepare a TextStyle object which merges the canvas defaults with user-provided options
      * @param anchor  - A text anchor point from CONST.TEXT_ANCHOR_POINTS
      * @param options - Additional options merged with the default TextStyle
      * @returns The prepared TextStyle
      */
-    static getTextStyle({
-      anchor,
-      ...options
-    }?: { anchor?: foundry.CONST.TEXT_ANCHOR_POINTS } & ConstructorParameters<
-      typeof PIXI.TextStyle
-    >[0]): PIXI.TextStyle;
+    static getTextStyle({ anchor, ...options }?: PreciseText.GetTextStyleOptions): PIXI.TextStyle;
   }
+
+  namespace PreciseText {
+    interface Any extends AnyPreciseText {}
+    interface AnyConstructor extends Identity<typeof AnyPreciseText> {}
+
+    /** @internal */
+    type _GetTextStyleOptions = NullishProps<{
+      /**
+       * A text anchor point from CONST.TEXT_ANCHOR_POINTS
+       * @remarks Only checked againt `.RIGHT` and `.LEFT`, and only if an `align` key is omitted
+       */
+      anchor: foundry.CONST.TEXT_ANCHOR_POINTS;
+    }> &
+      // Can't be NullishProps because keys are only checked for `!== undefined` in PIXI
+      InexactPartial<PIXI.ITextStyle>;
+    interface GetTextStyleOptions extends _GetTextStyleOptions {}
+  }
+}
+
+declare abstract class AnyPreciseText extends PreciseText {
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/core/shapes/ray.d.mts

@@ -1,19 +1,11 @@
+import type { Identity } from "fvtt-types/utils";
 import type { LineIntersection } from "../../../../common/utils/geometry.d.mts";
 
 declare global {
-  interface RayIntersection {
-    /** The x-coordinate of intersection */
-    x: number;
-
-    /** The y-coordinate of intersection */
-    y: number;
-
-    /** The proximity to the Ray origin, as a ratio of distance */
-    t0: number;
-
-    /** The proximity to the Ray destination, as a ratio of distance */
-    t1: number;
-  }
+  /**
+   * @deprecated {@link Ray.Intersection | `Ray.Intersection`}
+   */
+  type RayIntersection = Ray.Intersection;
 
   /**
    * A ray for the purposes of computing sight and collision
@@ -71,14 +63,14 @@ declare global {
     /**
      * The cached angle, computed lazily in Ray#angle
      * @defaultValue `undefined`
-     * @internal
+     * @privateRemarks Foundry marked `@private` and doesn't type the `| undefined`
      */
     protected _angle: number | undefined;
 
     /**
      * The cached distance, computed lazily in Ray#distance
      * @defaultValue `undefined`
-     * @internal
+     * @privateRemarks Foundry marked `@private` and doesn't type the `| undefined`
      */
     protected _distance: number | undefined;
 
@@ -87,10 +79,11 @@ declare global {
      * The angle is computed lazily (only if required) and cached.
      */
     get angle(): number;
-    set angle(value: number);
+
+    set angle(value);
 
     /**
-     * A bounding rectangle that encompasses the Ray
+     * A normalized bounding rectangle that encompasses the Ray
      */
     get bounds(): PIXI.Rectangle;
 
@@ -99,7 +92,8 @@ declare global {
      * The distance is computed lazily (only if required) and cached.
      */
     get distance(): number;
-    set distance(value: number);
+
+    set distance(value);
 
     /**
      * A factory method to construct a Ray from an origin point, an angle, and a distance
@@ -117,7 +111,7 @@ declare global {
      * @param B - The destination point [x,y]
      * @returns The constructed Ray instance
      */
-    static fromArrays(A: Canvas.PointArray, B: Canvas.PointArray): Ray;
+    static fromArrays(A: Canvas.PointTuple, B: Canvas.PointTuple): Ray;
 
     /**
      * Project the Array by some proportion of it's initial distance.
@@ -125,7 +119,7 @@ declare global {
      * @param t - The distance along the Ray
      * @returns The coordinates of the projected point
      */
-    project(t: number): { x: number; y: number };
+    project(t: number): PIXI.IPointData;
 
     /**
      * Create a Ray by projecting a certain distance towards a known point.
@@ -154,12 +148,42 @@ declare global {
      * @param distance - A distance the new ray should project, otherwise uses the same distance.
      * @returns A new Ray with an offset angle
      */
-    shiftAngle(angleOffset: number, distance?: number): Ray;
+    shiftAngle(
+      offset: number,
+      /**
+       * @defaultValue `this.distance`
+       * @remarks Default provided by `||`, so `0` is effectively `this.distance`
+       */
+      distance?: number | null,
+    ): Ray;
 
     /**
      * Find the point I[x,y] and distance t* on ray R(t) which intersects another ray
-     * @see foundry.utils.lineLineIntersection
+     * @see {@link foundry.utils.lineLineIntersection | `foundry.utils.lineLineIntersection`}
      */
-    intersectSegment(coords: [x0: number, y0: number, x1: number, y1: number]): LineIntersection | null;
+    intersectSegment(coords: Canvas.PairOfPointsTuple): LineIntersection | null;
   }
+
+  namespace Ray {
+    interface Any extends AnyRay {}
+    interface AnyConstructor extends Identity<typeof AnyRay> {}
+
+    interface Intersection {
+      /** The x-coordinate of intersection */
+      x: number;
+
+      /** The y-coordinate of intersection */
+      y: number;
+
+      /** The proximity to the Ray origin, as a ratio of distance */
+      t0: number;
+
+      /** The proximity to the Ray destination, as a ratio of distance */
+      t1: number;
+    }
+  }
+}
+
+declare abstract class AnyRay extends Ray {
+  constructor(...args: never);
 }