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

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-sprite-mesh.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial, NullishProps } from "fvtt-types/utils";
+import type { Identity, InexactPartial, NullishProps } from "fvtt-types/utils";
 
 declare global {
   /**
@@ -121,7 +121,7 @@ declare global {
 
   namespace PrimarySpriteMesh {
     interface Any extends AnyPrimarySpriteMesh {}
-    type AnyConstructor = typeof AnyPrimarySpriteMesh;
+    interface AnyConstructor extends Identity<typeof AnyPrimarySpriteMesh> {}
 
     type FitType = "fill" | "cover" | "contain" | "width" | "height";
 
@@ -154,7 +154,7 @@ declare global {
        * @remarks Default via `?? null` in function body
        * @privateRemarks Foundry types as `*`, but the only things passed in practice are `Tile`s, `Token`s, and the `PrimaryCanvasGroup`
        */
-      //TODO: (esheyw) Revisit the "any canvas group" type when groups are done
+      // TODO: (esheyw) Revisit the "any canvas group" type when groups are done
       object: PlaceableObject.Any | CanvasGroupMixin.AnyMixed;
     }>;
 
@@ -190,5 +190,5 @@ declare global {
 }
 
 declare abstract class AnyPrimarySpriteMesh extends PrimarySpriteMesh {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

package/src/foundry/client/pixi/placeables/region.d.mts

@@ -1,85 +1,50 @@
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
-import type { Brand, FixedInstanceType } from "fvtt-types/utils";
-import type RegionShape from "../../../client-esm/canvas/regions/shape.d.mts";
-import type RegionPolygonTree from "../../../client-esm/canvas/regions/polygon-tree.d.mts";
-import type RegionGeometry from "../../../client-esm/canvas/regions/geometry.d.mts";
-import type { Point } from "../../../common/_types.d.mts";
+import type { Brand, FixedInstanceType, HandleEmptyObject, NullishProps } from "fvtt-types/utils";
+import type RegionShape from "#client-esm/canvas/regions/shape.d.mts";
+import type RegionPolygonTree from "#client-esm/canvas/regions/polygon-tree.d.mts";
+import type RegionGeometry from "#client-esm/canvas/regions/geometry.d.mts";
+import type { Point } from "#common/_types.d.mts";
 
 declare global {
-  namespace Region {
-    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Region>;
-    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
-
-    interface RenderFlags extends PlaceableObject.RenderFlags {}
-
-    interface RegionMovementWaypoint {
-      /** The x-coordinates in pixels (integer) */
-      x: number;
-
-      /** The y-coordinates in pixels (integer) */
-      y: number;
-
-      /** The elevation in grid units. */
-      elevation: number;
-    }
-
-    interface RegionMovementSegment {
-      /** The type of htis segment (see {@link Region.MovementSegmentTypes}) */
-      type: number;
-
-      /** The waypoint that this segment starts from */
-      from: RegionMovementWaypoint;
-
-      /** The waypoint that this segment goes to */
-      to: RegionMovementWaypoint;
-    }
-
-    type MOVEMENT_SEGMENT_TYPES = Brand<number, "Region.MOVEMENT_SEGMENT_TYPES">;
-
-    interface MovementSegmentTypes
-      extends Readonly<{
-        /**
-         * The segment crosses the boundary of the region and exits it.
-         */
-        EXIT: -1 & MOVEMENT_SEGMENT_TYPES;
-
-        /**
-         * The segment does not cross the boundary of the region and is contained within it.
-         */
-        MOVE: 0 & MOVEMENT_SEGMENT_TYPES;
-
-        /**
-         * The segment crosses the boundary of the region and enters it.
-         */
-        ENTER: 1 & MOVEMENT_SEGMENT_TYPES;
-      }> {}
-  }
-
-  class Region extends PlaceableObject<RegionDocument.ConfiguredInstance> {
-    #region: true;
-
-    constructor(document: RegionDocument.ConfiguredInstance);
+  /**
+   * A Region is an implementation of PlaceableObject which represents a Region document
+   * within a viewed Scene on the game canvas.
+   * @see {@link RegionDocument | `RegionDocument`}
+   * @see {@link RegionLayer | `RegionLayer`}
+   */
+  class Region extends PlaceableObject<RegionDocument.Implementation> {
+    constructor(document: RegionDocument.Implementation);
+
+    // fake override; super has to type as if this could be a ControlIcon, but Regions don't use one
+    override controlIcon: null;
 
     static override embeddedName: "Region";
 
-    static override RENDER_FLAGS: {
-      /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Region.RenderFlags>;
+    static override RENDER_FLAGS: Region.RENDER_FLAGS;
 
-      /** @defaultValue `{ propagate: ["refreshState", "refreshBorder"], alias: true }` */
-      refresh: RenderFlag<Region.RenderFlags>;
+    // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
+    // `RENDER_FLAGS` and so it has to be adjusted here.
+    renderFlags: RenderFlags<Region.RENDER_FLAGS>;
 
-      /** @defaultValue `{}` */
-      refreshState: RenderFlag<Region.RenderFlags>;
-
-      /** @defaultValue `{}` */
-      refreshBorder: RenderFlag<Region.RenderFlags>;
-    };
+    /**
+     * The scaling factor used for Clipper paths.
+     * @defaultValue `100`
+     * @remarks Defined using `Object.defineProperty` in a static initialization block
+     */
+    static readonly CLIPPER_SCALING_FACTOR: 100;
 
-    static CLIPPER_SCALING_FACTOR: number;
-    static MOVEMENT_SEGMENT_TYPES: Region.MOVEMENT_SEGMENT_TYPES;
+    /**
+     * The three movement segment types: ENTER, MOVE, and EXIT.
+     * @remarks Defined using `Object.defineProperty` in a static initialization block
+     */
+    static readonly MOVEMENT_SEGMENT_TYPES: Region.MovementSegmentTypes;
 
-    get shapes(): ReadonlyArray<RegionShape.Any>;
+    /**
+     * The shapes of this Region in draw order.
+     * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get shapes(): RegionShape.Any[];
 
     /** The bottom elevation of this Region. */
     get bottom(): number;
@@ -87,17 +52,29 @@ declare global {
     /** The top elevation of this Region. */
     get top(): number;
 
-    /** The polygons of this Region. */
-    get polygons(): ReadonlyArray<PIXI.Polygon>;
+    /**
+     * The polygons of this Region.
+     * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get polygons(): PIXI.Polygon[];
 
     /** The polygon tree of this Region. */
     get polygonTree(): RegionPolygonTree;
 
-    /** The Clipper paths of this Region. */
-    get clipperPaths(): ReadonlyArray<ReadonlyArray<ClipperLib.IntPoint>>;
+    /**
+     * The Clipper paths of this Region.
+     * @privateRemarks Foundry types this as `ReadonlyArray<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get clipperPaths(): ClipperLib.Paths;
 
-    /** The triangulation of this Region */
-    get triangulation(): ReadonlyArray<{ vertices: Float32Array; indices: Uint16Array | Uint32Array }>;
+    /**
+     * The triangulation of this Region
+     * @privateRemarks Foundry types this as `Readonly<>`, but does nothing to that effect at runtime.
+     * Not reported, as this is deprecated and thus untyped in v13
+     */
+    get triangulation(): Region.TriangulationData;
 
     /** The geometry of this Region */
     get geometry(): RegionGeometry;
@@ -110,13 +87,16 @@ declare global {
     get isVisible(): boolean;
 
     /**
-     * @throws      - Region#getSnappedPosition is not supported: RegionDocument does not have a (x, y) position
+     * @throws "`Region#getSnappedPosition` is not supported: `RegionDocument` does not have a (x, y) position"
      */
-    override getSnappedPosition(position?: Canvas.Point): never;
+    override getSnappedPosition(position?: never): never;
 
-    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<Region.DrawOptions>): Promise<void>;
 
-    protected override _applyRenderFlags(flags: PlaceableObject.RenderFlags): void;
+    // fake override; super has to account for misbehaving siblings returning void
+    override clear(): this;
+
+    protected override _applyRenderFlags(flags: Region.RenderFlags): void;
 
     /** Refresh the state of the Region. */
     protected _refreshState(): void;
@@ -124,18 +104,19 @@ declare global {
     /** Refreshes the border of the Region. */
     protected _refreshBorder(): void;
 
-    protected override _canDrag(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent | null): boolean;
+    protected override _canDrag(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
 
-    protected override _canHUD(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent | null): boolean;
+    protected override _canHUD(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
 
-    protected override _onControl(options?: PlaceableObject.ControlOptions | null): void;
+    protected override _onControl(options: Region.ControlOptions): void;
 
-    protected override _onRelease(options?: PlaceableObject.ReleaseOptions | null): void;
+    protected override _onRelease(options: HandleEmptyObject<Region.ReleaseOptions>): void;
 
-    /** @remarks options cannot accept null because defaults are provided with `options={}` in the parameters  */
-    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): false | void;
+    // options: not null (destructured)
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: Region.HoverInOptions): void;
 
-    protected override _onHoverOut(event: PIXI.FederatedEvent): boolean | void;
+    // options: not null (destructured)
+    protected override _onHoverOut(event: PIXI.FederatedEvent, options?: Region.HoverOutOptions): void;
 
     protected override _overlapsSelection(rectangle: PIXI.Rectangle): boolean;
 
@@ -143,35 +124,163 @@ declare global {
      * Test whether the given point (at the given elevation) is inside this Region.
      * @param point       - The point.
      * @param elevation   - The elevation of the point.
-     * @returns           - Is the point (at the given elevation) inside this Region?
-     * @remarks elevation cannot be null because it is explicitly checked against undefined (===) in function body.
+     * @returns Is the point (at the given elevation) inside this Region?
+     * @remarks Only tests elevation if provided, always forwards `position` to {@link RegionPolygonTree.testPoint | `RegionPolygonTree#testPoint`}
      */
-    testPoint(point: Point, elevation?: number): boolean;
+    // elevation: not null (`=== undefined` check)
+    testPoint(point: Canvas.Point, elevation?: number): boolean;
 
     /**
      * Split the movement into its segments.
-     * @param waypoints                     - The waypoints of movement.
-     * @param samples                       - The points relative to the waypoints that are tested.
-     *                                        Whenever one of them is inside the region, the moved object
-     *                                        is considered to be inside the region.
-     * @returns                             - The movement split into its segments.
+     * @param waypoints - The waypoints of movement.
+     * @param samples   - The points relative to the waypoints that are tested. Whenever one of them is inside the region, the moved object is considered to be inside the region.
+     * @param options   - Additional options
+     * @returns The movement split into its segments.
      */
+    // options: not null (destructured)
     segmentizeMovement(
-      waypoints: Region.RegionMovementWaypoint[],
-      samples: Point[],
-      options?: {
-        /**
-         * Is it teleportation?
-         * @remarks options cannot accept null because defaults are provided with `options={}` in the parameters.
-         * @defaultValue `false`
-         */
-        teleport?: boolean | undefined;
-      },
-    ): Region.RegionMovementSegment[];
+      waypoints: Region.MovementWaypoint[],
+      samples: Canvas.Point[],
+      options?: Region.SegmentizeMovementOptions,
+    ): Region.MovementSegment[];
+
+    // _onUpdate is overridden but with no signature changes.
+    // For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+
+    // fake override to narrow the type from super, which had to account for this class's misbehaving siblings
+    protected override _prepareDragLeftDropUpdates(event: PIXI.FederatedEvent): PlaceableObject.DragLeftDropUpdate[];
+  }
+
+  namespace Region {
+    /**
+     * The implementation of the `Region` placeable configured through `CONFIG.Region.objectClass`
+     * in Foundry and {@link PlaceableObjectClassConfig | `PlaceableObjectClassConfig`} in fvtt-types.
+     *
+     * Not to be confused with {@link RegionDocument.Implementation | `RegionDocument.Implementation`}
+     * which refers to the implementation for the region document.
+     */
+    type Implementation = FixedInstanceType<ImplementationClass>;
 
     /**
-     * @privateRemarks _onUpdate is overridden but with no signature changes.
-     * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+     * The implementation of the `Region` placeable configured through `CONFIG.Region.objectClass`
+     * in Foundry and {@link PlaceableObjectClassConfig | `PlaceableObjectClassConfig`} in fvtt-types.
+     *
+     * Not to be confused with {@link RegionDocument.ImplementationClass | `RegionDocument.ImplementationClass`}
+     * which refers to the implementation for the region document.
      */
+    // eslint-disable-next-line no-restricted-syntax
+    type ImplementationClass = ConfiguredObjectClassOrDefault<typeof Region>;
+
+    /**
+     * @deprecated {@link ImplementationClass | `ImplementationClass`}
+     */
+    type ObjectClass = ImplementationClass;
+
+    /**
+     * @deprecated {@link Implementation | `Implementation`}
+     */
+    type Object = Implementation;
+
+    /**
+     * @deprecated {@link Region.ImplementationClass | `Region.ImplementationClass`}
+     */
+    type ConfiguredClass = ImplementationClass;
+
+    /**
+     * @deprecated {@link Region.Implementation | `Region.Implementation`}
+     */
+    type ConfiguredInstance = Implementation;
+
+    interface RENDER_FLAGS {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<this, "redraw">;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshBorder"], alias: true }` */
+      refresh: RenderFlag<this, "refresh">;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<this, "refreshState">;
+
+      /** @defaultValue `{}` */
+      refreshBorder: RenderFlag<this, "refreshBorder">;
+    }
+
+    interface RenderFlags extends RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS> {}
+
+    interface TriangulationData {
+      vertices: Float32Array;
+      indices: Uint16Array | Uint32Array;
+    }
+
+    interface DrawOptions extends PlaceableObject.DrawOptions {}
+
+    interface RefreshOptions extends PlaceableObject.RefreshOptions {}
+
+    interface ControlOptions extends PlaceableObject.ControlOptions {}
+
+    interface ReleaseOptions extends PlaceableObject.ReleaseOptions {}
+
+    type _HoverInOptions = NullishProps<{
+      /** @defaultValue `true` */
+      updateLegend: boolean;
+    }>;
+
+    interface HoverInOptions extends _HoverInOptions, PlaceableObject.HoverInOptions {}
+
+    interface HoverOutOptions extends _HoverInOptions {}
+
+    interface MovementWaypoint {
+      /** The x-coordinates in pixels (integer) */
+      x: number;
+
+      /** The y-coordinates in pixels (integer) */
+      y: number;
+
+      /** The elevation in grid units. */
+      elevation: number;
+    }
+
+    interface MovementSegment {
+      /** The type of this segment (see {@link Region.MovementSegmentTypes | `Region.MovementSegmentTypes`}) */
+      type: MOVEMENT_SEGMENT_TYPES;
+
+      /** The waypoint that this segment starts from */
+      from: MovementWaypoint;
+
+      /** The waypoint that this segment goes to */
+      to: MovementWaypoint;
+    }
+
+    type MOVEMENT_SEGMENT_TYPES = Brand<number, "Region.MOVEMENT_SEGMENT_TYPES">;
+
+    interface MovementSegmentTypes
+      extends Readonly<{
+        /**
+         * The segment crosses the boundary of the region and exits it.
+         */
+        EXIT: -1 & MOVEMENT_SEGMENT_TYPES;
+
+        /**
+         * The segment does not cross the boundary of the region and is contained within it.
+         */
+        MOVE: 0 & MOVEMENT_SEGMENT_TYPES;
+
+        /**
+         * The segment crosses the boundary of the region and enters it.
+         */
+        ENTER: 1 & MOVEMENT_SEGMENT_TYPES;
+      }> {}
+
+    /** @internal */
+    type _SegmentizeMovementOptions = NullishProps<{
+      /**
+       * Is it teleportation?
+       * @defaultValue `false`
+       * @remarks Can't be `null` because it only has a parameter default
+       */
+      teleport: boolean;
+    }>;
+
+    interface SegmentizeMovementOptions extends _SegmentizeMovementOptions {}
   }
 }