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

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>;
 }

package/src/types/helperTypes.d.ts

@@ -63,9 +63,35 @@ export type ConfiguredDocumentClass<T extends DocumentConstructor> = ConfiguredD
   T['metadata']['name']
 >;
 
-export type DocumentType = keyof {
-  [Key in keyof CONFIG as 'documentClass' extends keyof CONFIG[Key] ? Key : never]: unknown;
-};
+export type DocumentType =
+  | 'Actor'
+  | 'Adventure'
+  | 'Cards'
+  | 'ChatMessage'
+  | 'Combat'
+  | 'FogExploration'
+  | 'Folder'
+  | 'Item'
+  | 'JournalEntry'
+  | 'Macro'
+  | 'Playlist'
+  | 'RollTable'
+  | 'Scene'
+  | 'Setting'
+  | 'User'
+  | 'ActiveEffect'
+  | 'Card'
+  | 'TableResult'
+  | 'PlaylistSound'
+  | 'AmbientLight'
+  | 'AmbientSound'
+  | 'Combatant'
+  | 'Drawing'
+  | 'MeasuredTemplate'
+  | 'Note'
+  | 'Tile'
+  | 'Token'
+  | 'Wall';
 
 export type PlaceableDocumentType =
   | 'AmbientLight'
@@ -77,17 +103,9 @@ export type PlaceableDocumentType =
   | 'Token'
   | 'Wall';
 
-export type ConfiguredDocumentClassForName<Name extends DocumentType> = 'documentClass' extends keyof CONFIG[Name]
-  ? CONFIG[Name]['documentClass']
-  : never;
-
-export type ObjectType = keyof {
-  [Key in keyof CONFIG as 'objectClass' extends keyof CONFIG[Key] ? Key : never]: unknown;
-};
+export type ConfiguredDocumentClassForName<Name extends DocumentType> = CONFIG[Name]['documentClass'];
 
-export type ConfiguredObjectClassForName<Name extends ObjectType> = 'objectClass' extends keyof CONFIG[Name]
-  ? CONFIG[Name]['objectClass']
-  : never;
+export type ConfiguredObjectClassForName<Name extends PlaceableDocumentType> = CONFIG[Name]['objectClass'];
 
 export type ConfiguredData<Name extends string> = Name extends keyof DataConfig ? DataConfig[Name] : {};