@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1

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

@@ -1,45 +0,0 @@
-export {};
-
-declare global {
-  namespace PIXI {
-    namespace Graphics {
-      type Path =
-        | [points: number[] | PIXI.IPointData[] | PIXI.Polygon, smoothingFactor?: number]
-        | Array<number | PIXI.IPointData>;
-    }
-  }
-}
-
-/**
- * @remarks Internal helper to accommodate for the reuse of functions across the various Graphics classes
- */
-interface GraphicsHelper {
-  /**
-   * Draws a path.
-   * @param path - The polygon or points.
-   * @returns This Graphics instance.
-   */
-  drawPath(...path: PIXI.Graphics.Path): this;
-
-  /**
-   * Draws a smoothed polygon.
-   * @param path - The polygon or points.
-   * @returns This Graphics instance.
-   */
-  drawSmoothedPolygon(...path: PIXI.Graphics.Path): this;
-
-  /**
-   * Draws a smoothed path.
-   * @param path - The polygon or points.
-   * @returns This Graphics instance.
-   */
-  drawSmoothedPath(...path: PIXI.Graphics.Path): this;
-}
-
-declare module "pixi.js" {
-  interface Graphics extends GraphicsHelper {}
-}
-
-declare module "@pixi/graphics-smooth" {
-  interface SmoothGraphics extends GraphicsHelper {}
-}

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

@@ -1,5 +0,0 @@
-import "./circle.d.mts";
-import "./graphics.d.mts";
-import "./observable-transform.d.mts";
-import "./polygon.d.mts";
-import "./rectangle.d.mts";

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

@@ -1,38 +0,0 @@
-import type { Identity } from "fvtt-types/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 object> extends PIXI.Transform {
-    /**
-     *
-     * @param callback - The callback called to observe changes.
-     * @param scope    - The scope of the callback.
-     */
-    constructor(callback: CB, scope: Scope);
-
-    /**
-     * The callback which is observing the changes.
-     */
-    cb: CB;
-
-    /**
-     * The scope of the callback.
-     */
-    scope: Scope;
-
-    protected override onChange(): void;
-
-    protected override updateSkew(): void;
-  }
-  namespace ObservableTransform {
-    interface Any extends AnyObservableTransform {}
-    interface AnyConstructor extends Identity<typeof AnyObservableTransform> {}
-  }
-}
-
-declare abstract class AnyObservableTransform extends ObservableTransform<any, any> {
-  constructor(...args: never);
-}

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

@@ -1,163 +0,0 @@
-import type { InexactPartial, NullishProps } from "fvtt-types/utils";
-import * as _PIXI from "pixi.js";
-
-declare global {
-  namespace PIXI {
-    interface Polygon {
-      /**
-       * Test whether the polygon is has a positive signed area.
-       * Using a y-down axis orientation, this means that the polygon is "clockwise".
-       */
-      get isPositive(): boolean;
-
-      /**
-       * @remarks Non enumerable
-       */
-      _isPositive?: boolean;
-
-      /**
-       * Clear the cached signed orientation.
-       */
-      clearCache(): void;
-
-      /**
-       * Compute the signed area of polygon using an approach similar to ClipperLib.Clipper.Area.
-       * The math behind this is based on the Shoelace formula. https://en.wikipedia.org/wiki/Shoelace_formula.
-       * The area is positive if the orientation of the polygon is positive.
-       * @returns The signed area of the polygon
-       */
-      signedArea(): number;
-
-      /**
-       * Reverse the order of the polygon points in-place, replacing the points array into the polygon.
-       * Note: references to the old points array will not be affected.
-       * @returns This polygon with its orientation reversed
-       */
-      reverseOrientation(): this;
-
-      /**
-       * Add a de-duplicated point to the Polygon.
-       * @param point - The point to add to the Polygon
-       * @returns A reference to the polygon for method chaining
-       */
-      addPoint(point: Canvas.Point): this;
-
-      /**
-       * Return the bounding box for a PIXI.Polygon.
-       * The bounding rectangle is normalized such that the width and height are non-negative.
-       * @returns The bounding PIXI.Rectangle
-       */
-      getBounds(): PIXI.Rectangle;
-
-      /**
-       * Convert a PIXI.Polygon into an array of clipper points [\{X,Y\}, ...].
-       * Note that clipper points must be rounded to integers.
-       * In order to preserve some amount of floating point precision, an optional scaling factor may be provided.
-       * @param options - Options which affect how clipper points are generated
-       * @returns An array of points to be used by clipper
-       */
-      toClipperPoints(options?: PIXI.Polygon.ClipperPointsOptions): PIXI.Polygon.ClipperPoint[];
-
-      /**
-       * Determine whether the PIXI.Polygon is closed, defined by having the same starting and ending point.
-       * @remarks Non-enumerable
-       */
-      get isClosed(): boolean;
-
-      /**
-       * Intersect this PIXI.Polygon with another PIXI.Polygon using the clipper library.
-       * @param other   - Another PIXI.Polygon
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectPolygon(other: PIXI.Polygon, options?: PIXI.Polygon.IntersectPolygonOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Polygon with an array of ClipperPoints.
-       * @param clipperPoints - Array of clipper points generated by PIXI.Polygon.toClipperPoints()
-       * @param options       - Options which configure how the intersection is computed
-       */
-      intersectClipper(
-        clipperPoints: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Polygon.IntersectClipperOptions,
-      ): PIXI.Polygon.ClipperPoint[];
-
-      /**
-       * Intersect this PIXI.Polygon with a PIXI.Circle.
-       * For now, 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 circle  - A PIXI.Circle
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectCircle(circle: PIXI.Circle, options?: PIXI.Circle.IntersectClipperOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Polygon with a PIXI.Rectangle.
-       * For now, convert the rectangle to a Polygon and use intersectPolygon.
-       * In the future we may replace this with more specialized logic which uses the line-line intersection formula.
-       * @param rect    - A PIXI.Rectangle
-       * @param options - Options which configure how the intersection is computed
-       * @returns The intersected polygon
-       */
-      intersectRectangle(rect: PIXI.Rectangle, options?: PIXI.Rectangle.WACIntersectPolygonOptions): PIXI.Polygon;
-      intersectRectangle(
-        rect: PIXI.Rectangle,
-        options?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions,
-      ): PIXI.Polygon;
-    }
-
-    namespace Polygon {
-      type OrPointsFlat = number[] | PIXI.Polygon;
-      type OrPoints = OrPointsFlat | PIXI.IPointData[];
-
-      /** @privateRemarks Foundry uses this type instead of full `ClipperLib.IntPoint` objects */
-      interface ClipperPoint {
-        X: number;
-        Y: number;
-      }
-
-      /** @internal  */
-      type _IntersectClipperOptions = InexactPartial<{
-        /**
-         * A scaling factor passed to Polygon#toClipperPoints to preserve precision
-         * @remarks Can't be `null` as, where it has any, it only has parameter defaults
-         * @defaultValue `1`
-         */
-        scalingFactor: number;
-      }> &
-        NullishProps<{
-          /**
-           * The clipper clip type
-           * @defaultValue `ClipperLib.ClipType.ctIntersection`
-           * @remarks ClipperLib functions require a non-nullish `ClipperLib.ClipType` value, but the Foundry functions have `??=` guards for this.
-           */
-          clipType: ClipperLib.ClipType;
-        }>;
-
-      interface IntersectClipperOptions extends _IntersectClipperOptions {}
-
-      /**
-       * @privateRemarks Separate interface despite identical keys for purposes of declaration merging
-       * and just having an expected name for external reference
-       */
-      interface IntersectPolygonOptions extends _IntersectClipperOptions {}
-
-      interface ClipperPointsOptions extends Pick<PIXI.Polygon.IntersectClipperOptions, "scalingFactor"> {}
-    }
-
-    class Polygon extends _PIXI.Polygon {
-      /**
-       * Construct a PIXI.Polygon instance from an array of clipper points [\{X,Y\}, ...].
-       * @param points  - An array of points returned by clipper
-       * @param options - Options which affect how canvas points are generated
-       * @param scalingFactor -
-       * @returns The resulting PIXI.Polygon
-       */
-      static fromClipperPoints(
-        points: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Polygon.ClipperPointsOptions,
-      ): PIXI.Polygon;
-    }
-  }
-}

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

@@ -1,274 +0,0 @@
-import type { Brand, InexactPartial } from "fvtt-types/utils";
-import * as _PIXI from "pixi.js";
-
-declare global {
-  namespace PIXI {
-    interface Rectangle {
-      /**
-       * Bit code labels splitting a rectangle into zones, based on the Cohen-Sutherland algorithm.
-       * See https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm
-       *          left    central   right
-       * top      1001    1000      1010
-       * central  0001    0000      0010
-       * bottom   0101    0100      0110
-       */
-      CS_ZONES: PIXI.Rectangle.CS_Zones;
-
-      /**
-       * Calculate center of this rectangle.
-       */
-      get center(): Canvas.Point;
-
-      /**
-       * Return the bounding box for a PIXI.Rectangle.
-       * The bounding rectangle is normalized such that the width and height are non-negative.
-       */
-      getBounds(): PIXI.Rectangle;
-
-      /**
-       * Determine if a point is on or nearly on this rectangle.
-       * @param p - Point to test
-       * @returns Is the point on the rectangle boundary?
-       */
-      pointIsOn(p: Canvas.Point): boolean;
-
-      /**
-       * Calculate the rectangle Zone for a given point located around, on, or in the rectangle.
-       * See https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm
-       * This differs from _getZone in how points on the edge are treated: they are not considered inside.
-       * @param point - A point to test for location relative to the rectangle
-       * @returns Which edge zone does the point belong to?
-       */
-      _getEdgeZone(point: Canvas.Point): PIXI.Rectangle.CS_ZONES;
-
-      /**
-       * Get all the points (corners) for a polygon approximation of a rectangle between two points on the rectangle.
-       * The two points can be anywhere in 2d space on or outside the rectangle.
-       * The starting and ending side are based on the zone of the corresponding a and b points.
-       * (See PIXI.Rectangle.CS_ZONES.)
-       * This is the rectangular version of PIXI.Circle.prototype.pointsBetween, and is similarly used
-       * to draw the portion of the shape between two intersection points on that shape.
-       * @param a - A point on or outside the rectangle, representing the starting position.
-       * @param b - A point on or outside the rectangle, representing the starting position.
-       * @returns Points returned are clockwise from start to end.
-       */
-      pointsBetween(a: Canvas.Point, b: Canvas.Point): Canvas.Point[];
-
-      /**
-       * Get all intersection points for a segment A|B
-       * Intersections are sorted from A to B.
-       * @param a - Endpoint A of the segment
-       * @param b - Endpoint B of the segment
-       * @returns Array of intersections or empty if no intersection.
-       *  If A|B is parallel to an edge of this rectangle, returns the two furthest points on
-       *  the segment A|B that are on the edge.
-       *  The return object's t0 property signifies the location of the intersection on segment A|B.
-       *  This will be NaN if the segment is a point.
-       *  The return object's t1 property signifies the location of the intersection on the rectangle edge.
-       *  The t1 value is measured relative to the intersecting edge of the rectangle.
-       */
-      segmentIntersections(a: Canvas.Point, b: Canvas.Point): Canvas.Point[];
-
-      /**
-       * Compute the intersection of this Rectangle with some other Rectangle.
-       * @param other - Some other rectangle which intersects this one
-       * @returns The intersected rectangle
-       */
-      intersection(other: PIXI.Rectangle): PIXI.Rectangle;
-
-      /**
-       * Convert this PIXI.Rectangle into a PIXI.Polygon
-       * @returns The Rectangle expressed as a PIXI.Polygon
-       */
-      toPolygon(): PIXI.Polygon;
-
-      /**
-       * Get the left edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get leftEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Get the right edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get rightEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Get the top edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get topEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Get the bottom edge of this rectangle.
-       * The returned edge endpoints are oriented clockwise around the rectangle.
-       */
-      get bottomEdge(): PIXI.Rectangle.Edge;
-
-      /**
-       * Calculate the rectangle Zone for a given point located around or in the rectangle.
-       * https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm
-       *
-       * @param p - Point to test for location relative to the rectangle
-       */
-      _getZone(p: Canvas.Point): PIXI.Rectangle.CS_ZONES;
-
-      /**
-       * Test whether a line segment AB intersects this rectangle.
-       * @param a       - The first endpoint of segment AB
-       * @param b       - The second endpoint of segment AB
-       * @param options - Options affecting the intersect test.
-       * @returns True if intersects.
-       */
-      lineSegmentIntersects(
-        a: Canvas.Point,
-        b: Canvas.Point,
-        options?: PIXI.Rectangle.LineSegmentIntersectsOptions,
-      ): boolean;
-
-      /**
-       * Intersect this PIXI.Rectangle 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.Rectangle.WACIntersectPolygonOptions): PIXI.Polygon;
-      intersectPolygon(polygon: PIXI.Polygon, options?: PIXI.Rectangle.ClipperLibIntersectPolygonOptions): PIXI.Polygon;
-
-      /**
-       * Intersect this PIXI.Rectangle with an array of ClipperPoints. Currently, uses the clipper library.
-       * In the future we may replace this with more specialized logic which uses the line-line 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
-       * @remarks Foundry has this typed as returning `PIXI.Polygon | null`, but this method will actually
-       * return an empty array if this rectangle's width or height are 0. This is almost certainly a bug.
-       */
-      intersectClipper(
-        clipperPoints: PIXI.Polygon.ClipperPoint[],
-        options?: PIXI.Polygon.IntersectClipperOptions,
-      ): PIXI.Polygon | [];
-
-      /**
-       * Determine whether some other Rectangle overlaps with this one.
-       * This check differs from the parent class Rectangle#intersects test because it is true for adjacency (zero area).
-       * @param other - Some other rectangle against which to compare
-       * @returns Do the rectangles overlap?
-       */
-      overlaps(other: PIXI.Rectangle): boolean;
-
-      /**
-       * Normalize the width and height of the rectangle in-place, enforcing that those dimensions be positive.
-       */
-      normalize(): PIXI.Rectangle;
-
-      /**
-       * Fits this rectangle around this rectangle rotated around the given pivot counterclockwise by the given angle in radians.
-       * @param radians - The angle of rotation.
-       * @param pivot   - An optional pivot point (normalized).
-       * @returns A new rotated rectangle
-       */
-      rotate(radians: number, pivot?: PIXI.Point): PIXI.Rectangle;
-    }
-
-    namespace Rectangle {
-      type CS_ZONES = Brand<number, "PIXI.Rectangle.CS_ZONES">;
-
-      interface CS_Zones {
-        INSIDE: 0x0000 & CS_ZONES;
-        LEFT: 0x0001 & CS_ZONES;
-        RIGHT: 0x0010 & CS_ZONES;
-        TOP: 0x1000 & CS_ZONES;
-        BOTTOM: 0x0100 & CS_ZONES;
-        TOPLEFT: 0x1001 & CS_ZONES;
-        TOPRIGHT: 0x1010 & CS_ZONES;
-        BOTTOMRIGHT: 0x0110 & CS_ZONES;
-        BOTTOMLEFT: 0x0101 & CS_ZONES;
-      }
-
-      interface Edge {
-        A: Canvas.Point;
-        B: Canvas.Point;
-      }
-
-      /** @internal */
-      type _LineSegmentIntersectsOptions = InexactPartial<{
-        /**
-         * If true, a line contained within the rectangle will return true
-         * @defaultValue `false`
-         * @remarks Can't be `null` as it only has a parameter default
-         */
-        inside: boolean;
-      }>;
-
-      /** Options affecting the intersect test. */
-      interface LineSegmentIntersectsOptions extends _LineSegmentIntersectsOptions {}
-
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is true (or not provided) */
-      interface WACIntersectPolygonOptions extends WeilerAthertonClipper._CombineOptions {
-        /**
-         * One of CLIP_TYPES
-         * @defaultValue `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`
-         * @remarks Default provided by `??=` in function body
-         *
-         * The default is actually `ClipperLib.ClipType.ctIntersection`, but that and `.ctUnion` are
-         * equivalent to  `WeilerAthertonClipper.CLIP_TYPES.INTERSECT` and `.UNION` respectively at runtime
-         */
-        clipType?:
-          | WeilerAthertonClipper.CLIP_TYPES
-          | (typeof ClipperLib.ClipType)["ctIntersection" | "ctUnion"]
-          | undefined
-          | null;
-
-        /**
-         * Use the Weiler-Atherton algorithm. Otherwise, use Clipper.
-         * @defaultValue `true`
-         */
-        weilerAtherton?: true;
-      }
-
-      /** @remarks The options for `intersectPolygon` when `weilerAtherton` is false. */
-      interface ClipperLibIntersectPolygonOptions extends PIXI.Polygon.ClipperPointsOptions {
-        /**
-         * One of CLIP_TYPES
-         * @defaultValue `ClipperLib.ClipType.ctIntersection`
-         * @remarks Default provided by `??=` in function body
-         *
-         * `WeilerAthertonClipper.CLIP_TYPES.INTERSECT` and `.UNION` are equivalent to
-         * `ClipperLib.ClipType.ctIntersection` and `.ctUnion` respectively at runtime
-         */
-        clipType?: ClipperLib.ClipType | WeilerAthertonClipper.CLIP_TYPES | null | undefined;
-
-        /**
-         * Use the Weiler-Atherton algorithm. Otherwise, use Clipper.
-         * @defaultValue `true`
-         */
-        weilerAtherton: false;
-      }
-    }
-
-    class Rectangle extends _PIXI.Rectangle {
-      /**
-       * Create normalized rectangular bounds given a rectangle shape and an angle of central rotation.
-       * @param x       - The top-left x-coordinate of the un-rotated rectangle
-       * @param y       - The top-left y-coordinate of the un-rotated rectangle
-       * @param width   - The width of the un-rotated rectangle
-       * @param height  - The height of the un-rotated rectangle
-       * @param radians - The angle of rotation about the center
-       * @param pivot   - An optional pivot point (if not provided, the pivot is the centroid)
-       * @param _outRect - (Internal)
-       * @returns The constructed rotated rectangle bounds
-       */
-      static fromRotation(
-        x: number,
-        y: number,
-        width: number,
-        height: number,
-        radians: number,
-        pivot?: PIXI.Point,
-        _outRect?: PIXI.Rectangle,
-      ): PIXI.Rectangle;
-    }
-  }
-}