@league-of-foundry-developers/foundry-vtt-types 9.268.0 → 9.269.0

package/src/foundry/{foundry.js/rollTerms/diceTerms → client/dice/dice}/die.d.ts

@@ -11,13 +11,11 @@ declare class Die extends DiceTerm {
   constructor(termData?: Partial<Die.TermData>);
 
   /**
-   * @override
    * @defaultValue `"d"`
    */
-  static DENOMINATION: string;
+  static override DENOMINATION: string;
 
   /**
-   * @override
    * @defaultValue
    * ```typescript
    * {
@@ -43,12 +41,9 @@ declare class Die extends DiceTerm {
    * }
    * ```
    */
-  static MODIFIERS: Die.Modifiers;
+  static override MODIFIERS: Die.Modifiers;
 
-  /**
-   * @override
-   */
-  get total(): number | null;
+  override get total(): number | null;
 
   /**
    * Re-roll the Die, rolling additional results for any values which fall within a target set.

package/src/foundry/{foundry.js/rollTerms/diceTerms/fateDie.d.ts → client/dice/dice/fate.d.ts}

@@ -12,18 +12,11 @@ declare class FateDie extends DiceTerm {
    */
   static DENOMINATION: string;
 
-  /** @override */
-  static MODIFIERS: FateDie.Modifiers;
+  static override MODIFIERS: FateDie.Modifiers;
 
-  /**
-   * @override
-   */
-  roll({ minimize, maximize }?: { minimize: boolean; maximize: boolean }): DiceTerm.Result;
+  override roll({ minimize, maximize }?: { minimize: boolean; maximize: boolean }): DiceTerm.Result;
 
-  /**
-   * @override
-   */
-  getResultLabel(result: DiceTerm.Result): string;
+  override getResultLabel(result: DiceTerm.Result): string;
 }
 
 declare namespace FateDie {

package/src/foundry/client/dice/dice/index.d.ts

@@ -0,0 +1,3 @@
+import './coin';
+import './die';
+import './fate';

package/src/foundry/client/dice/index.d.ts

@@ -0,0 +1,5 @@
+import './dice';
+import './roll';
+import './term';
+import './terms';
+import './twister';

package/src/foundry/{foundry.js → client/dice}/roll.d.ts

@@ -1,4 +1,4 @@
-import { ConfiguredDocumentClass } from '../../types/helperTypes';
+import { ConfiguredDocumentClass } from '../../../types/helperTypes';
 
 declare global {
   /**
@@ -147,8 +147,8 @@ declare global {
      * console.log(r.total);  // 11
      * ```
      */
-    evaluate(options?: InexactPartial<Options & { async: false }>): Evaluated<this>;
-    evaluate(options: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    evaluate(options?: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    evaluate(options: InexactPartial<Options & { async: false }>): Evaluated<this>;
     evaluate(options?: InexactPartial<Options>): Evaluated<this> | Promise<Evaluated<this>>;
 
     /**
@@ -173,8 +173,8 @@ declare global {
      * Alias for evaluate.
      * @see Roll#evaluate
      */
-    roll(options?: InexactPartial<Options & { async: false }>): Evaluated<this>;
-    roll(options: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    roll(options?: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    roll(options: InexactPartial<Options & { async: false }>): Evaluated<this>;
     roll(options?: InexactPartial<Options>): Evaluated<this> | Promise<Evaluated<this>>;
 
     /**
@@ -183,8 +183,8 @@ 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 }>): Evaluated<this>;
-    reroll(options: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    reroll(options?: InexactPartial<Options> & { async: true }): Promise<Evaluated<this>>;
+    reroll(options: InexactPartial<Options & { async: false }>): Evaluated<this>;
     reroll(options?: InexactPartial<Options>): Evaluated<this> | Promise<Evaluated<this>>;
 
     /**

package/src/foundry/{foundry.js/rollTerms/diceTerm.d.ts → client/dice/terms/dice.d.ts}

@@ -68,8 +68,7 @@ declare abstract class DiceTerm extends RollTerm {
   /** Return an array of rolled values which are still active within this term */
   get values(): number[];
 
-  /** @override */
-  get isDeterministic(): boolean;
+  override get isDeterministic(): boolean;
 
   /* -------------------------------------------- */
 

package/src/foundry/client/dice/terms/index.d.ts

@@ -0,0 +1,7 @@
+import './dice';
+import './math';
+import './numeric';
+import './operator';
+import './parenthetical';
+import './pool';
+import './string';

package/src/foundry/{foundry.js/rollTerms/mathTerm.d.ts → client/dice/terms/math.d.ts}

@@ -44,8 +44,7 @@ declare global {
 
     get expression(): string;
 
-    /** @override */
-    get isDeterministic(): boolean;
+    override get isDeterministic(): boolean;
 
     protected _evaluateSync({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): this;
 

package/src/foundry/{foundry.js/rollTerms/parentheticalTerm.d.ts → client/dice/terms/parenthetical.d.ts}

@@ -22,8 +22,7 @@ declare class ParentheticalTerm extends RollTerm {
   /** An array of evaluated DiceTerm instances that should be bubbled up to the parent Roll */
   get dice(): DiceTerm[];
 
-  /** @override */
-  get isDeterministic(): boolean;
+  override get isDeterministic(): boolean;
 
   /**
    * Construct a ParentheticalTerm from an Array of component terms which should be wrapped inside the parentheses.

package/src/foundry/{foundry.js/rollTerms/poolTerm.d.ts → client/dice/terms/pool.d.ts}

@@ -209,7 +209,6 @@ interface PoolTermConstructorData {
    */
   terms?: string[];
 
-  /** @override */
   get isDeterministic(): boolean;
 
   /**

package/src/foundry/{foundry.js/rollTerms/stringTerm.d.ts → client/dice/terms/string.d.ts}

@@ -16,8 +16,7 @@ declare global {
 
     get total(): string;
 
-    /** @override */
-    get isDeterministic(): boolean;
+    override get isDeterministic(): boolean;
 
     evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): never;
   }

package/src/foundry/{foundry.js → client}/game.d.ts

@@ -473,9 +473,6 @@ declare global {
      */
     protected _onWindowBlur(event: FocusEvent): void;
 
-    /**
-     * @param event - (unused)
-     */
     protected _onWindowPopState(event: PopStateEvent): void;
 
     /**
@@ -672,6 +669,12 @@ declare global {
 
     type View = ValueOf<typeof foundry.CONST.GAME_VIEWS>;
   }
+
+  /**
+   * @defaultValue `undefined`
+   * Initialized between the `'DOMContentLoaded'` event and the `'init'` hook event.
+   */
+  let canvas: 'canvas' extends keyof LenientGlobalVariableTypes ? Canvas : Canvas | undefined;
 }
 
 type ConfiguredCollectionClassForName<Name extends foundry.CONST.DOCUMENT_TYPES> = InstanceType<

package/src/foundry/client/head.d.ts

@@ -0,0 +1,44 @@
+export {};
+
+declare global {
+  let vtt: 'Foundry VTT';
+
+  /**
+   * @defaultValue `{}`
+   * @remarks
+   * Initialized between the `'DOMContentLoaded'` event and the `'init'` hook event.
+   */
+  let game: 'game' extends keyof LenientGlobalVariableTypes ? Game : Game | {};
+
+  /**
+   * @defaultValue `null`
+   * @remarks
+   * Initialized between the `'DOMContentLoaded'` event and the `'init'` hook event.
+   */
+  let socket: 'socket' extends keyof LenientGlobalVariableTypes ? io.Socket : io.Socket | null;
+
+  /**
+   * A collection of application instances
+   * @remarks
+   * - All of the elements of {@link ui} except for `context` and `window` are initialized between the `'setup'` and `'ready'` hook events.
+   * - In the `/stream` view, only `chat` is initialized but none of the other {@link Application}s.
+   */
+  let ui: {
+    /**
+     * @remarks
+     * Initialized whenever a {@link ContextMenu} is opened, deleted when it's closed again.
+     */
+    context?: ContextMenu;
+
+    /**
+     * @defaultValue `{}`
+     */
+    windows: Record<number, Application>;
+  } & ('ui' extends keyof LenientGlobalVariableTypes ? UiApplications : Partial<UiApplications>);
+
+  let logger: typeof console;
+}
+
+type UiApplications = {
+  [Key in keyof CONFIG['ui']]: InstanceType<CONFIG['ui'][Key]>;
+};

package/src/foundry/client/index.d.ts

@@ -0,0 +1,12 @@
+import './apps';
+import './audio';
+import './av';
+import './config';
+import './core';
+import './data';
+import './dice';
+import './game';
+import './head';
+import './pixi';
+import './tail';
+import './ui';

package/src/foundry/{foundry.js/canvas.d.ts → client/pixi/board.d.ts}

@@ -1,27 +1,26 @@
-import { ConfiguredDocumentClass } from '../../types/helperTypes';
-import { BaseScene } from '../common/documents.mjs';
-
-/**
- * The virtual tabletop environment is implemented using a WebGL powered HTML 5 canvas using the powerful PIXI.js
- * library. The canvas is comprised of an ordered sequence of layers which define rendering groups and collections of
- * objects that are drawn on the canvas itself.
- *
- * @see {@link CanvasLayer} An abstract class for all Canvas layers.
- * @see {@link PlaceablesLayer} An abstract class for Canvas Layers which contain Placeable Objects.
- * @see {@link PlaceableObject} An abstract class for objects which are placed into the Scene and drawn on the canvas.
- *
- * @example <caption>Example Canvas commands</caption>
- * ```typescript
- * canvas.ready; // Is the canvas ready for use?
- * canvas.scene; // The currently viewed Scene document.
- * canvas.dimensions; // The dimensions of the current Scene.
- * canvas.draw(); // Completely re-draw the game canvas (this is usually unnecessary).
- * canvas.pan(x, y, zoom); // Pan the canvas to new coordinates and scale.
- * canvas.recenter(); // Re-center the canvas on the currently controlled Token.
- * ```
- */
+import { ConfiguredDocumentClass } from '../../../types/helperTypes';
+import { BaseScene } from '../../common/documents.mjs';
 
 declare global {
+  /**
+   * The virtual tabletop environment is implemented using a WebGL powered HTML 5 canvas using the powerful PIXI.js
+   * library. The canvas is comprised of an ordered sequence of layers which define rendering groups and collections of
+   * objects that are drawn on the canvas itself.
+   *
+   * @see {@link CanvasLayer} An abstract class for all Canvas layers.
+   * @see {@link PlaceablesLayer} An abstract class for Canvas Layers which contain Placeable Objects.
+   * @see {@link PlaceableObject} An abstract class for objects which are placed into the Scene and drawn on the canvas.
+   *
+   * @example <caption>Example Canvas commands</caption>
+   * ```typescript
+   * canvas.ready; // Is the canvas ready for use?
+   * canvas.scene; // The currently viewed Scene document.
+   * canvas.dimensions; // The dimensions of the current Scene.
+   * canvas.draw(); // Completely re-draw the game canvas (this is usually unnecessary).
+   * canvas.pan(x, y, zoom); // Pan the canvas to new coordinates and scale.
+   * canvas.recenter(); // Re-center the canvas on the currently controlled Token.
+   * ```
+   */
   class Canvas {
     constructor();
 
@@ -433,7 +432,6 @@ declare global {
     /**
      * Handle the conclusion of a right-mouse drag workflow the Canvas stage.
      * @see {@link MouseInteractionManager#_handleDragDrop}
-     * @param event - (unused)
      */
     protected _onDragRightDrop(event: PIXI.InteractionEvent): void;
 
@@ -486,7 +484,6 @@ declare global {
     /**
      * Get a reference to the a specific CanvasLayer by it's name
      * @param layerName - The name of the canvas layer to get
-     *                    (unused)
      * @deprecated since v9, will be deleted in v10
      */
     getLayer(layerName: any): {

package/src/foundry/client/pixi/core/containers/index.d.ts

@@ -0,0 +1,3 @@
+import './cached-container';
+import './quadtree';
+import './sampler-mesh';

package/src/foundry/{foundry.js/screenCulling.d.ts → client/pixi/core/culling.d.ts}

@@ -17,3 +17,21 @@ declare class ScreenCulling {
    */
   intersects(rect: Rectangle, bounds: Rectangle): boolean;
 }
+
+/**
+ * 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;
+}
+
+/**
+ * Benchmark the performance of different culling methods
+ * @internal
+ */
+declare function benchmarkCulling(n?: number): Promise<void>;

package/src/foundry/client/pixi/core/index.d.ts

@@ -0,0 +1,5 @@
+import './containers';
+import './culling';
+import './interaction';
+import './loader';
+import './shapes';

package/src/foundry/client/pixi/core/interaction/index.d.ts

@@ -0,0 +1,5 @@
+import './canvas-animation';
+import './control-icon';
+import './mouse-handler';
+import './resize-handle';
+import './targets';

package/src/foundry/{foundry.js/userTargets.d.ts → client/pixi/core/interaction/targets.d.ts}

@@ -1,5 +1,5 @@
-import { ConfiguredDocumentClass } from '../../types/helperTypes';
-import { ObjectClass } from '../../types/helperTypes';
+import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import { ObjectClass } from '../../../../../types/helperTypes';
 
 interface SetReplacementMembers<T> {
   add(value: T): void;
@@ -32,19 +32,16 @@ declare global {
     get ids(): string[];
 
     /**
-     * @override
      * @remarks Returns void, but Set<T>.add returns boolean
      */
-    add(token: InstanceType<ObjectClass<typeof TokenDocument>>): void;
+    override add(token: InstanceType<ObjectClass<typeof TokenDocument>>): void;
 
-    /** @override */
-    clear(): void;
+    override clear(): void;
 
     /**
-     * @override
      * @remarks Returns void, but Set<T>.delete returns boolean
      */
-    delete(token: InstanceType<ObjectClass<typeof TokenDocument>>): void;
+    override delete(token: InstanceType<ObjectClass<typeof TokenDocument>>): void;
 
     /**
      * Dispatch the targetToken hook whenever the user's target set changes

package/src/foundry/{foundry.js/textureLoader.d.ts → client/pixi/core/loader.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredDocumentClassForName } from '../../types/helperTypes';
+import type { ConfiguredDocumentClassForName } from '../../../../types/helperTypes';
 
 declare global {
   /**
@@ -143,4 +143,29 @@ declare global {
       pct: number;
     }
   }
+
+  /**
+   * Test whether a file source exists by performing a HEAD request against it
+   * @param src - The source URL or path to test
+   * @returns Does the file exist at the provided url?
+   */
+  function srcExists(src: string): Promise<boolean>;
+
+  /**
+   * Get a single texture from the cache
+   */
+  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
+   */
+  function loadTexture(
+    src: string,
+    options?: {
+      /** A fallback texture to use if the requested source is unavailable or invalid */
+      fallback?: string | undefined;
+    }
+  ): Promise<PIXI.Texture | null>;
 }

package/src/foundry/client/pixi/core/shapes/index.d.ts

@@ -0,0 +1,5 @@
+import './normalized-rectangle';
+import './polygon-helpers';
+import './precise-text';
+import './ray';
+import './source-polygon';