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

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

@@ -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 {

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/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>);

package/src/foundry/index.d.ts

@@ -1,9 +1,10 @@
 import './common/module.mjs';
-
 import './foundry.js/application';
+import './foundry.js/applications';
 import './foundry.js/audioContainer';
 import './foundry.js/audioHelper';
 import './foundry.js/avClient';
+import './foundry.js/avClients';
 import './foundry.js/avMaster';
 import './foundry.js/avSettings';
 import './foundry.js/cameraPopoutAppWrapper';
@@ -12,10 +13,12 @@ import './foundry.js/canvasAnimation';
 import './foundry.js/canvasDocumentMixin';
 import './foundry.js/chatBubbles';
 import './foundry.js/clientDatabaseBackend';
-import './foundry.js/clientDocuments';
 import './foundry.js/clientDocumentMixin';
+import './foundry.js/clientDocuments';
 import './foundry.js/clientKeybindings';
 import './foundry.js/clientSettings';
+import './foundry.js/collections';
+import './foundry.js/collisionResult';
 import './foundry.js/config';
 import './foundry.js/constants';
 import './foundry.js/contextMenu';
@@ -25,8 +28,8 @@ import './foundry.js/features';
 import './foundry.js/fonts';
 import './foundry.js/formDataExtended';
 import './foundry.js/game';
-import './foundry.js/gamepadManager';
 import './foundry.js/gameTime';
+import './foundry.js/gamepadManager';
 import './foundry.js/globalVariables';
 import './foundry.js/handlebarsHelpers';
 import './foundry.js/hooks';
@@ -38,16 +41,34 @@ import './foundry.js/mouseInteractionManager';
 import './foundry.js/mouseManager';
 import './foundry.js/newUserExperience';
 import './foundry.js/perceptionManager';
+import './foundry.js/pixi';
 import './foundry.js/pointSource';
+import './foundry.js/pointSources';
+import './foundry.js/polygonEdge';
+import './foundry.js/polygonVertex';
 import './foundry.js/quadtree';
+import './foundry.js/quadtreeCulling';
 import './foundry.js/ray';
+import './foundry.js/rays';
 import './foundry.js/roll';
+import './foundry.js/rollTerm';
+import './foundry.js/rollTerms/diceTerm';
+import './foundry.js/rollTerms/diceTerms/coin';
+import './foundry.js/rollTerms/diceTerms/die';
+import './foundry.js/rollTerms/diceTerms/fateDie';
+import './foundry.js/rollTerms/mathTerm';
+import './foundry.js/rollTerms/numericTerm';
+import './foundry.js/rollTerms/operatorTerm';
+import './foundry.js/rollTerms/parentheticalTerm';
+import './foundry.js/rollTerms/poolTerm';
+import './foundry.js/rollTerms/stringTerm';
+import './foundry.js/screenCulling';
 import './foundry.js/searchFilter';
-import './foundry.js/specialEffect';
-import './foundry.js/specialEffects';
 import './foundry.js/socketInterface';
 import './foundry.js/sortingHelpers';
 import './foundry.js/sound';
+import './foundry.js/specialEffect';
+import './foundry.js/specialEffects';
 import './foundry.js/tabs';
 import './foundry.js/templateUtils';
 import './foundry.js/textEditor';
@@ -57,25 +78,3 @@ import './foundry.js/types';
 import './foundry.js/userTargets';
 import './foundry.js/utils';
 import './foundry.js/videoHelper';
-
-import './foundry.js/applications';
-
-import './foundry.js/avClients';
-
-import './foundry.js/collections';
-
-import './foundry.js/rollTerm';
-
-import './foundry.js/rollTerms/diceTerm';
-import './foundry.js/rollTerms/mathTerm';
-import './foundry.js/rollTerms/numericTerm';
-import './foundry.js/rollTerms/operatorTerm';
-import './foundry.js/rollTerms/parentheticalTerm';
-import './foundry.js/rollTerms/poolTerm';
-import './foundry.js/rollTerms/stringTerm';
-
-import './foundry.js/rollTerms/diceTerms/coin';
-import './foundry.js/rollTerms/diceTerms/die';
-import './foundry.js/rollTerms/diceTerms/fateDie';
-
-import './foundry.js/pixi';

package/src/foundry/foundry.js/pixi/polygons/sourcePolygon.d.ts

@@ -1,25 +0,0 @@
-/**
- * An extension of the base PIXI.Polygon class designed for polygons which are constructed as a radius around
- * some central origin.
- */
-declare class SourcePolygon extends PIXI.Polygon {
-  constructor(x: number, y: number, radius: number, ...points: ({ x: number; y: number }[] | number[])[]);
-
-  x: number;
-
-  y: number;
-
-  radius: number;
-
-  /** @override */
-  clone(): this;
-
-  /**
-   * Optimize Polygon membership test by first checking the hypotenuse of the candidate point against the known origin
-   * @see PIXI.Polygon#contains
-   * @param x - The candidate x-coordinate
-   * @param y - The candidate y-coordinate
-   * @returns Is the provided point contained within the SourcePolygon?
-   */
-  contains(x: number, y: number): boolean;
-}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/standardColorationShader.d.ts

@@ -1,21 +0,0 @@
-/**
- * The default coloration shader used by standard rendering and animations.
- * A fragment shader which creates a light source.
- */
-declare class StandardColorationShader extends AbstractBaseShader {
-  static fragmentShader: string;
-
-  /**
-   * @defaultValue
-   * ```typescript
-   * {
-   *   alpha: 1.0,
-   *   color: [1.0, 1.0, 1.0],
-   *   time: 0,
-   *   intensity: 5,
-   *   darkness: false,
-   * }
-   * ```
-   */
-  static defaultUniforms: AbstractBaseShader.Uniforms;
-}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/standardColorationShaders/chromaColorationShader.d.ts

@@ -1,18 +0,0 @@
-/**
- * Chroma animation coloration shader
- */
-declare class ChromaColorationShader extends StandardColorationShader {
-  static fragmentShader: string;
-
-  /**
-   * @override
-   * @defaultValue
-   * ```typescript
-   * Object.assign({}, super.defaultUniforms, {
-   *   pulse: 0,
-   *   color: PIXI.utils.hex2rgb(0xCEECEE)
-   * })
-   * ```
-   */
-  static defaultUniforms: AbstractBaseShader.Uniforms;
-}

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShaders/standardColorationShaders/emanationColorationShader.d.ts

@@ -1,17 +0,0 @@
-/**
- * Emanation animation coloration shader
- */
-declare class EmanationColorationShader extends StandardColorationShader {
-  static fragmentShader: string;
-
-  /**
-   * @override
-   * @defaultValue
-   * ```typescript
-   * Object.assign({}, super.defaultUniforms, {
-   *   color: PIXI.utils.hex2rgb(0xCEECEE)
-   * })
-   * ```
-   */
-  static defaultUniforms: AbstractBaseShader.Uniforms;
-}