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

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

@@ -0,0 +1,184 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { WallThresholdData } from "../../../common/documents/_types.d.mts";
+
+/**
+ * A data structure used to represent potential edges used by the ClockwiseSweepPolygon.
+ * Edges are not polygon-specific, meaning they can be reused across many polygon instances.
+ */
+declare class Edge {
+  /**
+   * Construct an Edge by providing the following information.
+   * @param a - The first endpoint of the edge
+   * @param b - The second endpoint of the edge
+   * @param options - Additional options which describe the edge
+   */
+  constructor(
+    a: Canvas.Point,
+    b: Canvas.Point,
+    options?: InexactPartial<{
+      /** A string used to uniquely identify this edge */
+      id?: string;
+      /** A PlaceableObject that is responsible for this edge, if any */
+      object?: PlaceableObject;
+      /** The type of edge */
+      type?: Edge.EdgeTypes;
+      /** How this edge restricts light */
+      light?: foundry.CONST.WALL_SENSE_TYPES;
+      /** How this edge restricts movement */
+      move?: foundry.CONST.WALL_SENSE_TYPES;
+      /** How this edge restricts sight */
+      sight?: foundry.CONST.WALL_SENSE_TYPES;
+      /** How this edge restricts sound */
+      sound?: foundry.CONST.WALL_SENSE_TYPES;
+      /**
+       * A direction of effect for the edge
+       * @defaultValue `0`
+       */
+      direction?: foundry.CONST.WALL_DIRECTIONS;
+      /** Configuration of threshold data for this edge */
+      threshold?: WallThresholdData;
+    }>,
+  );
+
+  /**
+   * The first endpoint of the edge.
+   */
+  a: PIXI.Point;
+
+  /**
+   * The second endpoint of the edge.
+   */
+  b: PIXI.Point;
+
+  /**
+   * A string used to uniquely identify this edge.
+   */
+  id: string;
+
+  object: PlaceableObject;
+
+  type: Edge.EdgeTypes;
+
+  /**
+   * The direction of effect for the edge.
+   */
+  direction: foundry.CONST.WALL_DIRECTIONS;
+
+  /**
+   * How this edge restricts light.
+   */
+  light: foundry.CONST.WALL_SENSE_TYPES;
+
+  /**
+   * How this edge restricts movement.
+   */
+  move: foundry.CONST.WALL_SENSE_TYPES;
+
+  /**
+   * How this edge restricts sight.
+   */
+  sight: foundry.CONST.WALL_SENSE_TYPES;
+
+  /**
+   * How this edge restricts sound.
+   */
+  sound: foundry.CONST.WALL_SENSE_TYPES;
+
+  /**
+   * Specialized threshold data for this edge.
+   */
+  threshold: WallThresholdData;
+
+  /**
+   * The endpoint of the edge which is oriented towards the top-left.
+   */
+  nw: Canvas.Point;
+
+  /**
+   * The endpoint of the edge which is oriented towards the bottom-right.
+   */
+  se: Canvas.Point;
+
+  /**
+   * The rectangular bounds of the edge. Used by the quadtree.
+   */
+  bounds: PIXI.Rectangle;
+
+  /**
+   * Record other edges which this one intersects with.
+   */
+  intersections: {
+    edge: Edge;
+    intersection: foundry.utils.LineIntersection;
+  }[];
+
+  /**
+   * A PolygonVertex instance.
+   * Used as part of ClockwiseSweepPolygon computation.
+   */
+  vertexA: foundry.canvas.edges.PolygonVertex;
+
+  /**
+   * A PolygonVertex instance.
+   * Used as part of ClockwiseSweepPolygon computation.
+   */
+  vertexB: foundry.canvas.edges.PolygonVertex;
+
+  /**
+   * Is this edge limited for a particular type?
+   */
+  isLimited(type: "direction" | "light" | "move" | "sight" | "sound"): boolean;
+
+  /**
+   * Create a copy of the Edge which can be safely mutated.
+   */
+  clone(): Edge;
+
+  /**
+   * Get an intersection point between this Edge and another.
+   */
+  getIntersection(other: Edge): foundry.utils.LineIntersection | void;
+
+  /**
+   * Test whether to apply a proximity threshold to this edge.
+   * If the proximity threshold is met, this edge excluded from perception calculations.
+   * @param sourceType     - Sense type for the source
+   * @param sourceOrigin   - The origin or position of the source on the canvas
+   * @param externalRadius - The external radius of the source
+   *                         (default: `0`)
+   * @returns True if the edge has a threshold greater than 0 for the source type,
+   *          and the source type is within that distance.
+   */
+  applyThreshold(sourceType: string, sourceOrigin: Canvas.Point, externalRadius?: number): boolean;
+
+  /**
+   * Determine the orientation of this Edge with respect to a reference point.
+   * @param point - Some reference point, relative to which orientation is determined
+   * @returns An orientation in CONST.WALL_DIRECTIONS which indicates whether the Point is left,
+   *          right, or collinear (both) with the Edge
+   */
+  orientPoint(point: Canvas.Point): foundry.CONST.WALL_DIRECTIONS;
+
+  /**
+   * Identify intersections between a provided iterable of edges.
+   * @param edges - An iterable of edges
+   */
+  static identifyEdgeIntersections(edges: Iterable<Edge>): void;
+
+  /**
+   * Record the intersections between two edges.
+   * @param other - Another edge to test and record
+   */
+  recordIntersections(other: Edge): void;
+
+  /**
+   * Remove intersections of this edge with all other edges.
+   */
+  removeIntersections(): void;
+}
+
+declare namespace Edge {
+  type EdgeTypes = "wall" | "darkness" | "innerBounds" | "outerBounds";
+}
+
+export default Edge;

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

@@ -0,0 +1,23 @@
+import type Edge from "./edge.d.mts";
+
+/**
+ * A special class of Map which defines all the edges used to restrict perception in a Scene.
+ */
+declare class CanvasEdges extends Map<string, Edge> {
+  /**
+   * Initialize all active edges for the Scene. This workflow occurs once only when the Canvas is first initialized.
+   * Edges are created from the following sources:
+   * 1. Wall documents
+   * 2. Canvas boundaries (inner and outer bounds)
+   * 3. Darkness sources
+   * 4. Programmatically defined in the "initializeEdges" hook
+   */
+  initialize(): void;
+
+  /**
+   * Incrementally refresh Edges by computing intersections between all registered edges.
+   */
+  refresh(): void;
+}
+
+export default CanvasEdges;

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

@@ -0,0 +1,136 @@
+import type Edge from "./edge.d.mts";
+
+/**
+ * A specialized point data structure used to represent vertices in the context of the ClockwiseSweepPolygon.
+ * This class is not designed or intended for use outside of that context.
+ * @internal
+ */
+declare class PolygonVertex {
+  constructor(x: number, y: number, { distance, index }?: PolygonVertex.Options);
+
+  x: number;
+
+  y: number;
+
+  key: number;
+
+  protected _distance: number | undefined;
+
+  protected _d2: undefined;
+
+  protected _index: number | undefined;
+
+  /**
+   * The set of edges which connect to this vertex.
+   * This set is initially empty and populated later after vertices are de-duplicated.
+   * @defaultValue `new Set()`
+   */
+  edges: EdgeSet;
+
+  /**
+   * The subset of edges which continue clockwise from this vertex.
+   * @defaultValue `new Set()`
+   */
+  cwEdges: EdgeSet;
+
+  /**
+   * The subset of edges which continue counter-clockwise from this vertex.
+   * @defaultValue `new Set()`
+   */
+  ccwEdges: EdgeSet;
+
+  /**
+   * The set of vertices collinear to this vertex
+   */
+  collinearVertices: Set<PolygonVertex>;
+
+  /**
+   * The maximum restriction type of this vertex
+   * @defaultValue `null`
+   */
+  type: number | null;
+
+  /**
+   * Is this vertex an endpoint of one or more edges?
+   */
+  isEndpoint: boolean | undefined;
+
+  /**
+   * Does this vertex have a single counterclockwise limiting edge?
+   */
+  isLimitingCCW: boolean | undefined;
+
+  /**
+   * Does this vertex have a single clockwise limiting edge?
+   */
+  isLimitingCW: boolean | undefined;
+
+  /**
+   * Does this vertex have non-limited edges or 2+ limited edges counterclockwise?
+   */
+  isBlockingCCW: boolean | undefined;
+
+  /**
+   * Does this vertex have non-limited edges or 2+ limited edges clockwise?
+   */
+  isBlockingCW: boolean | undefined;
+
+  /**
+   * Does this vertex result from an internal collision?
+   * @defaultValue `false`
+   */
+  isInternal: boolean;
+
+  /**
+   * The maximum restriction imposed by this vertex.
+   * @defaultValue `0`
+   * @remarks Possibly tied to `CONST.WALL_SENSE_TYPES`?
+   */
+  restriction: number;
+
+  /**
+   * Record whether this PolygonVertex has been visited in the sweep
+   * @defaultValue `false`
+   * @internal
+   */
+  _visited: boolean;
+
+  /**
+   * Is this vertex limited in type?
+   */
+  get isLimited(): boolean;
+
+  /**
+   * Associate an edge with this vertex.
+   * @param edge        - The edge being attached
+   * @param orientation - The orientation of the edge with respect to the origin
+   * @param type        - The restriction type of the polygon being created
+   */
+  attachEdge(edge: Edge, orientation: number, type: string): void;
+
+  /**
+   * Is this vertex terminal (at the maximum radius)
+   */
+  get isTerminal(): boolean;
+
+  /**declareme point?
+   */
+  equals(other: PolygonVertex): boolean;
+
+  /**
+   * Construct a PolygonVertex instance from some other Point structure.
+   * @param point   - The point
+   * @param options - Additional options that apply to this vertex
+   * @returns The constructed vertex
+   */
+  static fromPoint(point: Canvas.Point, options?: PolygonVertex.Options): PolygonVertex;
+}
+
+declare namespace PolygonVertex {
+  interface Options {
+    distance: PolygonVertex["_distance"];
+    index: PolygonVertex["_index"];
+  }
+}
+
+export default PolygonVertex;

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

@@ -0,0 +1,10 @@
+// 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 */
+/* eslint-disable import/no-unresolved */ // TODO: Remove when the files are instantiated
+
+export { default as RegionGeometry } from "./geometry.mjs";
+export { default as RegionMesh } from "./mesh.mjs";
+export { default as RegionPolygonTree } from "./polygon-tree.mjs";
+export { default as RegionShape } from "./shape.mjs";

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

@@ -0,0 +1,93 @@
+/**
+ * A framework for imbuing special scripted behaviors into a single specific Scene.
+ * Managed scenes are registered in CONFIG.Canvas.managedScenes.
+ *
+ * The SceneManager instance is called at various points in the Scene rendering life-cycle.
+ *
+ * This also provides a framework for registering additional hook events which are required only for the life-cycle of
+ * the managed Scene.
+ *
+ * @example Registering a custom SceneManager
+ * ```js
+ * // Define a custom SceneManager subclass
+ * class MyCustomSceneManager extends SceneManager {
+ *   async _onInit() {
+ *     console.log(`Initializing managed Scene "${this.scene.name}"`);
+ *   }
+ *
+ *   async _onDraw() {
+ *     console.log(`Drawing managed Scene "${this.scene.name}"`);
+ *   }
+ *
+ *   async _onReady() {
+ *     console.log(`Readying managed Scene "${this.scene.name}"`);
+ *   }
+ *
+ *   async _onTearDown() {
+ *     console.log(`Deconstructing managed Scene "${this.scene.name}"`);
+ *   }
+ *
+ *   _registerHooks() {
+ *     this.registerHook("updateToken", this.#onUpdateToken.bind(this));
+ *   }
+ *
+ *   #onUpdateToken(document, updateData, options, userId) {
+ *     console.log("Updating a token within the managed Scene");
+ *   }
+ * }
+ *
+ * // Register MyCustomSceneManager to be used for a specific Scene
+ * CONFIG.Canvas.sceneManagers = {
+ *   [sceneId]: MyCustomSceneManager
+ * }
+ * ```
+ */
+declare class SceneManager {
+  /**
+   * The SceneManager is constructed by passing a reference to the active Scene document.
+   */
+  constructor(scene: Scene);
+
+  /**
+   * The managed Scene
+   */
+  get scene(): Scene.ConfiguredInstance;
+
+  /**
+   * Additional behaviors to perform when the Canvas is first initialized for the Scene.
+   */
+  protected _onInit(): Promise<void>
+
+  /**
+   * Additional behaviors to perform after core groups and layers are drawn to the canvas.
+   */
+  protected _onDraw(): Promise<void>
+
+  /**
+   * Additional behaviors to perform after the Canvas is fully initialized for the Scene.
+   */
+  protected _onReady(): Promise<void>;
+
+  /**
+   * Additional behaviors to perform when the Scene is deactivated.
+   */
+  protected _onTearDown(): Promise<void>
+
+  /**
+   * Register additional hook functions are only used while this Scene is active and is automatically deactivated.
+   * Hooks should be registered in this function by calling this._registerHook(hookName, handler)
+   */
+  protected _registerHooks(): void;
+
+  /**
+   * Register additional hook functions are only used while this Scene is active and is automatically deactivated.
+   */
+  registerHooks(hookName: string, handler: (...args: unknown[]) => unknown): void;
+
+  /**
+   * Deactivate Hook functions that were added specifically for this Scene.
+   */
+  protected _deactivateHooks(): void;
+}
+
+export default SceneManager;

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

@@ -0,0 +1,6 @@
+/**
+ * The blending weight calculation filter for {@link foundry.canvas.SMAAFilter}.
+ */
+export default class SMAABWeightCalculationFilter extends PIXI.Filter {
+  constructor(config: foundry.canvas.SMAAFilter.SMAAFilterConfig);
+}

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

@@ -0,0 +1,6 @@
+/**
+ * The edge detection filter for {@link foundry.canvas.SMAAFilter}.
+ */
+export default class SMAAEdgeDetectionFilter extends PIXI.Filter {
+  constructor(config: foundry.canvas.SMAAFilter.SMAAFilterConfig);
+}

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

@@ -0,0 +1,56 @@
+import type { CLEAR_MODES, FilterState, FilterSystem, RenderTexture } from "pixi.js";
+
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+
+declare class SMAAFilter extends PIXI.Filter {
+  /**
+   * @param config    - The config (defaults: SMAAFilter.PRESETS.DEFAULT)
+   */
+  constructor(config?: InexactPartial<SMAAFilter.SMAAFilterConfig>);
+
+  // a placeholder private method to help subclassing
+  #smaaFilter: true;
+
+  /**
+   * The presets.
+   */
+  static get PRESETS(): Record<string, SMAAFilter.SMAAFilterConfig>;
+
+  /** @override */
+  apply(
+    filterManager: FilterSystem,
+    input: RenderTexture,
+    output: RenderTexture,
+    clearMode: CLEAR_MODES | undefined,
+    currentState: 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. */
+    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.
+     */
+    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]. */
+    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]. */
+    maxSearchStepsDiag: number;
+
+    /** Specifies how much sharp corners will be rounded. Range: [0, 100]. */
+    cornerRounding: number;
+
+    /** Is diagonal detection disabled? */
+    disableDiagDetection: boolean;
+
+    /** Is corner detection disabled? */
+    disableCornerDetection: boolean;
+  }
+}
+
+export default SMAAFilter;

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

@@ -0,0 +1,6 @@
+/**
+ * The neighborhood blending filter for {@link foundry.canvas.SMAAFilter}.
+ */
+export default class SMAANeighborhoodBlendingFilter extends PIXI.Filter {
+  constructor();
+}

package/src/foundry/client-esm/canvas/sources/_module.d.mts

@@ -0,0 +1,15 @@
+// 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 */
+
+export { default as BaseEffectSource } from "./base-effect-source.mjs";
+export { default as BaseLightSource } from "./base-light-source.mjs";
+export { default as GlobalLightSource } from "./global-light-source.mjs";
+export { default as PointDarknessSource } from "./point-darkness-source.mjs";
+export { default as PointEffectSourceMixin } from "./point-effect-source.mjs";
+export { default as PointLightSource } from "./point-light-source.mjs";
+export { default as PointMovementSource } from "./point-movement-source.mjs";
+export { default as PointSoundSource } from "./point-sound-source.mjs";
+export { default as PointVisionSource } from "./point-vision-source.mjs";
+export { default as RenderedEffectSource } from "./rendered-effect-source.mjs";