@league-of-foundry-developers/foundry-vtt-types 0.8.9-9 → 9.245.0

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.js';
 
-  /** 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

@@ -42,7 +42,7 @@ declare global {
     /**
      * Options which modify or describe the Roll
      */
-    options: Partial<Options>;
+    options: InexactPartial<Options>;
 
     /**
      * The identified terms of the Roll
@@ -72,10 +72,8 @@ declare global {
      */
     protected _total: number | undefined;
 
-    /**
-     * A Proxy environment for safely evaluating a string using only available Math functions
-     */
-    static MATH_PROXY: MathProxy;
+    /** A Proxy environment for safely evaluating a string using only available Math functions */
+    static MATH_PROXY: Math;
 
     /**
      * The HTML template path used to render a complete Roll object to the chat log
@@ -117,6 +115,9 @@ declare global {
      */
     get total(): number | undefined;
 
+    /** Whether this Roll contains entirely deterministic terms or whether there is some randomness. */
+    get isDeterministic(): boolean;
+
     /**
      * Alter the Roll expression by adding or multiplying the number of dice which are rolled
      * @param multiply        - A factor to multiply. Dice are multiplied before any additions.
@@ -146,21 +147,21 @@ declare global {
      * console.log(r.total);  // 11
      * ```
      */
-    evaluate(options?: Partial<Options & { async: false }>): this;
-    evaluate(options: Partial<Options> & { async: true }): Promise<this>;
-    evaluate(options?: Partial<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?: Partial<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?: Partial<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.
@@ -172,9 +173,9 @@ declare global {
      * Alias for evaluate.
      * @see Roll#evaluate
      */
-    roll(options?: Partial<Options & { async: false }>): this;
-    roll(options: Partial<Options> & { async: true }): Promise<this>;
-    roll(options?: Partial<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.
@@ -182,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?: Partial<Options & { async: false }>): this;
-    reroll(options: Partial<Options> & { async: true }): Promise<this>;
-    reroll(options?: Partial<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.
@@ -197,7 +198,7 @@ declare global {
     static create<D extends Record<string, unknown> = {}>(
       formula: string,
       data?: D,
-      options?: Partial<Options>
+      options?: InexactPartial<Options>
     ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<D>;
 
     /**
@@ -229,7 +230,7 @@ declare global {
      *                  (default: `10000`)
      * @returns The rolled totals
      */
-    static simulate(formula: string, n?: number): number[];
+    static simulate(formula: string, n?: number): Promise<number[]>;
 
     /**
      * Parse a formula by following an order of operations:
@@ -302,7 +303,7 @@ declare global {
      *                   (default: `{}`)
      * @returns An array of terms, split on dice pool terms
      */
-    protected _splitGroup(_formula: string, options?: Partial<SplitGroupOptions>): string[];
+    protected _splitGroup(_formula: string, options?: InexactPartial<SplitGroupOptions>): string[];
 
     /**
      * Split a formula by identifying arithmetic terms
@@ -350,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.
@@ -373,15 +392,15 @@ declare global {
      */
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData?: T,
-      { rollMode, create }?: { rollMode?: foundry.CONST.DiceRollMode; 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.DiceRollMode; 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.DiceRollMode; create: boolean }
+      { rollMode, create }: { rollMode?: keyof CONFIG.Dice.RollModes | 'roll'; create: boolean }
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof ChatMessage>> | undefined> | MessageData<T>;
 
     /**
@@ -439,42 +458,14 @@ declare global {
      * roll.formula; // 4d8 + 8
      * ```
      */
-    static fromTerms(
+    static fromTerms<T extends ConstructorOf<Roll<any>>>(
+      this: T,
       terms: RollTerm[],
-      options?: Partial<Options>
-    ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<{}>;
-
-    /**
-     * @deprecated since 0.8.1
-     */
-    get _rolled(): boolean;
+      options?: InexactPartial<Options>
+    ): 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 {
@@ -488,22 +479,17 @@ interface SplitGroupOptions {
 interface Data {
   formula: string;
   results: Array<number | string>;
-  terms: Array<(PoolTerm.TermData & { class: 'DicePool' }) | DiceTerm.Data>;
+  terms: Array<PoolTerm.TermData | DiceTerm.Data>;
   total: number | null;
 }
 
 type Flavor = Record<`%F${number}%`, string>;
 
-/**
- * @deprecated since 0.8.1
- */
-interface MathProxy extends Math {
-  safeEval: (arg: Parameters<typeof Roll['safeEval']>) => ReturnType<typeof Roll['safeEval']>;
-}
-
 type MessageData<T extends DeepPartial<ConstructorParameters<typeof ChatMessage>[0]>> = {
   user: string;
   type: typeof foundry.CONST.CHAT_MESSAGE_TYPES['ROLL'];
   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/rollTerm.d.ts

@@ -41,14 +41,17 @@ declare abstract class RollTerm {
   /** Optional flavor text which modifies and describes this term. */
   get flavor(): string;
 
+  /** Whether this term is entirely deterministic or contains some randomness. */
+  get isDeterministic(): boolean;
+
   /**
    * Evaluate the roll term, populating the results Array.
    * @param options - (default: `{}`)
    * @returns The evaluated dice term
    */
-  evaluate(options?: Partial<RollTerm.EvaluationOptions & { async: false }>): this;
-  evaluate(options: Partial<RollTerm.EvaluationOptions> & { async: true }): Promise<this>;
-  evaluate(options?: Partial<RollTerm.EvaluationOptions>): this | Promise<this>;
+  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions & { async: false }>): this;
+  evaluate(options: InexactPartial<RollTerm.EvaluationOptions> & { async: true }): Promise<this>;
+  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
 
   protected _evaluate({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): Promise<this>;
 
@@ -107,7 +110,7 @@ declare namespace RollTerm {
     /**
      * Evaluate the roll asynchronously, receiving a Promise as the returned value.
      * This will become the default behavior in version 10.x
-     * @defaultValue `false`
+     * @defaultValue `true`
      */
     async: boolean;
   }