@league-of-foundry-developers/foundry-vtt-types 9.238.1 → 9.249.1

package/src/foundry/foundry.js/quadtree.d.ts

@@ -97,12 +97,12 @@ declare class Quadtree<T> {
 
   /**
    * Get all the objects which could collide with the provided rectangle
-   * @param rect - The target rectangle
+   * @param rect - The normalized target rectangle
    * @param _s   - The existing result set, for internal use.
    *               (default: `new Set<T>()`)
    * @returns The objects in the Quadtree which represent potential collisions
    */
-  getObjects(rect: Rectangle, _s?: Set<T>): Set<T>;
+  getObjects(rect: NormalizedRectangle, _s?: Set<T>): Set<T>;
 
   /**
    * Obtain the leaf nodes to which a target rectangle belongs.

package/src/foundry/foundry.js/quadtreeCulling.d.ts

@@ -0,0 +1,11 @@
+/**
+ * An experimental approach to culling using the quadtree mapping rather than the screen rectangle.
+ * @internal
+ */
+declare class QuadtreeCulling {
+  constructor();
+
+  cull(screen: Rectangle): void;
+
+  protected _getRect(screen: Rectangle): NormalizedRectangle;
+}

package/src/foundry/foundry.js/ray.d.ts

@@ -1,171 +1,165 @@
-declare interface RayIntersection {
-  /** The x-coordinate of intersection */
-  x: number;
+import type { LineIntersection } from '../common/utils/geometry.mjs';
 
-  /** The y-coordinate of intersection */
-  y: number;
+declare global {
+  interface RayIntersection {
+    /** The x-coordinate of intersection */
+    x: number;
 
-  /** The proximity to the Ray origin, as a ratio of distance */
-  t0: number;
+    /** The y-coordinate of intersection */
+    y: number;
 
-  /** The proximity to the Ray destination, as a ratio of distance */
-  t1: number;
-}
-
-/**
- * A ray for the purposes of computing sight and collision
- * Given points A[x,y] and B[x,y]
- *
- * Slope-Intercept form:
- * y = a + bx
- * y = A.y + ((B.y - A.Y) / (B.x - A.x))x
- *
- * Parametric form:
- * R(t) = (1-t)A + tB
- */
-declare class Ray {
-  /**
-   * @param A - The origin of the Ray
-   * @param B - The destination of the Ray
-   */
-  constructor(A: Point, B: Point);
-
-  /**
-   * The origin point, `{x, y}`
-   */
-  A: Point;
-
-  /**
-   * The destination point, `{x, y}`
-   */
-  B: Point;
-
-  /**
-   * The origin y-coordinate
-   */
-  y0: number;
+    /** The proximity to the Ray origin, as a ratio of distance */
+    t0: number;
 
-  /**
-   * The origin x-coordinate
-   */
-  x0: number;
+    /** The proximity to the Ray destination, as a ratio of distance */
+    t1: number;
+  }
 
   /**
-   * The horizontal distance of the ray, x1 - x0
-   */
-  dx: number;
-
-  /**
-   * The vertical distance of the ray, y1 - y0
-   */
-  dy: number;
-
-  /**
-   * The slope of the ray, dy over dx
-   */
-  slope: number;
-
-  /**
-   * The cached angle, computed lazily in Ray#angle
-   * @defaultValue `undefined`
-   * @internal
-   */
-  protected _angle: number | undefined;
-
-  /**
-   * The cached distance, computed lazily in Ray#distance
-   * @defaultValue `undefined`
-   * @internal
-   */
-  protected _distance: number | undefined;
-
-  /**
-   * The normalized angle of the ray in radians on the range (-PI, PI).
-   * The angle is computed lazily (only if required) and cached.
-   */
-  get angle(): number;
-  set angle(value: number);
-
-  /**
-   * A bounding rectangle that encompasses the Ray
-   */
-  get bounds(): NormalizedRectangle;
-
-  /**
-   * The distance (length) of the Ray in pixels.
-   * The distance is computed lazily (only if required) and cached.
-   */
-  get distance(): number;
-  set distance(value: number);
-
-  /**
-   * A factory method to construct a Ray from an origin point, an angle, and a distance
-   * @param x        - The origin x-coordinate
-   * @param y        - The origin y-coordinate
-   * @param radians  - The ray angle in radians
-   * @param distance - The distance of the ray in pixels
-   * @returns The constructed Ray instance
-   */
-  static fromAngle(x: number, y: number, radians: number, distance: number): Ray;
-
-  /**
-   * A factory method to construct a Ray from points in array format.
-   * @param A - The origin point [x,y]
-   * @param B - The destination point [x,y]
-   * @returns The constructed Ray instance
-   */
-  static fromArrays(A: PointArray, B: PointArray): Ray;
-
-  /**
-   * Project the Array by some proportion of it's initial distance.
-   * Return the coordinates of that point along the path.
-   * @param t - The distance along the Ray
-   * @returns The coordinates of the projected point
-   */
-  project(t: number): { x: number; y: number };
-
-  /**
-   * Reverse the direction of the Ray, returning a second Ray
-   */
-  reverse(): Ray;
-
-  /**
-   * Create a new ray which uses the same origin point, but a slightly offset angle and distance
-   * @param offset   - An offset in radians which modifies the angle of the original Ray
-   * @param distance - A distance the new ray should project, otherwise uses the same distance.
-   * @returns A new Ray with an offset angle
-   */
-  shiftAngle(angleOffset: number, distance?: number): Ray;
-
-  /**
-   * Find the point I[x,y] and distance t* on ray R(t) which intersects another ray
-   * http://paulbourke.net/geometry/pointlineplane/
+   * A ray for the purposes of computing sight and collision
+   * Given points A[x,y] and B[x,y]
    *
-   * @param coords - An array of coordinates [x0, y0, x1, y1] which defines a line segment to test
+   * Slope-Intercept form:
+   * y = a + bx
+   * y = A.y + ((B.y - A.Y) / (B.x - A.x))x
    *
-   * @returns
-   *    The point of collision [x,y] the position of that collision point along the Ray (t0) an the tested
-   *    segment (t1). Returns false if no collision occurs.
-   */
-  intersectSegment(coords: [x0: number, y0: number, x1: number, y1: number]): RayIntersection | false;
-
-  /**
-   * An internal helper method for computing the intersection between two lines.
-   * @internal
-   */
-  protected static _getIntersection(
-    x1: number,
-    y1: number,
-    x2: number,
-    y2: number,
-    x3: number,
-    y3: number,
-    x4: number,
-    y4: number
-  ): RayIntersection | false;
-
-  /**
-   * @deprecated since 0.8.0
-   */
-  get normAngle(): number;
+   * Parametric form:
+   * R(t) = (1-t)A + tB
+   */
+  class Ray {
+    /**
+     * @param A - The origin of the Ray
+     * @param B - The destination of the Ray
+     */
+    constructor(A: Point, B: Point);
+
+    /**
+     * The origin point, `{x, y}`
+     */
+    A: Point;
+
+    /**
+     * The destination point, `{x, y}`
+     */
+    B: Point;
+
+    /**
+     * The origin y-coordinate
+     */
+    y0: number;
+
+    /**
+     * The origin x-coordinate
+     */
+    x0: number;
+
+    /**
+     * The horizontal distance of the ray, x1 - x0
+     */
+    dx: number;
+
+    /**
+     * The vertical distance of the ray, y1 - y0
+     */
+    dy: number;
+
+    /**
+     * The slope of the ray, dy over dx
+     */
+    slope: number;
+
+    /**
+     * The cached angle, computed lazily in Ray#angle
+     * @defaultValue `undefined`
+     * @internal
+     */
+    protected _angle: number | undefined;
+
+    /**
+     * The cached distance, computed lazily in Ray#distance
+     * @defaultValue `undefined`
+     * @internal
+     */
+    protected _distance: number | undefined;
+
+    /**
+     * The normalized angle of the ray in radians on the range (-PI, PI).
+     * The angle is computed lazily (only if required) and cached.
+     */
+    get angle(): number;
+    set angle(value: number);
+
+    /**
+     * A bounding rectangle that encompasses the Ray
+     */
+    get bounds(): NormalizedRectangle;
+
+    /**
+     * The distance (length) of the Ray in pixels.
+     * The distance is computed lazily (only if required) and cached.
+     */
+    get distance(): number;
+    set distance(value: number);
+
+    /**
+     * A factory method to construct a Ray from an origin point, an angle, and a distance
+     * @param x        - The origin x-coordinate
+     * @param y        - The origin y-coordinate
+     * @param radians  - The ray angle in radians
+     * @param distance - The distance of the ray in pixels
+     * @returns The constructed Ray instance
+     */
+    static fromAngle(x: number, y: number, radians: number, distance: number): Ray;
+
+    /**
+     * A factory method to construct a Ray from points in array format.
+     * @param A - The origin point [x,y]
+     * @param B - The destination point [x,y]
+     * @returns The constructed Ray instance
+     */
+    static fromArrays(A: PointArray, B: PointArray): Ray;
+
+    /**
+     * Project the Array by some proportion of it's initial distance.
+     * Return the coordinates of that point along the path.
+     * @param t - The distance along the Ray
+     * @returns The coordinates of the projected point
+     */
+    project(t: number): { x: number; y: number };
+
+    /**
+     * Create a Ray by projecting a certain distance towards a known point.
+     * @param origin   - The origin of the Ray
+     * @param point    - The point towards which to project
+     * @param distance - The distance of projection
+     */
+    static towardsPoint(origin: Point, point: Point, distance: number): Ray;
+
+    /**
+     * Create a Ray by projecting a certain squared-distance towards a known point.
+     * @param origin    - The origin of the Ray
+     * @param point     - The point towards which to project
+     * @param distance2 - The squared distance of projection
+     */
+    static towardsPointSquared(origin: Point, point: Point, distance2: number): Ray;
+
+    /**
+     * Reverse the direction of the Ray, returning a second Ray
+     */
+    reverse(): Ray;
+
+    /**
+     * Create a new ray which uses the same origin point, but a slightly offset angle and distance
+     * @param offset   - An offset in radians which modifies the angle of the original Ray
+     * @param distance - A distance the new ray should project, otherwise uses the same distance.
+     * @returns A new Ray with an offset angle
+     */
+    shiftAngle(angleOffset: number, distance?: number): Ray;
+
+    /**
+     * Find the point I[x,y] and distance t* on ray R(t) which intersects another ray
+     * @see foundry.utils.lineLineIntersection
+     */
+    intersectSegment(coords: [x0: number, y0: number, x1: number, y1: number]): LineIntersection | null;
+  }
 }

package/src/foundry/foundry.js/rays/index.d.ts

@@ -0,0 +1 @@
+import './sightRay';

package/src/foundry/foundry.js/rays/sightRay.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A subclass of Ray that is used specifically for computing source polygons
+ *
+ * This was used for the RadialSweepPolygon but can now be deleted once that is
+ * @deprecated since v9d2
+ */
+declare class SightRay extends Ray {
+  /**
+   * The array of sorted collision points which apply for this Ray.
+   */
+  collisions: WallEndpoint[];
+
+  /**
+   * The target endpoint at which this Ray was fired
+   */
+  endpoint: WallEndpoint | null;
+
+  /**
+   * The result objects which records the outcome of this Ray
+   */
+  result: {
+    collisions: unknown[];
+    continuation: unknown | undefined;
+    limitation: number;
+    superfluous: boolean;
+    stopped: boolean;
+    activeWalls: unknown | undefined;
+  };
+
+  /**
+   * The final collision point that this SightRay encountered.
+   */
+  get lastCollision(): WallEndpoint | null;
+}

package/src/foundry/foundry.js/roll.d.ts

@@ -147,21 +147,21 @@ declare global {
      * console.log(r.total);  // 11
      * ```
      */
-    evaluate(options?: InexactPartial<Options & { async: false }>): this;
-    evaluate(options: InexactPartial<Options> & { async: true }): Promise<this>;
-    evaluate(options?: InexactPartial<Options>): this | Promise<this>;
+    evaluate(options?: InexactPartial<Options & { async: false }>): Evaluated<this>;
+    evaluate(options: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    evaluate(options?: InexactPartial<Options>): Evaluated<this> | Promise<Evaluated<this>>;
 
     /**
      * Evaluate the roll asynchronously.
      * A temporary helper method used to migrate behavior from 0.7.x (sync by default) to 0.9.x (async by default).
      */
-    protected _evaluate(options?: InexactPartial<Omit<Options, 'async'>>): Promise<this>;
+    protected _evaluate(options?: InexactPartial<Omit<Options, 'async'>>): Promise<Evaluated<this>>;
 
     /**
      * Evaluate the roll synchronously.
      * A temporary helper method used to migrate behavior from 0.7.x (sync by default) to 0.9.x (async by default).
      */
-    protected _evaluateSync(options?: InexactPartial<Omit<Options, 'async'>>): this;
+    protected _evaluateSync(options?: InexactPartial<Omit<Options, 'async'>>): Evaluated<this>;
 
     /**
      * Safely evaluate the final total result for the Roll using its component terms.
@@ -173,9 +173,9 @@ declare global {
      * Alias for evaluate.
      * @see Roll#evaluate
      */
-    roll(options?: InexactPartial<Options & { async: false }>): this;
-    roll(options: InexactPartial<Options> & { async: true }): Promise<this>;
-    roll(options?: InexactPartial<Options>): this | Promise<this>;
+    roll(options?: InexactPartial<Options & { async: false }>): Evaluated<this>;
+    roll(options: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    roll(options?: InexactPartial<Options>): Evaluated<this> | Promise<Evaluated<this>>;
 
     /**
      * Create a new Roll object using the original provided formula and data.
@@ -183,9 +183,9 @@ declare global {
      * @param options - Evaluation options passed to Roll#evaluate
      * @returns A new Roll object, rolled using the same formula and data
      */
-    reroll(options?: InexactPartial<Options & { async: false }>): this;
-    reroll(options: InexactPartial<Options> & { async: true }): Promise<this>;
-    reroll(options?: InexactPartial<Options>): this | Promise<this>;
+    reroll(options?: InexactPartial<Options & { async: false }>): Evaluated<this>;
+    reroll(options: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    reroll(options?: InexactPartial<Options>): Evaluated<this> | Promise<Evaluated<this>>;
 
     /**
      * A factory method which constructs a Roll instance using the default configured Roll class.
@@ -351,11 +351,29 @@ declare global {
 
     /**
      * Render a Roll instance to HTML
-     * @param chatOptions - An object configuring the behavior of the resulting chat message.
-     *                      (default: `{}`)
+     * @param options - Options which affect how the Roll is rendered
+     *                  (default: `{}`)
      * @returns The rendered HTML template as a string
      */
-    render(chatOptions?: ChatOptions): Promise<string>;
+    render(options?: {
+      /**
+       * Flavor text to include
+       * @defaultValue `undefined`
+       */
+      flavor?: string;
+
+      /**
+       * A custom HTML template path
+       * @defaultValue `this.constructor.CHAT_TEMPLATE`
+       */
+      template?: string;
+
+      /**
+       * Is the Roll displayed privately?
+       * @defaultValue `false`
+       */
+      isPrivate?: boolean;
+    }): Promise<string>;
 
     /**
      * Transform a Roll instance into a ChatMessage, displaying the roll result.
@@ -374,15 +392,15 @@ declare global {
      */
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData?: T,
-      { rollMode, create }?: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create?: true }
+      { rollMode, create }?: { rollMode?: keyof CONFIG.Dice.RollModes | 'roll'; create?: true }
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof ChatMessage>> | undefined>;
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData: T,
-      { rollMode, create }: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create: false }
+      { rollMode, create }: { rollMode?: keyof CONFIG.Dice.RollModes | 'roll'; create: false }
     ): MessageData<T>;
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData: T,
-      { rollMode, create }: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create: boolean }
+      { rollMode, create }: { rollMode?: keyof CONFIG.Dice.RollModes | 'roll'; create: boolean }
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof ChatMessage>> | undefined> | MessageData<T>;
 
     /**
@@ -440,37 +458,14 @@ declare global {
      * roll.formula; // 4d8 + 8
      * ```
      */
-    static fromTerms(
+    static fromTerms<T extends ConstructorOf<Roll<any>>>(
+      this: T,
       terms: RollTerm[],
       options?: InexactPartial<Options>
-    ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<{}>;
+    ): InstanceType<T>;
   }
 }
 
-interface ChatOptions {
-  /**
-   * @defaultValue `false`
-   */
-  blind?: boolean;
-
-  /**
-   * @defaultValue `null`
-   */
-  flavor?: any;
-
-  /**
-   * @defaultValue `false`
-   */
-  isPrivate?: boolean;
-
-  template?: string;
-
-  /**
-   * @defaultValue The id of the current user
-   */
-  user?: string;
-}
-
 type Options = RollTerm.EvaluationOptions;
 
 interface SplitGroupOptions {
@@ -496,3 +491,5 @@ type MessageData<T extends DeepPartial<ConstructorParameters<typeof ChatMessage>
   content: number;
   sound: typeof CONFIG.sounds.dice;
 } & T;
+
+type Evaluated<T extends Roll> = T & { _evaluated: true; _total: number; get total(): number };

package/src/foundry/foundry.js/screenCulling.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A tool for culling the renderable state of objects which are outside the current viewport.
+ */
+declare class ScreenCulling {
+  constructor();
+
+  /**
+   * Toggle the renderable state of objects based on the current viewport rectangle
+   */
+  cull(rect: Rectangle): void;
+
+  /**
+   * Test whether rectangular bounds intersect
+   * @param rect   - The target rectangle (the screen)
+   * @param bounds - The reference rectangle (the object)
+   * @returns Do they intersect?
+   */
+  intersects(rect: Rectangle, bounds: Rectangle): boolean;
+}

package/src/foundry/foundry.js/searchFilter.d.ts

@@ -1,3 +1,33 @@
+/** Options which customize the behavior of the filter */
+interface SearchFilterConfiguration {
+  /**
+   * The CSS selector used to target the text input element.
+   */
+  inputSelector: string;
+
+  /**
+   * The CSS selector used to target the content container for these tabs.
+   */
+  contentSelector: string;
+
+  /**
+   * A callback function which executes when the filter changes.
+   */
+  callback?: SearchFilter['callback'];
+
+  /**
+   * The initial value of the search query.
+   * @defaultValue `""`
+   */
+  initial?: SearchFilter['query'] | undefined;
+
+  /**
+   * The number of milliseconds to wait for text input before processing.
+   * @defaultValue `100`
+   */
+  delay?: number;
+}
+
 /**
  * A controller class for managing a text input widget that filters the contents of some other UI element
  * @see {@link Application}
@@ -6,7 +36,7 @@ declare class SearchFilter {
   /**
    * @param options - Options which customize the behavior of the filter
    */
-  constructor(options: SearchFilter.Options);
+  constructor(options: SearchFilterConfiguration);
 
   /**
    * The value of the current query string
@@ -26,28 +56,33 @@ declare class SearchFilter {
 
   /**
    * The CSS selector used to target the tab navigation element
+   * @internal
    */
   protected _inputSelector: string;
 
   /**
    * A reference to the HTML navigation element the tab controller is bound to
+   * @internal
    */
   protected _input: HTMLElement | null;
 
   /**
    * The CSS selector used to target the tab content element
+   * @internal
    */
   protected _contentSelector: string;
 
   /**
    * A reference to the HTML container element of the tab content
+   * @internal
    */
   protected _content: HTMLElement | null;
 
   /**
    * A debounced function which applies the search filtering
+   * @internal
    */
-  protected _filter: this['callback'];
+  protected _filter: (...args: Parameters<this['callback']>) => void;
 
   /**
    * Bind the SearchFilter controller to an HTML application
@@ -69,34 +104,3 @@ declare class SearchFilter {
    */
   static cleanQuery(query: string): string;
 }
-
-declare namespace SearchFilter {
-  interface Options {
-    /**
-     * The CSS selector used to target the text input element.
-     */
-    inputSelector: string;
-
-    /**
-     * The CSS selector used to target the content container for these tabs.
-     */
-    contentSelector: string;
-
-    /**
-     * The initial value of the search query.
-     * @defaultValue `""`
-     */
-    initial?: SearchFilter['query'];
-
-    /**
-     * A callback function which executes when the filter changes.
-     */
-    callback: SearchFilter['callback'];
-
-    /**
-     * The number of milliseconds to wait for text input before processing.
-     * @defaultValue `100`
-     */
-    delay?: number;
-  }
-}

package/src/foundry/foundry.js/specialEffect.d.ts

@@ -1,5 +1,5 @@
 /**
- * I don't know what this will do yet
+ * TODO: Document Me
  */
 declare class SpecialEffect {
   constructor(parent: PIXI.Container, options?: DeepPartial<SpecialEffect.Options>);