@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-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: Point,
+    b: 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: Point;
+
+  /**
+   * The endpoint of the edge which is oriented towards the bottom-right.
+   */
+  se: 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: 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: 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,134 @@
+/**
+ * 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: PolygonEdge, 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: 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 @@
+export default class 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";

package/src/foundry/client-esm/canvas/sources/base-effect-source.d.mts

@@ -0,0 +1,243 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+
+/**
+ * TODO - Re-document after ESM refactor.
+ * An abstract base class which defines a framework for effect sources which originate radially from a specific point.
+ * This abstraction is used by the LightSource, VisionSource, SoundSource, and MovementSource subclasses.
+ *
+ * @example A standard PointSource lifecycle:
+ * ```js
+ * const source = new PointSource({object}); // Create the point source
+ * source.initialize(data);                  // Configure the point source with new data
+ * source.refresh();                         // Refresh the point source
+ * source.destroy();                         // Destroy the point source
+ * ```
+ * @privateRemarks The TODO is foundry's
+ */
+declare class BaseEffectSource<
+  SourceData extends BaseEffectSource.BaseEffectSourceData,
+  SourceShape extends PIXI.Polygon,
+> {
+  /**
+   * An effect source is constructed by providing configuration options.
+   * @param options - Options which modify the base effect source instance
+   */
+  constructor(options?: BaseEffectSource.BaseEffectSourceOptions);
+
+  /**
+   * The type of source represented by this data structure.
+   * Each subclass must implement this attribute.
+   */
+  static sourceType: string;
+
+  /**
+   * The target collection into the effects canvas group.
+   */
+  static effectsCollection: string;
+
+  /**
+   * Effect source default data.
+   * @defaultValue
+   * ```js
+   * {
+   * x: 0,
+   * y: 0,
+   * elevation: 0,
+   * disabled: false
+   * }
+   * ```
+   */
+  static defaultData: BaseEffectSource.BaseEffectSourceData;
+
+  /**
+   * Some other object which is responsible for this source.
+   */
+  object: PlaceableObject | null;
+
+  /**
+   * The source id linked to this effect source.
+   */
+  readonly sourceId: string;
+
+  /**
+   * The data of this source.
+   */
+  data: SourceData;
+
+  /**
+   * The geometric shape of the effect source which is generated later.
+   */
+  shape: SourceShape;
+
+  /**
+   * A collection of boolean flags which control rendering and refresh behavior for the source.
+   */
+  protected _flags: Record<string, boolean | number>;
+
+  /**
+   * The x-coordinate of the point source origin.
+   */
+  get x(): number;
+
+  /**
+   * The y-coordinate of the point source origin.
+   */
+  get y(): number;
+
+  /**
+   * The elevation bound to this source.
+   */
+  get elevation(): number;
+
+  /**
+   * The EffectsCanvasGroup collection linked to this effect source.
+   */
+  get effectsCollection(): foundry.utils.Collection<this>;
+
+  /**
+   * Returns the update ID associated with this source.
+   * The update ID is increased whenever the shape of the source changes.
+   */
+  get updateId(): number;
+
+  /**
+   * Is this source currently active?
+   * A source is active if it is attached to an effect collection and is not disabled or suppressed.
+   */
+  get active(): boolean;
+
+  /**
+   * Is this source attached to an effect collection?
+   */
+  get attached(): boolean;
+
+  /**
+   * Is this source temporarily suppressed?
+   */
+  get suppressed(): boolean;
+
+  /**
+   * Records of suppression strings with a boolean value.
+   * If any of this record is true, the source is suppressed.
+   */
+  suppression: Record<string, boolean>;
+
+  /**
+   * Initialize and configure the source using provided data.
+   * @param data    - Provided data for configuration
+   * @param options - Additional options which modify source initialization
+   * @returns The initialized source
+   */
+  initialize(
+    data?: InexactPartial<SourceData>,
+    options?: InexactPartial<{
+      // The type def references a behaviors object that is not even passed into the function
+      /**
+       * Should source data be reset to default values before applying changes?
+       * @defaultValue `false`
+       */
+      reset?: boolean;
+    }>,
+  ): this;
+
+  /**
+   * Subclass specific data initialization steps.
+   * @param data - Provided data for configuration
+   */
+  _initialize(data: Partial<SourceData>): void;
+
+  /**
+   * Create the polygon shape (or shapes) for this source using configured data.
+   */
+  protected _createShapes(): void;
+
+  /**
+   * Subclass specific configuration steps. Occurs after data initialization and shape computation.
+   * Only called if the source is attached and not disabled.
+   * @param changes - Changes to the source data which were applied
+   */
+  protected _configure(changes: Partial<SourceData>): void;
+
+  /**
+   * Refresh the state and uniforms of the source.
+   * Only active sources are refreshed.
+   */
+  refresh(): void;
+
+  /**
+   * Subclass-specific refresh steps.
+   */
+  protected _refresh(): void;
+
+  /**
+   * Steps that must be performed when the source is destroyed.
+   */
+  destroy(): void;
+
+  /**
+   * Subclass specific destruction steps.
+   */
+  protected _destroy(): void;
+
+  /**
+   * Add this BaseEffectSource instance to the active collection.
+   */
+  add(): void;
+
+  /**
+   * Remove this BaseEffectSource instance from the active collection.
+   */
+  remove(): void;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks `"BaseEffectSource#sourceType is deprecated. Use BaseEffectSource.sourceType instead."`
+   */
+  get sourceType(): string;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"BaseEffectSource#_createShape is deprecated in favor of BaseEffectSource#_createShapes."`
+   */
+  _createShape(): void;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"BaseEffectSource#disabled is deprecated in favor of BaseEffectSource#data#disabled or BaseEffectSource#active depending on your use case."`
+   */
+  get disabled(): boolean;
+}
+
+declare namespace BaseEffectSource {
+  interface BaseEffectSourceOptions {
+    /**
+     * An optional PlaceableObject which is responsible for this source
+     */
+    object?: PlaceableObject | undefined;
+    /**
+     * A unique ID for this source. This will be set automatically if an
+     * object is provided, otherwise is required.
+     */
+    sourceId?: string | undefined;
+  }
+  interface BaseEffectSourceData {
+    /**
+     * The x-coordinate of the source location
+     */
+    x: number;
+    /**
+     * The y-coordinate of the source location
+     */
+    y: number;
+    /**
+     * The elevation of the point source
+     */
+    elevation: number;
+    /**
+     * Whether or not the source is disabled
+     */
+    disabled: boolean;
+  }
+}
+
+export default BaseEffectSource;