@league-of-foundry-developers/foundry-vtt-types 9.249.4 → 9.255.2

package/src/foundry/foundry.js/pixi/containers/placeableObjects/measuredTemplate.d.ts

@@ -33,6 +33,9 @@ declare global {
     /** @override */
     static embeddedName: 'MeasuredTemplate';
 
+    /** @override */
+    get bounds(): Rectangle;
+
     /**
      * A convenience accessor for the border color as a numeric hex code
      */

package/src/foundry/foundry.js/pixi/containers/placeableObjects/note.d.ts

@@ -4,11 +4,14 @@ import { HoverInOptions } from '../placeableObject';
 declare global {
   /**
    * A Note is an implementation of PlaceableObject which represents an annotated location within the Scene.
-   * Each Note links to a JournalEntry entity and represents it's location on the map.
+   * Each Note links to a JournalEntry document and represents its location on the map.
    */
   class Note extends PlaceableObject<InstanceType<ConfiguredDocumentClass<typeof NoteDocument>>> {
     /** @override */
-    static get embeddedName(): 'Note';
+    static embeddedName: 'Note';
+
+    /** @override */
+    get bounds(): Rectangle;
 
     /**
      * The associated JournalEntry which is described by this note
@@ -25,6 +28,13 @@ declare global {
      */
     get size(): number;
 
+    /**
+     * Determine whether the Note is visible to the current user based on their perspective of the Scene.
+     * Visibility depends on permission to the underlying journal entry, as well as the perspective of controlled Tokens.
+     * If Token Vision is required, the user must have a token with vision over the note to see it.
+     */
+    get isVisible(): boolean;
+
     /** @override */
     draw(): Promise<this>;
 

package/src/foundry/foundry.js/pixi/containers/placeableObjects/tile.d.ts

@@ -36,6 +36,12 @@ declare global {
      */
     tile: PIXI.Sprite | undefined;
 
+    /**
+     * The occlusion image sprite
+     * @defaultValue `undefined`
+     */
+    occlusionTile: PIXI.Sprite | undefined;
+
     /**
      * A Tile background which is displayed if no valid image texture is present
      * @defaultValue `undefined`
@@ -72,6 +78,9 @@ declare global {
      */
     get aspectRatio(): number;
 
+    /** @override */
+    get bounds(): Rectangle;
+
     /**
      * The HTML source element for the primary Tile texture
      */
@@ -91,7 +100,12 @@ declare global {
     draw(): Promise<this>;
 
     /** @override */
-    refresh(): this;
+    destroy(options?: Parameters<PlaceableObject['destroy']>[0]): void;
+
+    /**
+     * @param options - (default: `{}`)
+     * @override */
+    refresh(options?: Tile.RefreshOptions | undefined): this;
 
     /**
      * Refresh the display of the Tile border
@@ -111,7 +125,14 @@ declare global {
      * @param options - Additional options for modifying video playback
      *                  (default: `{}`)
      */
-    play(playing: boolean, options?: Partial<Tile.PlayOptions>): void;
+    play(playing: boolean, options?: Tile.PlayOptions | undefined): void;
+
+    /**
+     * Unlink the playback of this video tile from the playback of other tokens which are using the same base texture.
+     * @param source - The video element source
+     * @internal
+     */
+    protected _unlinkVideoPlayback(source: HTMLVideoElement): Promise<void>;
 
     /**
      * Update the occlusion rendering for this overhead Tile for a given controlled Token.
@@ -128,7 +149,7 @@ declare global {
      */
     testOcclusion(
       token: InstanceType<ConfiguredObjectClassForName<'Token'>>,
-      options?: Partial<Tile.OcclusionOptions>
+      options?: Tile.OcclusionOptions | undefined
     ): boolean;
 
     /**
@@ -154,7 +175,7 @@ declare global {
      * @param options - Options which customize the return value
      * @internal
      */
-    protected _createAlphaMap(options: Partial<Tile.AlphaMapOptions>): Exclude<Tile['_alphaMap'], undefined>;
+    protected _createAlphaMap(options: Tile.AlphaMapOptions): Exclude<Tile['_alphaMap'], undefined>;
 
     /**
      * Compute the alpha-based bounding box for the tile, including an angle of rotation.
@@ -239,7 +260,7 @@ declare global {
      * Get resized Tile dimensions
      * @internal
      */
-    protected _getResizedDimensions(event: MouseEvent, origin: Point, destination: Point): NormalizedRectangle;
+    protected _getResizedDimensions(event: MouseEvent, origin: Point, destination: Point): Rectangle;
 
     /**
      * Handle cancellation of a drag event for one of the resizing handles
@@ -248,18 +269,27 @@ declare global {
 
     /**
      * Create a preview tile with a background texture instead of an image
+     * @param data - Initial data with which to create the preview Tile
      */
-    static createPreview(data: TileDataConstructorData): Tile;
+    static createPreview(data: TileDataConstructorData): InstanceType<ConfiguredObjectClassForName<'Tile'>>;
   }
 
   namespace Tile {
+    interface RefreshOptions {
+      /**
+       * Also refresh the perception layer.
+       * @defaultValue `false`
+       */
+      refreshPerception?: boolean | undefined;
+    }
+
     interface PlayOptions {
       /** Should the video loop? */
-      loop: boolean;
+      loop?: boolean | undefined;
       /** A specific timestamp between 0 and the video duration to begin playback */
-      offset: number;
+      offset?: number | undefined;
       /** Desired volume level of the video's audio channel (if any) */
-      volume: number;
+      volume?: number | undefined;
     }
 
     interface OcclusionOptions {
@@ -267,7 +297,7 @@ declare global {
        * Test corners of the hit-box in addition to the token center?
        * @defaultValue `true`
        */
-      corners: boolean;
+      corners?: boolean | undefined;
     }
 
     interface AlphaMapOptions {
@@ -275,13 +305,13 @@ declare global {
        * Keep the Uint8Array of pixel alphas?
        * @defaultValue `false`
        */
-      keepPixels: boolean;
+      keepPixels?: boolean | undefined;
 
       /**
        * Keep the pure white RenderTexture?
        * @defaultValue `false`
        */
-      keepTexture: boolean;
+      keepTexture?: boolean | undefined;
     }
   }
 }

package/src/foundry/foundry.js/pixi/containers/placeableObjects/token.d.ts

@@ -77,6 +77,9 @@ declare global {
      */
     readonly name: string;
 
+    /** @override */
+    get bounds(): Rectangle;
+
     /**
      * Translate the token's grid width into a pixel width based on the canvas size
      */

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

@@ -42,8 +42,9 @@ declare abstract class PointSourcePolygon extends PIXI.Polygon {
   /**
    * A cached array of SightRay objects used to compute the polygon.
    * @defaultValue `[]`
+   * @remarks This is documented as `SightRay[]` but that's only correct for the {@link RadialSweepPolygon}
    */
-  rays: SightRay[];
+  rays: Ray[];
 
   /**
    * Compute the rectangular bounds for the Polygon.
@@ -66,11 +67,12 @@ declare abstract class PointSourcePolygon extends PIXI.Polygon {
    * Compute the polygon given a point origin and radius
    * @param origin - The origin source point
    * @param config - Configuration options which customize the polygon computation
+   *                 (default: `{}`)
    * @returns The computed polygon instance
    */
   static create(
     origin: Point,
-    config: Parameters<PointSourcePolygon['initialize']>[1]
+    config?: Parameters<PointSourcePolygon['initialize']>[1] | undefined
   ): ReturnType<PointSourcePolygon['compute']>;
 
   /**

package/src/foundry/foundry.js/pixi/polygons/pointSourcePolygons/clockwiseSweepPolygon.d.ts

@@ -37,13 +37,13 @@ declare global {
      * The minimum ray of emission
      * @defaultValue `Ray.fromAngle(origin.x, origin.y, config.aMin, config.radius)`
      */
-    rMin?: Ray;
+    rMin?: PolygonRay;
 
     /**
      * The maximum ray of emission
      * @defaultValue `config.hasLimitedAngle && Ray.fromAngle(origin.x, origin.y, config.aMax, config.radius)`
      */
-    rMax?: Ray;
+    rMax?: PolygonRay;
 
     /**
      * Does this polygon have a limited radius?
@@ -70,6 +70,10 @@ declare global {
     radiusE?: number;
   }
 
+  interface PolygonRay extends Ray {
+    result: CollisionResult;
+  }
+
   /**
    * A PointSourcePolygon implementation that uses CCW (counter-clockwise) geometry orientation.
    * Sweep around the origin, accumulating collision points based on the set of active walls.
@@ -97,7 +101,7 @@ declare global {
     /**
      * A collection of rays which are fired at vertices
      */
-    rays: SightRay[];
+    rays: PolygonRay[];
 
     static benchmark(
       iterations: number,
@@ -125,7 +129,7 @@ declare global {
      * @returns The ray with rounded vertices
      * @internal
      */
-    protected _roundRayVertices(ray: Ray): Ray;
+    protected _roundRayVertices(ray: PolygonRay): PolygonRay;
 
     /**
      * Translate walls and other obstacles into edges which limit visibility
@@ -194,7 +198,7 @@ declare global {
      * @internal
      */
     protected _isVertexBehindActiveEdges(
-      ray: Ray,
+      ray: PolygonRay,
       vertex: PolygonVertex,
       activeEdges: EdgeSet
     ): { isBehind: boolean; wasLimited: boolean };
@@ -207,7 +211,12 @@ declare global {
      * @param activeEdges - The set of active edges
      * @internal
      */
-    protected _determineRayResult(ray: Ray, vertex: PolygonVertex, result: CollisionResult, activeEdges: EdgeSet): void;
+    protected _determineRayResult(
+      ray: PolygonRay,
+      vertex: PolygonVertex,
+      result: CollisionResult,
+      activeEdges: EdgeSet
+    ): void;
 
     /**
      * Jump to a new closest active edge.
@@ -223,7 +232,7 @@ declare global {
      *                          (default: `true`)
      */
     protected _beginNewEdge(
-      ray: Ray,
+      ray: PolygonRay,
       result: CollisionResult,
       activeEdges: EdgeSet,
       isBinding: boolean,
@@ -241,7 +250,12 @@ declare global {
      * @param activeEdges - The set of currently active edges
      * @param isBinding   - Is the target vertex a binding collision point?
      */
-    protected _completeCurrentEdge(ray: Ray, result: CollisionResult, activeEdges: EdgeSet, isBinding: boolean): void;
+    protected _completeCurrentEdge(
+      ray: PolygonRay,
+      result: CollisionResult,
+      activeEdges: EdgeSet,
+      isBinding: boolean
+    ): void;
 
     /**
      * Augment a CollisionResult with an additional secondary collision.
@@ -251,7 +265,7 @@ declare global {
      * @param edges  - The subset of active edges which are candidates for collision
      * @internal
      */
-    protected _getSecondaryCollisions(ray: Ray, result: CollisionResult, edges: EdgeSet): PolygonVertex[];
+    protected _getSecondaryCollisions(ray: PolygonRay, result: CollisionResult, edges: EdgeSet): PolygonVertex[];
 
     /**
      * Identify collision points for a required terminal ray.
@@ -261,7 +275,7 @@ declare global {
      * @param result      - The pending collision result
      * @param activeEdges - The set of currently active edges
      */
-    protected _findRequiredCollision(ray: Ray, result: CollisionResult, activeEdges: EdgeSet): void;
+    protected _findRequiredCollision(ray: PolygonRay, result: CollisionResult, activeEdges: EdgeSet): void;
 
     /**
      * Identify the collision points between an emitted Ray and a set of active edges.
@@ -271,7 +285,7 @@ declare global {
      * @internal
      */
     protected _getRayCollisions(
-      ray: Ray,
+      ray: PolygonRay,
       activeEdges: EdgeSet,
       {
         minimumDistance
@@ -304,7 +318,7 @@ declare global {
      * @param r1 - The next ray that collides with some vertex
      * @internal
      */
-    protected _getPaddingPoints(r0: Ray, r1: Ray): Point[];
+    protected _getPaddingPoints(r0: PolygonRay, r1: PolygonRay): Point[];
 
     /**
      * Test whether a wall should be included in the computed polygon for a given origin and type
@@ -328,7 +342,7 @@ declare global {
      * @param angle  - The angle being tested, in degrees
      * @returns Is the vertex between the two rays?
      */
-    static pointBetweenRays(vertex: PolygonVertex, rMin: Ray, rMax: Ray, angle: number): boolean;
+    static pointBetweenRays(vertex: PolygonVertex, rMin: PolygonRay, rMax: PolygonRay, angle: number): boolean;
 
     /** @override */
     visualize(): void;
@@ -342,7 +356,7 @@ declare global {
      *          The closest collision, if mode is "closest"
      */
     static getRayCollisions<Mode extends 'any' | 'closest' | 'all'>(
-      ray: Ray,
+      ray: PolygonRay,
       options?: {
         /**
          * Which collision type to check, a value in CONST.WALL_RESTRICTION_TYPES
@@ -368,7 +382,7 @@ declare global {
      * Visualize the polygon, displaying its computed area, rays, and collision points
      * @internal
      */
-    protected static _visualizeCollision(ray: Ray, edges: EdgeSet, collisions: PolygonVertex[]): void;
+    protected static _visualizeCollision(ray: PolygonRay, edges: EdgeSet, collisions: PolygonVertex[]): void;
   }
 
   namespace ClockwiseSweepPolygon {
@@ -385,12 +399,12 @@ declare global {
       rotation: number;
       hasLimitedAngle: boolean;
       density: number;
-      rMin: Ray;
+      rMin: PolygonRay;
     }
 
     interface LimitedAngleConfig extends InitializedConfig {
       hasLimitedAngle: true;
-      rMax: Ray;
+      rMax: PolygonRay;
     }
   }
 }

package/src/foundry/foundry.js/rollTerms/diceTerms/die.d.ts

@@ -207,11 +207,6 @@ declare class Die extends DiceTerm {
 }
 
 declare namespace Die {
-  interface Data extends Partial<TermData> {
-    class: 'Die';
-    results: DiceTerm.Result[];
-  }
-
   interface TermData extends DiceTerm.TermData {
     modifiers: Array<keyof typeof Die['MODIFIERS']>;
   }

package/src/foundry/foundry.js/rollTerms/diceTerms/fateDie.d.ts

@@ -3,7 +3,7 @@
  * Mathematically behaves like 1d3-2
  */
 declare class FateDie extends DiceTerm {
-  constructor(termData?: Partial<DiceTerm.TermData>);
+  constructor(termData?: Partial<FateDie.TermData>);
 
   faces: 3;
 
@@ -12,6 +12,9 @@ declare class FateDie extends DiceTerm {
    */
   static DENOMINATION: string;
 
+  /** @override */
+  static MODIFIERS: FateDie.Modifiers;
+
   /**
    * @override
    */
@@ -22,3 +25,20 @@ declare class FateDie extends DiceTerm {
    */
   getResultLabel(result: DiceTerm.Result): string;
 }
+
+declare namespace FateDie {
+  interface TermData extends DiceTerm.TermData {
+    modifiers: Array<keyof typeof FateDie['MODIFIERS']>;
+  }
+
+  interface Modifiers {
+    r: Die['reroll'];
+    rr: Die['rerollRecursive'];
+    k: Die['keep'];
+    kh: Die['keep'];
+    kl: Die['keep'];
+    d: Die['drop'];
+    dh: Die['drop'];
+    dl: Die['drop'];
+  }
+}

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

@@ -5,13 +5,6 @@
 declare class VideoHelper {
   constructor();
 
-  /**
-   * A collection of HTML5 video objects which are currently active within the FVTT page
-   * @defaultValue `[]`
-   * @remarks This seems to be unused.
-   */
-  videos: HTMLVideoElement[];
-
   /**
    * A user gesture must be registered before video playback can begin.
    * This Set records the video elements which await such a gesture.

package/src/foundry/index.d.ts

@@ -20,12 +20,9 @@ import './foundry.js/clientSettings';
 import './foundry.js/collections';
 import './foundry.js/collisionResult';
 import './foundry.js/config';
-import './foundry.js/constants';
 import './foundry.js/contextMenu';
 import './foundry.js/dragDrop';
 import './foundry.js/draggable';
-import './foundry.js/features';
-import './foundry.js/fonts';
 import './foundry.js/formDataExtended';
 import './foundry.js/game';
 import './foundry.js/gameTime';
@@ -74,7 +71,6 @@ import './foundry.js/templateUtils';
 import './foundry.js/textEditor';
 import './foundry.js/textureLoader';
 import './foundry.js/textureUtils';
-import './foundry.js/types';
 import './foundry.js/userTargets';
 import './foundry.js/utils';
 import './foundry.js/videoHelper';

package/src/types/helperTypes.d.ts

@@ -103,6 +103,12 @@ export type PlaceableDocumentType =
   | 'Token'
   | 'Wall';
 
+export type DocumentSubTypes<T extends DocumentType> = 'type' extends keyof InstanceType<
+  ConfiguredDocumentClassForName<T>
+>['data']
+  ? InstanceType<ConfiguredDocumentClassForName<T>>['data']['type']
+  : typeof foundry.CONST.BASE_DOCUMENT_TYPE;
+
 export type ConfiguredDocumentClassForName<Name extends DocumentType> = CONFIG[Name]['documentClass'];
 
 export type ConfiguredObjectClassForName<Name extends PlaceableDocumentType> = CONFIG[Name]['objectClass'];