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

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

@@ -0,0 +1,130 @@
+/** The node of a {@link RegionPolygonTree | `RegionPolygonTree`}.*/
+declare class RegionPolygonTreeNode {
+  /**
+   * Create a RegionPolygonTreeNode.
+   * @param parent    - The parent node.
+   * @remarks Foundry marked `@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.
+   * @remarks Foundry marked `@internal`, called exclusively  {@link RegionPolygonTree._fromClipperPolyTree | `RegionPolygonTree._fromClipperPolyTree`}
+   */
+  protected static _fromClipperPath(
+    clipperPath: ClipperLib.Path,
+    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.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.#children`
+   */
+  get children(): 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.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.#clipperPath`
+   */
+  get clipperPath(): ClipperLib.Path | 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.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.polygon.points`
+   */
+  get points(): number[] | null;
+
+  /**
+   * The bounds of the polygon.
+   *
+   * They are `null` in case of the root node.
+   */
+  get bounds(): PIXI.Rectangle | null;
+
+  /** @privateRemarks Recursively iterates all child nodes */
+  [Symbol.iterator](): Generator<RegionPolygonTreeNode>;
+
+  /**
+   * Test whether given point is contained within this node.
+   * @param point - The point.
+   */
+  testPoint(point: Canvas.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: Canvas.Point, radius: number): -1 | 0 | 1;
+}
+
+declare namespace RegionPolygonTreeNode {
+  interface Any extends AnyRegionPolygonTreeNode {}
+  type AnyConstructor = typeof AnyRegionPolygonTreeNode;
+}
+
+/** The polygon tree of a {@link Region | `Region`}. */
+declare class RegionPolygonTree extends RegionPolygonTreeNode {
+  /**
+   * Create a RegionPolygonTree
+   * @remarks Foundry marked `@internal`
+   */
+  constructor();
+
+  /**
+   * Create the tree from a Clipper polygon tree.
+   * @remarks Foundry marked `@internal`, called exclusively from {@link Region#polygonTree | `Region#polygonTree`}
+   */
+  protected static _fromClipperPolyTree(clipperPolyTree: ClipperLib.PolyTree): RegionPolygonTree;
+}
+
+declare namespace RegionPolygonTree {
+  interface Any extends AnyRegionPolygonTree {}
+  type AnyConstructor = typeof AnyRegionPolygonTree;
+}
+
+declare abstract class AnyRegionPolygonTreeNode extends RegionPolygonTreeNode {
+  constructor(...args: never);
+}
+
+declare abstract class AnyRegionPolygonTree extends RegionPolygonTree {
+  constructor(...args: never);
+}
+
+export default RegionPolygonTree;

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

@@ -0,0 +1,129 @@
+import type { CircleShapeData, EllipseShapeData, PolygonShapeData, RectangleShapeData } from "../../data/_module.d.mts";
+
+/** A shape of a {@link Region | `Region`} */
+declare abstract class RegionShape<ShapeData extends RegionShape.ShapeData> {
+  /**
+   * 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.
+   * @remarks Foundry types this as `ReadonlyArray<>`, but does nothing to prevent writes
+   * at runtime, just returning a reference to `this.#clipperPaths`
+   */
+  get clipperPaths(): ClipperLib.Paths;
+
+  /** 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-self-intersecting 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.
+   * @remarks Despite Foundry typing this as possibly returning a `PolyTree`, all four core subclasses return `Path`s,
+   * relying on the {@link RegionShape.clipperPolyTree | `#clipperPolyTree`} getter to convert and cache it.
+   */
+  protected abstract _createClipperPolyTree(): ClipperLib.PolyTree | ClipperLib.Path;
+
+  /**
+   * Draw shape into the graphics.
+   * @param graphics  - The graphics to draw the shape into.
+   * @remarks Foundry marked `@internal` but not `@abstract`, despite it throwing if not overridden
+   */
+  protected abstract _drawShape(graphics: PIXI.Graphics): void;
+}
+
+declare namespace RegionShape {
+  interface Any extends AnyRegionShape {}
+  type AnyConstructor = typeof AnyRegionShape;
+
+  type ShapeData = CircleShapeData | EllipseShapeData | PolygonShapeData | RectangleShapeData;
+
+  type CreatedRegionShape<ShapeData extends RegionShape.ShapeData> =
+    | (ShapeData extends CircleShapeData ? RegionCircle<ShapeData> : never)
+    | (ShapeData extends EllipseShapeData ? RegionEllipse<ShapeData> : never)
+    | (ShapeData extends PolygonShapeData ? RegionPolygon<ShapeData> : never)
+    | (ShapeData extends RectangleShapeData ? RegionRectangle<ShapeData> : never);
+}
+
+/**
+ * A circle of a {@link Region | `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.Path;
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+
+/**
+ * An ellipse of a {@link Region | `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.Path;
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+
+/**
+ * A polygon of a {@link Region | `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.Path;
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+
+/**
+ * A rectangle of a {@link Region | `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.Path;
+
+  protected override _drawShape(graphics: PIXI.Graphics): void;
+}
+
+// Only RegionShape is exported, so `Any_` classes and types for the subclasses have been omitted
+declare abstract class AnyRegionShape extends RegionShape<RegionShape.ShapeData> {
+  constructor(...args: never);
+}
+
+export default RegionShape;

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

@@ -1,3 +1,4 @@
+import type { AnyFunction, Identity } from "fvtt-types/utils";
 /**
  * A framework for imbuing special scripted behaviors into a single specific Scene.
  * Managed scenes are registered in CONFIG.Canvas.managedScenes.
@@ -46,22 +47,22 @@ declare class SceneManager {
   /**
    * The SceneManager is constructed by passing a reference to the active Scene document.
    */
-  constructor(scene: Scene);
+  constructor(scene: Scene.Implementation);
 
   /**
    * The managed Scene
    */
-  get scene(): Scene.ConfiguredInstance;
+  get scene(): Scene.Implementation;
 
   /**
    * Additional behaviors to perform when the Canvas is first initialized for the Scene.
    */
-  protected _onInit(): Promise<void>
+  protected _onInit(): Promise<void>;
 
   /**
    * Additional behaviors to perform after core groups and layers are drawn to the canvas.
    */
-  protected _onDraw(): Promise<void>
+  protected _onDraw(): Promise<void>;
 
   /**
    * Additional behaviors to perform after the Canvas is fully initialized for the Scene.
@@ -71,7 +72,7 @@ declare class SceneManager {
   /**
    * Additional behaviors to perform when the Scene is deactivated.
    */
-  protected _onTearDown(): Promise<void>
+  protected _onTearDown(): Promise<void>;
 
   /**
    * Register additional hook functions are only used while this Scene is active and is automatically deactivated.
@@ -82,7 +83,7 @@ declare class SceneManager {
   /**
    * Register additional hook functions are only used while this Scene is active and is automatically deactivated.
    */
-  registerHooks(hookName: string, handler: (...args: unknown[]) => unknown): void;
+  registerHooks(hookName: string, handler: AnyFunction): void;
 
   /**
    * Deactivate Hook functions that were added specifically for this Scene.
@@ -90,4 +91,13 @@ declare class SceneManager {
   protected _deactivateHooks(): void;
 }
 
+declare namespace SceneManager {
+  interface Any extends AnySceneManager {}
+  interface AnyConstructor extends Identity<typeof AnySceneManager> {}
+}
+
+declare abstract class AnySceneManager extends SceneManager {
+  constructor(...args: never);
+}
+
 export default SceneManager;

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

@@ -1,6 +1,17 @@
 /**
- * The blending weight calculation filter for {@link foundry.canvas.SMAAFilter}.
+ * The neighborhood blending filter for {@link foundry.canvas.SMAAFilter | `foundry.canvas.SMAAFilter`}.
  */
-export default class SMAABWeightCalculationFilter extends PIXI.Filter {
-  constructor(config: foundry.canvas.SMAAFilter.SMAAFilterConfig);
+declare class SMAANeighborhoodBlendingFilter extends PIXI.Filter {
+  constructor();
 }
+
+declare namespace SMAANeighborhoodBlendingFilter {
+  interface Any extends AnySMAANeighborhoodBlendingFilter {}
+  type AnyConstructor = typeof AnySMAANeighborhoodBlendingFilter;
+}
+
+declare abstract class AnySMAANeighborhoodBlendingFilter extends SMAANeighborhoodBlendingFilter {
+  constructor(...args: never);
+}
+
+export default SMAANeighborhoodBlendingFilter;

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

@@ -1,6 +1,28 @@
+import type { IntentionalPartial, RequiredProps } from "../../../../utils/index.d.mts";
+
 /**
- * The edge detection filter for {@link foundry.canvas.SMAAFilter}.
+ * The edge detection filter for {@link foundry.canvas.SMAAFilter | `foundry.canvas.SMAAFilter`}.
  */
-export default class SMAAEdgeDetectionFilter extends PIXI.Filter {
-  constructor(config: foundry.canvas.SMAAFilter.SMAAFilterConfig);
+declare class SMAAEdgeDetectionFilter extends PIXI.Filter {
+  constructor(config: SMAAEdgeDetectionFilter.Config);
 }
+
+declare namespace SMAAEdgeDetectionFilter {
+  interface Any extends AnySMAAEdgeDetectionFilter {}
+  type AnyConstructor = typeof AnySMAAEdgeDetectionFilter;
+
+  /**
+   * @privateRemarks The SMAAEdgeDetectionFilter constructor passes `config` to an unexported local
+   * function that only uses two properties of the interface
+   */
+  type Config = RequiredProps<
+    IntentionalPartial<foundry.canvas.SMAAFilter.Config>,
+    "threshold" | "localContrastAdaptionFactor"
+  >;
+}
+
+declare abstract class AnySMAAEdgeDetectionFilter extends SMAAEdgeDetectionFilter {
+  constructor(...args: never);
+}
+
+export default SMAAEdgeDetectionFilter;

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

@@ -1,56 +1,154 @@
-import type { CLEAR_MODES, FilterState, FilterSystem, RenderTexture } from "pixi.js";
-
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { Brand, InexactPartial } from "fvtt-types/utils";
 
 declare class SMAAFilter extends PIXI.Filter {
   /**
-   * @param config    - The config (defaults: SMAAFilter.PRESETS.DEFAULT)
+   * @param config - The config
+   * @remarks The one place Foundry makes one of these it passes no config
+   * @privateRemarks Foundry references `SMAAFilter.PRESETS.DEFAULT` as the default values for `config`,
+   * but that key does not exist in 12.331 or 11.315, and appears to just be a docs error.
    */
-  constructor(config?: InexactPartial<SMAAFilter.SMAAFilterConfig>);
+  // config: not null (destructured)
+  constructor(config?: SMAAFilter.ConstructorOptions);
 
   // a placeholder private method to help subclassing
   #smaaFilter: true;
 
   /**
    * The presets.
+   * @remarks Unused in 12.331
    */
-  static get PRESETS(): Record<string, SMAAFilter.SMAAFilterConfig>;
-
-  /** @override */
-  apply(
-    filterManager: FilterSystem,
-    input: RenderTexture,
-    output: RenderTexture,
-    clearMode: CLEAR_MODES | undefined,
-    currentState: FilterState,
+  static get PRESETS(): SMAAFilter.Presets;
+
+  override apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clearMode: PIXI.CLEAR_MODES | undefined,
+    currentState: PIXI.FilterState,
   ): void;
 }
 
 declare namespace SMAAFilter {
-  interface SMAAFilterConfig {
-    /** Specifies the threshold or sensitivity to edges. Lowering this value you will be able to detect more edges at the expense of performance. Range: [0, 0.5]. 0.1 is a reasonable value, and allows to catch most visible edges. 0.05 is a rather overkill value, that allows to catch 'em all. */
+  interface Any extends AnySMAAFilter {}
+  type AnyConstructor = typeof AnySMAAFilter;
+
+  type PRESETS = Brand<Config, "SMAAFilter.PRESETS">;
+
+  interface Presets {
+    LOW: {
+      threshold: 0.15;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 4;
+      maxSearchStepsDiag: 0;
+      cornerRounding: 0;
+      disableDiagDetection: true;
+      disableCornerDetection: true;
+    } & PRESETS;
+    MEDIUM: {
+      threshold: 0.1;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 8;
+      maxSearchStepsDiag: 0;
+      cornerRounding: 0;
+      disableDiagDetection: true;
+      disableCornerDetection: true;
+    } & PRESETS;
+    HIGH: {
+      threshold: 0.1;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 16;
+      maxSearchStepsDiag: 8;
+      cornerRounding: 25;
+      disableDiagDetection: false;
+      disableCornerDetection: false;
+    } & PRESETS;
+    ULTRA: {
+      threshold: 0.05;
+      localContrastAdaptionFactor: 2.0;
+      maxSearchSteps: 32;
+      maxSearchStepsDiag: 16;
+      cornerRounding: 25;
+      disableDiagDetection: false;
+      disableCornerDetection: false;
+    } & PRESETS;
+  }
+
+  interface Config {
+    /**
+     * Specifies the threshold or sensitivity to edges. Lowering this value you will be able to detect more
+     * edges at the expense of performance.
+     *
+     * Range: [0, 0.5].
+     *
+     * 0.1 is a reasonable value, and allows to catch
+     * most visible edges. 0.05 is a rather overkill value, that allows to catch 'em all.
+     * @defaultValue `0.1`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     threshold: number;
 
-    /** If there is an neighbor edge that has SMAA_LOCAL_CONTRAST_FACTOR times bigger contrast than current edge, current edge will be discarded.
-     *  This allows to eliminate spurious crossing edges, and is based on the fact that, if there is too much contrast in a direction, that will hide perceptually contrast in the other neighbors.
+    /**
+     * If there is an neighbor edge that has SMAA_LOCAL_CONTRAST_FACTOR times bigger contrast than current
+     * edge, current edge will be discarded. This allows to eliminate spurious crossing edges, and is based
+     * on the fact that, if there is too much contrast in a direction, that will hide perceptually contrast
+     * in the other neighbors.
+     * @defaultValue `2.0`
+     * @remarks Can't be `null` as it only has a parameter default
      */
     localContrastAdaptionFactor: number;
 
-    /** Specifies the maximum steps performed in the horizontal/vertical pattern searches, at each side of the pixel. In number of pixels, it's actually the double. So the maximum line length perfectly handled by, for example 16, is 64 (by perfectly, we meant that longer lines won't look as good, but still antialiased. Range: [0, 112]. */
+    /**
+     * Specifies the maximum steps performed in the horizontal/vertical pattern searches, at each side of the
+     * pixel. In number of pixels, it's actually the double. So the maximum line length perfectly handled by,
+     * for example 16, is 64 (by perfectly, we meant that longer lines won't look as good, but still antialiased).
+     *
+     * Range: [0, 112].
+     * @defaultValue `16`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     maxSearchSteps: number;
 
-    /** Specifies the maximum steps performed in the diagonal pattern searches, at each side of the pixel. In this case we jump one pixel at time, instead of two. Range: [0, 20]. */
+    /**
+     * Specifies the maximum steps performed in the diagonal pattern searches, at each side of the pixel. In this
+     * case we jump one pixel at time, instead of two.
+     *
+     * Range: [0, 20].
+     * @defaultValue `8`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     maxSearchStepsDiag: number;
 
-    /** Specifies how much sharp corners will be rounded. Range: [0, 100]. */
+    /**
+     * Specifies how much sharp corners will be rounded.
+     *
+     * Range: [0, 100].
+     * @defaultValue `25`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     cornerRounding: number;
 
-    /** Is diagonal detection disabled? */
+    /**
+     * Is diagonal detection disabled?
+     * @defaultValue `false`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     disableDiagDetection: boolean;
 
-    /** Is corner detection disabled? */
+    /**
+     * Is corner detection disabled?
+     * @defaultValue `false`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
     disableCornerDetection: boolean;
   }
+
+  type _ConstructorOptions = InexactPartial<Config>;
+
+  interface ConstructorOptions extends _ConstructorOptions {}
+}
+
+declare abstract class AnySMAAFilter extends SMAAFilter {
+  constructor(...args: never);
 }
 
 export default SMAAFilter;

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

@@ -1,6 +1,29 @@
+import type { Identity, IntentionalPartial, RequiredProps } from "../../../../utils/index.d.mts";
+
 /**
- * The neighborhood blending filter for {@link foundry.canvas.SMAAFilter}.
+ * The blending weight calculation filter for {@link foundry.canvas.SMAAFilter | `foundry.canvas.SMAAFilter`}.
  */
-export default class SMAANeighborhoodBlendingFilter extends PIXI.Filter {
-  constructor();
+declare class SMAABWeightCalculationFilter extends PIXI.Filter {
+  constructor(config: SMAABWeightCalculationFilter.Config);
 }
+
+declare namespace SMAABWeightCalculationFilter {
+  interface Any extends AnySMAABWeightCalculationFilter {}
+  interface AnyConstructor extends Identity<typeof AnySMAABWeightCalculationFilter> {}
+
+  type Config = RequiredProps<
+    IntentionalPartial<foundry.canvas.SMAAFilter.Config>,
+    | "maxSearchSteps"
+    | "threshold"
+    | "maxSearchStepsDiag"
+    | "cornerRounding"
+    | "disableCornerDetection"
+    | "disableDiagDetection"
+  >;
+}
+
+declare abstract class AnySMAABWeightCalculationFilter extends SMAABWeightCalculationFilter {
+  constructor(...args: never);
+}
+
+export default SMAABWeightCalculationFilter;

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";