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

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

@@ -249,6 +249,9 @@ declare global {
       /** @defaultValue `Cards` */
       documentClass: ConfiguredDocumentClassOrDefault<typeof Cards>;
 
+      /** @defaultValue `"fas fa-id-badge"` */
+      sidebarIcon: string;
+
       presets: {
         /**
          * @defaultValue
@@ -505,7 +508,7 @@ declare global {
       /** @defaultValue `Macros` */
       collection: ConstructorOf<Macros>;
 
-      /** @defaultValue `'fas fa-terminal'` */
+      /** @defaultValue `'fas fa-code'` */
       sidebarIcon: string;
     };
 
@@ -973,7 +976,7 @@ declare global {
 
     /**
      * Suggested font families that are displayed wherever a choice is presented
-     * @defaultValue `['Arial', 'Arial Black', 'Comic Sans MS', 'Courier New', 'Times New Roman', 'Signika', 'Modesto Condensed']`
+     * @defaultValue `["Arial", "Courier", "Courier New", "Helvetica", "Signika", "Times", "Times New Roman", "Modesto Condensed"]`
      */
     fontFamilies: string[];
 

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

@@ -1,3 +1,27 @@
+interface DragDropConfiguration {
+  /**
+   * The CSS selector used to target draggable elements.
+   */
+  dragSelector?: DragDrop['dragSelector'];
+
+  /**
+   * The CSS selector used to target viable drop targets.
+   */
+  dropSelector?: DragDrop['dropSelector'];
+
+  /**
+   * An object of permission test functions for each action
+   * @defaultValue `{}`
+   */
+  permissions?: DragDrop['permissions'];
+
+  /**
+   * An object of callback functions for each action
+   * @defaultValue `{}`
+   */
+  callbacks?: DragDrop['callbacks'];
+}
+
 /**
  * A controller class for managing drag and drop workflows within an Application instance.
  * The controller manages the following actions: dragstart, dragover, drop
@@ -16,16 +40,9 @@
  */
 declare class DragDrop {
   /**
-   * @param dragSelector - The CSS selector used to target draggable elements.
-   *                       (default: `undefined`)
-   * @param dropSelector - The CSS selector used to target viable drop targets.
-   *                       (default: `undefined`)
-   * @param permissions  - An object of permission test functions for each action
-   *                       (default: `{}`)
-   * @param callbacks    - An object of callback functions for each action
-   *                       (default: `{}`)
+   * @param options - (default: `{}`)
    */
-  constructor({ dragSelector, dropSelector, permissions, callbacks }?: DragDrop.Options);
+  constructor({ dragSelector, dropSelector, permissions, callbacks }?: DragDropConfiguration);
 
   /**
    * The HTML selector which identifies draggable elements
@@ -65,7 +82,7 @@ declare class DragDrop {
   callback(event: DragEvent, action: DragDrop.Action): void;
 
   /**
-   * Test whether the current user has permission to perform a step of the workflow
+   * Execute a callback function associated with a certain action in the workflow
    * @param action   - The action being attempted
    * @param selector - The selector being targeted
    * @returns Can the action be performed?
@@ -97,29 +114,5 @@ declare class DragDrop {
 }
 
 declare namespace DragDrop {
-  interface Options {
-    /**
-     * The CSS selector used to target draggable elements.
-     */
-    dragSelector?: DragDrop['dragSelector'];
-
-    /**
-     * The CSS selector used to target viable drop targets.
-     */
-    dropSelector?: DragDrop['dropSelector'];
-
-    /**
-     * An object of permission test functions for each action
-     * @defaultValue `{}`
-     */
-    permissions?: DragDrop['permissions'];
-
-    /**
-     * An object of callback functions for each action
-     * @defaultValue `{}`
-     */
-    callbacks?: DragDrop['callbacks'];
-  }
-
   type Action = 'dragstart' | 'dragover' | 'drop';
 }

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

@@ -2,8 +2,10 @@ import './blendModes';
 import './containers';
 import './filters';
 import './graphics';
+import './meshes';
 import './points';
 import './polygons';
 import './rectangles';
 import './shaders';
 import './texts';
+import './transforms';

package/src/foundry/foundry.js/pixi/meshes/index.d.ts

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

package/src/foundry/foundry.js/pixi/meshes/samplerMesh.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A Mesh subclass used to render a texture with faster performance than a PIXI.Sprite.
+ */
+declare class SamplerMesh extends PIXI.Mesh {
+  /**
+   * The basic quad geometry used for the Mesh
+   * @defaultValue
+   * ```javascript
+   * new PIXI.Geometry()
+   *   .addAttribute('aVertexPosition', [0, 0, 1, 0, 1, 1, 0, 1], 2)
+   *   .addAttribute('aUvs', [0, 0, 1, 0, 1, 1, 0, 1], 2)
+   *   .addIndex([0, 1, 2, 0, 2, 3])
+   * ```
+   */
+  static QUAD: PIXI.Geometry;
+
+  /**
+   * Create a SamplerMesh using a provided RenderTexture
+   * @param texture - The texture to render using a Mesh
+   */
+  static create(texture: PIXI.RenderTexture): SamplerMesh;
+}

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

@@ -119,6 +119,14 @@ declare global {
     /** @override */
     protected _compute(): void;
 
+    /**
+     * Round vertices of a ray segment
+     * @param ray - The provided ray
+     * @returns The ray with rounded vertices
+     * @internal
+     */
+    protected _roundRayVertices(ray: Ray): Ray;
+
     /**
      * Translate walls and other obstacles into edges which limit visibility
      * @internal

package/src/foundry/foundry.js/pixi/rectangles/normalizedRectangle.d.ts

@@ -4,6 +4,13 @@
 declare class NormalizedRectangle extends PIXI.Rectangle {
   constructor(x: number, y: number, width: number, height: number);
 
+  /**
+   * Determine whether some other Rectangle intersects with this one.
+   * @param other - Some other rectangle against which to compare
+   * @returns Do the rectangles intersect?
+   */
+  intersects(other: PIXI.Rectangle): boolean;
+
   /**
    * Generate a new rectangle by rotating this one clockwise about its center by a certain number of radians
    * @param radians - The angle of rotation

package/src/foundry/foundry.js/pixi/shaders/abstractBaseShader.d.ts

@@ -14,7 +14,7 @@ declare abstract class AbstractBaseShader extends PIXI.Shader {
 
   /**
    * The raw vertex shader used by this class.
-   * A subclass of AbstractBaseShader must implement the fragmentShader static field.
+   * A subclass of AbstractBaseShader must implement the vertexShader static field.
    * @defaultValue `""`
    *
    * @remarks This is abstract, subclasses must implement it.

package/src/foundry/foundry.js/pixi/transforms/index.d.ts

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

package/src/foundry/foundry.js/pixi/transforms/synchronizedTransform.d.ts

@@ -0,0 +1,38 @@
+/**
+ * An extension of PIXI.Transform.
+ * This uses a different DisplayObject than the current parent as the reference for the worldTransform.
+ */
+declare class SynchronizedTransform extends PIXI.Transform {
+  constructor(transform: PIXI.Transform);
+
+  /**
+   * A list of attributes from the transform reference which should be synchronized
+   * @defaultValue
+   * ```javascript
+   * [
+   *   "localTransform", "position", "scale", "pivot", "skew", "_rotation",
+   *   "_cx", "_sx", "_cy", "_sy", "_localID", "_currentLocalID"
+   * ];
+   * ```
+   */
+  static synchronizedAttributes: string[];
+
+  /**
+   * A Transform instance which defines the reference point for the worldTransform
+   */
+  get reference(): PIXI.Transform;
+
+  set reference(value: PIXI.Transform);
+
+  /** @internal */
+  protected _reference: PIXI.Transform;
+
+  /** @internal */
+  protected _syncLocalID: number;
+
+  /** @override */
+  updateTransform(parentTransform: PIXI.Transform): void;
+
+  /** @override */
+  updateLocalTransform(): void;
+}

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/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.
@@ -491,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/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/textureLoader.d.ts

@@ -8,11 +8,11 @@ declare global {
     /**
      * The cached mapping of textures
      */
-    cache: Map<string, { tex: PIXI.Texture; time: number }>;
+    cache: Map<string, { tex: PIXI.BaseTexture; time: number }>;
 
     /**
      * The duration in milliseconds for which a texture will remain cached
-     * @defaultValue `1000`
+     * @defaultValue `1000 * 60 * 15`
      */
     static CACHE_TTL: number;
 
@@ -33,14 +33,14 @@ declare global {
      * @param options - Additional options which modify loading
      * @returns A Promise which resolves once all textures are loaded
      */
-    load(sources: string[], options?: Partial<TextureLoader.LoadOptions>): Promise<void[]>;
+    load(sources: string[], options?: Partial<TextureLoader.LoadOptions>): Promise<PIXI.BaseTexture | void[]>;
 
     /**
      * Load a single texture on-demand from a given source URL path
      * @param src - The source texture path to load
      * @returns The loaded texture object
      */
-    loadTexture(src: string): Promise<PIXI.Texture>;
+    loadTexture(src: string): Promise<PIXI.BaseTexture>;
 
     /**
      * Log texture loading progress in the console and in the Scene loading bar
@@ -57,40 +57,50 @@ declare global {
     /**
      * Load an image texture from a provided source url
      */
-    loadImageTexture(src: string): Promise<PIXI.Texture>;
+    loadImageTexture(src: string): Promise<PIXI.BaseTexture>;
 
     /**
-     * If an attempted image load failed, we may attempt a re-load in case the issue was CORS + caching
-     * Cross-origin requests which failed might be CORS, or might be 404, no way to know - so try a 2nd time
-     * @param src     - The source URL being attempted
-     * @param resolve - Resolve the promise
-     * @param reject  - Reject the promise
+     * Use the Fetch API to retrieve a resource and return a Blob instance for it.
+     * @param options - Options to configure the loading behaviour.
+     *                  (default: `{}`)
      * @internal
      */
-    protected _attemptCORSReload<T>(
+    protected _fetchResource(
       src: string,
-      resolve: (tex: PIXI.Texture) => void,
-      reject: (reason: string) => T
-    ): Promise<PIXI.Texture | T>;
+      options?: {
+        /**
+         * Append a cache-busting query parameter to the request.
+         * @defaultValue `false`
+         */
+        bustCache?: boolean | undefined;
+      }
+    ): Promise<Blob>;
+
+    /**
+     * Return a URL with a cache-busting query parameter appended.
+     * @param src - The source URL being attempted
+     * @returns The new URL, or false on a failure.
+     * @internal
+     */
+    protected _getCacheBustURL(src: string): string | false;
 
     /**
      * Load a video texture from a provided source url
-     * @param src -
      */
-    loadVideoTexture(src: string): Promise<PIXI.Texture>;
+    loadVideoTexture(src: string): Promise<PIXI.BaseTexture>;
 
     /**
      * Add an image url to the texture cache
      * @param src - The source URL
      * @param tex - The readied texture
      */
-    setCache(src: string, tex: PIXI.Texture): void;
+    setCache(src: string, tex: PIXI.BaseTexture): void;
 
     /**
      * Retrieve a texture from the texture cache
      * @param src - The source URL
      */
-    getCache(src: string): PIXI.Texture | undefined;
+    getCache(src: string): PIXI.BaseTexture | undefined;
 
     /**
      * Expire (and destroy) textures from the cache which have not been used for more than CACHE_TTL milliseconds.

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

@@ -13,16 +13,13 @@ declare function getTexture(src: string): PIXI.Texture | null;
 /**
  * Load a single texture and return a Promise which resolves once the texture is ready to use
  * @param src      - The requested texture source
+ * @param options  - Additional options which modify texture loading
  * @param fallback - A fallback texture to use if the requested source is unavailable or invalid
  */
 declare function loadTexture(
   src: string,
-  {
-    fallback
-  }?: {
-    /**
-     * A fallback texture to use if the requested source is unavailable or invalid
-     */
-    fallback?: string;
+  options?: {
+    /** A fallback texture to use if the requested source is unavailable or invalid */
+    fallback?: string | undefined;
   }
-): Promise<PIXI.Texture>;
+): Promise<PIXI.Texture | null>;

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

@@ -65,7 +65,8 @@ declare class VideoHelper {
    * The thumbnail is cached using the video file path or URL.
    * @param src     - The source video URL
    * @param options - Thumbnail creation options, including width and height
-   * @returns The created and cached base64 thumbnail image
+   * @returns The created and cached base64 thumbnail image, or a placeholder image if the canvas is
+   *          disabled and no thumbnail can be generated.
    */
   createThumbnail(src: string, options: ImageHelper.CompositeOptions): Promise<string>;
 }