@league-of-foundry-developers/foundry-vtt-types 0.8.9-9 → 9.238.0

package/src/foundry/foundry.js/pixi/containers/effectsCanvasGroup.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A container group which contains visual effects rendered above the primary group.
+ */
+declare class EffectsCanvasGroup extends PIXI.Container {
+  constructor();
+
+  walls: WallsLayer;
+
+  lighting: LightingLayer;
+
+  weather: WeatherLayer;
+
+  sight: SightLayer;
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @defaultValue `"effects"`
+   */
+  static groupName: string;
+
+  /**
+   * Create the member layers of the scene container
+   * @internal
+   */
+  protected _createLayers(): void;
+}

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

@@ -1,11 +1,14 @@
 import './baseGrid';
 import './baseGrids';
 import './cachedContainer';
+import './cachedContainers';
 import './canvasLayer';
 import './canvasLayers';
 import './controlIcon';
 import './cursor';
 import './doorControl';
+import './effectsCanvasGroup';
+import './interfaceCanvasGroup';
 import './placeableObject';
 import './placeableObjects';
 import './ruler';

package/src/foundry/foundry.js/pixi/containers/interfaceCanvasGroup.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A container group which displays interface elements rendered above other canvas groups.
+ */
+declare class InterfaceCanvasGroup extends PIXI.Container {
+  constructor();
+
+  sounds: SoundsLayer;
+
+  notes: NotesLayer;
+
+  controls: ControlsLayer;
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @defaultValue `"interface"`
+   */
+  static groupName: string;
+
+  /**
+   * Create the member layers of the scene container
+   * @internal
+   */
+  protected _createLayers(): void;
+}

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

@@ -258,7 +258,7 @@ declare global {
      * @param mode - The mode from CONST.TOKEN_DISPLAY_MODES
      * @returns Is the attribute viewable?
      */
-    protected _canViewMode(mode: foundry.CONST.TokenDisplayMode): boolean;
+    protected _canViewMode(mode: foundry.CONST.TOKEN_DISPLAY_MODES): boolean;
 
     /**
      * Animate Token movement along a certain path which is defined by a Ray object

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

@@ -178,7 +178,7 @@ declare class PointSource {
    * The source type from CONST.SOURCE_TYPES
    * @defaultValue `undefined`
    */
-  type?: foundry.CONST.SourceType;
+  type?: foundry.CONST.SOURCE_TYPES;
 
   /**
    * An animation configuration for the source
@@ -366,7 +366,7 @@ declare namespace PointSource {
      * The source type from CONST.SOURCE_TYPES
      * @defaultValue `CONST.SOURCE_TYPES.LOCAL`
      */
-    type?: foundry.CONST.SourceType;
+    type?: foundry.CONST.SOURCE_TYPES;
 
     /**
      * An animation configuration for the source

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

@@ -42,7 +42,7 @@ declare global {
     /**
      * Options which modify or describe the Roll
      */
-    options: Partial<Options>;
+    options: InexactPartial<Options>;
 
     /**
      * The identified terms of the Roll
@@ -72,10 +72,8 @@ declare global {
      */
     protected _total: number | undefined;
 
-    /**
-     * A Proxy environment for safely evaluating a string using only available Math functions
-     */
-    static MATH_PROXY: MathProxy;
+    /** A Proxy environment for safely evaluating a string using only available Math functions */
+    static MATH_PROXY: Math;
 
     /**
      * The HTML template path used to render a complete Roll object to the chat log
@@ -117,6 +115,9 @@ declare global {
      */
     get total(): number | undefined;
 
+    /** Whether this Roll contains entirely deterministic terms or whether there is some randomness. */
+    get isDeterministic(): boolean;
+
     /**
      * Alter the Roll expression by adding or multiplying the number of dice which are rolled
      * @param multiply        - A factor to multiply. Dice are multiplied before any additions.
@@ -146,21 +147,21 @@ declare global {
      * console.log(r.total);  // 11
      * ```
      */
-    evaluate(options?: Partial<Options & { async: false }>): this;
-    evaluate(options: Partial<Options> & { async: true }): Promise<this>;
-    evaluate(options?: Partial<Options>): this | Promise<this>;
+    evaluate(options?: InexactPartial<Options & { async: false }>): this;
+    evaluate(options: InexactPartial<Options> & { async: true }): Promise<this>;
+    evaluate(options?: InexactPartial<Options>): this | Promise<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?: Partial<Omit<Options, 'async'>>): Promise<this>;
+    protected _evaluate(options?: InexactPartial<Omit<Options, 'async'>>): Promise<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?: Partial<Omit<Options, 'async'>>): this;
+    protected _evaluateSync(options?: InexactPartial<Omit<Options, 'async'>>): this;
 
     /**
      * Safely evaluate the final total result for the Roll using its component terms.
@@ -172,9 +173,9 @@ declare global {
      * Alias for evaluate.
      * @see Roll#evaluate
      */
-    roll(options?: Partial<Options & { async: false }>): this;
-    roll(options: Partial<Options> & { async: true }): Promise<this>;
-    roll(options?: Partial<Options>): this | Promise<this>;
+    roll(options?: InexactPartial<Options & { async: false }>): this;
+    roll(options: InexactPartial<Options> & { async: true }): Promise<this>;
+    roll(options?: InexactPartial<Options>): this | Promise<this>;
 
     /**
      * Create a new Roll object using the original provided formula and data.
@@ -182,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?: Partial<Options & { async: false }>): this;
-    reroll(options: Partial<Options> & { async: true }): Promise<this>;
-    reroll(options?: Partial<Options>): this | Promise<this>;
+    reroll(options?: InexactPartial<Options & { async: false }>): this;
+    reroll(options: InexactPartial<Options> & { async: true }): Promise<this>;
+    reroll(options?: InexactPartial<Options>): this | Promise<this>;
 
     /**
      * A factory method which constructs a Roll instance using the default configured Roll class.
@@ -197,7 +198,7 @@ declare global {
     static create<D extends Record<string, unknown> = {}>(
       formula: string,
       data?: D,
-      options?: Partial<Options>
+      options?: InexactPartial<Options>
     ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<D>;
 
     /**
@@ -229,7 +230,7 @@ declare global {
      *                  (default: `10000`)
      * @returns The rolled totals
      */
-    static simulate(formula: string, n?: number): number[];
+    static simulate(formula: string, n?: number): Promise<number[]>;
 
     /**
      * Parse a formula by following an order of operations:
@@ -302,7 +303,7 @@ declare global {
      *                   (default: `{}`)
      * @returns An array of terms, split on dice pool terms
      */
-    protected _splitGroup(_formula: string, options?: Partial<SplitGroupOptions>): string[];
+    protected _splitGroup(_formula: string, options?: InexactPartial<SplitGroupOptions>): string[];
 
     /**
      * Split a formula by identifying arithmetic terms
@@ -373,15 +374,15 @@ declare global {
      */
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData?: T,
-      { rollMode, create }?: { rollMode?: foundry.CONST.DiceRollMode; create?: true }
+      { rollMode, create }?: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create?: true }
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof ChatMessage>> | undefined>;
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData: T,
-      { rollMode, create }: { rollMode?: foundry.CONST.DiceRollMode; create: false }
+      { rollMode, create }: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create: false }
     ): MessageData<T>;
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData: T,
-      { rollMode, create }: { rollMode?: foundry.CONST.DiceRollMode; create: boolean }
+      { rollMode, create }: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create: boolean }
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof ChatMessage>> | undefined> | MessageData<T>;
 
     /**
@@ -441,13 +442,8 @@ declare global {
      */
     static fromTerms(
       terms: RollTerm[],
-      options?: Partial<Options>
+      options?: InexactPartial<Options>
     ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<{}>;
-
-    /**
-     * @deprecated since 0.8.1
-     */
-    get _rolled(): boolean;
   }
 }
 
@@ -488,19 +484,12 @@ interface SplitGroupOptions {
 interface Data {
   formula: string;
   results: Array<number | string>;
-  terms: Array<(PoolTerm.TermData & { class: 'DicePool' }) | DiceTerm.Data>;
+  terms: Array<PoolTerm.TermData | DiceTerm.Data>;
   total: number | null;
 }
 
 type Flavor = Record<`%F${number}%`, string>;
 
-/**
- * @deprecated since 0.8.1
- */
-interface MathProxy extends Math {
-  safeEval: (arg: Parameters<typeof Roll['safeEval']>) => ReturnType<typeof Roll['safeEval']>;
-}
-
 type MessageData<T extends DeepPartial<ConstructorParameters<typeof ChatMessage>[0]>> = {
   user: string;
   type: typeof foundry.CONST.CHAT_MESSAGE_TYPES['ROLL'];

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

@@ -41,14 +41,17 @@ declare abstract class RollTerm {
   /** Optional flavor text which modifies and describes this term. */
   get flavor(): string;
 
+  /** Whether this term is entirely deterministic or contains some randomness. */
+  get isDeterministic(): boolean;
+
   /**
    * Evaluate the roll term, populating the results Array.
    * @param options - (default: `{}`)
    * @returns The evaluated dice term
    */
-  evaluate(options?: Partial<RollTerm.EvaluationOptions & { async: false }>): this;
-  evaluate(options: Partial<RollTerm.EvaluationOptions> & { async: true }): Promise<this>;
-  evaluate(options?: Partial<RollTerm.EvaluationOptions>): this | Promise<this>;
+  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions & { async: false }>): this;
+  evaluate(options: InexactPartial<RollTerm.EvaluationOptions> & { async: true }): Promise<this>;
+  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
 
   protected _evaluate({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): Promise<this>;
 
@@ -107,7 +110,7 @@ declare namespace RollTerm {
     /**
      * Evaluate the roll asynchronously, receiving a Promise as the returned value.
      * This will become the default behavior in version 10.x
-     * @defaultValue `false`
+     * @defaultValue `true`
      */
     async: boolean;
   }

package/src/foundry/foundry.js/rollTerms/diceTerm.d.ts

@@ -65,11 +65,12 @@ declare abstract class DiceTerm extends RollTerm {
   /*  Dice Term Attributes                        */
   /* -------------------------------------------- */
 
-  /**
-   * Return an array of rolled values which are still active within this term
-   */
+  /** Return an array of rolled values which are still active within this term */
   get values(): number[];
 
+  /** @override */
+  get isDeterministic(): boolean;
+
   /* -------------------------------------------- */
 
   /**
@@ -218,13 +219,6 @@ declare abstract class DiceTerm extends RollTerm {
   /*  Factory Methods                             */
   /* -------------------------------------------- */
 
-  /**
-   * @deprecated since 0.8.1
-   */
-  static fromExpression(expression: string, options: DiceTerm.Options): DiceTerm | null;
-
-  /* -------------------------------------------- */
-
   /**
    * Determine whether a string expression matches this type of term
    * @param expression - The expression to parse
@@ -242,18 +236,6 @@ declare abstract class DiceTerm extends RollTerm {
    * @returns The constructed term
    */
   static fromMatch(match: RegExpMatchArray): DiceTerm;
-
-  /* -------------------------------------------- */
-
-  /**
-   * @deprecated since 0.8.1
-   */
-  static fromResults(options: Partial<DiceTerm.TermData>, results: DiceTerm.Result[]): DiceTerm;
-
-  /**
-   * @deprecated since 0.8.1
-   */
-  static getResultLabel(): string;
 }
 
 declare namespace DiceTerm {

package/src/foundry/foundry.js/rollTerms/mathTerm.d.ts

@@ -44,6 +44,9 @@ declare global {
 
     get expression(): string;
 
+    /** @override */
+    get isDeterministic(): boolean;
+
     protected _evaluateSync({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): this;
 
     protected _evaluate({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): Promise<this>;

package/src/foundry/foundry.js/rollTerms/parentheticalTerm.d.ts

@@ -22,6 +22,9 @@ 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;
+
   /**
    * Construct a ParentheticalTerm from an Array of component terms which should be wrapped inside the parentheses.
    * @param terms - The array of terms to use as internal parts of the parenthetical

package/src/foundry/foundry.js/rollTerms/poolTerm.d.ts

@@ -177,11 +177,6 @@ declare global {
     countFailures(modifier: string): ReturnType<Die['countFailures']>;
   }
 
-  /**
-   * @deprecated since 0.8.1
-   */
-  const DicePool: typeof PoolTerm;
-
   namespace PoolTerm {
     /**
      * @remarks This interface is not defined by foundry itself. It only exists
@@ -209,6 +204,9 @@ interface PoolTermConstructorData {
    */
   terms?: string[];
 
+  /** @override */
+  get isDeterministic(): boolean;
+
   /**
    * @defaultValue `[]`
    */

package/src/foundry/foundry.js/rollTerms/stringTerm.d.ts

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

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

@@ -84,7 +84,7 @@ declare namespace SearchFilter {
 
     /**
      * The initial value of the search query.
-     * @defaultValue `''`
+     * @defaultValue `""`
      */
     initial?: SearchFilter['query'];
 

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

@@ -6,7 +6,7 @@ declare class TextEditor {
    * Create a Rich Text Editor. The current implementation uses TinyMCE
    * @param options - Configuration options provided to the Editor init
    * @param content - Initial HTML or text content to populate the editor with
-   *                  (default: `''`)
+   *                  (default: `""`)
    * @returns The editor instance.
    */
   static create(options: TextEditor.Options, content: string): Promise<tinyMCE.Editor>;

package/src/foundry/index.d.ts

@@ -14,6 +14,7 @@ import './foundry.js/chatBubbles';
 import './foundry.js/clientDatabaseBackend';
 import './foundry.js/clientDocuments';
 import './foundry.js/clientDocumentMixin';
+import './foundry.js/clientKeybindings';
 import './foundry.js/clientSettings';
 import './foundry.js/config';
 import './foundry.js/constants';
@@ -24,6 +25,7 @@ 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/globalVariables';
 import './foundry.js/handlebarsHelpers';
@@ -33,6 +35,8 @@ import './foundry.js/keyboardManager';
 import './foundry.js/localization';
 import './foundry.js/mersenneTwister';
 import './foundry.js/mouseInteractionManager';
+import './foundry.js/mouseManager';
+import './foundry.js/newUserExperience';
 import './foundry.js/perceptionManager';
 import './foundry.js/pointSource';
 import './foundry.js/quadtree';

package/src/types/utils.d.ts

@@ -2,10 +2,18 @@
  * Recursively sets keys of an object to optional. Used primarily for update methods
  * @internal
  */
-declare type DeepPartial<T> = {
+type DeepPartial<T> = {
   [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
 
+/**
+ * Make all properties in T optional and explicitly allow `undefined`
+ * @internal
+ */
+type InexactPartial<T> = {
+  [P in keyof T]?: T[P] | undefined;
+};
+
 /**
  * References the constructor of type `T`
  * @internal
@@ -75,7 +83,7 @@ type Expanded<O> = O extends Record<string, unknown>
  * Union type of the types of the values in `T`
  * @internal
  */
-type ValueOf<T> = T extends Array<unknown> ? T[number] : T[keyof T];
+type ValueOf<T> = T extends Array<unknown> | ReadonlyArray<unknown> ? T[number] : T[keyof T];
 
 /**
  * Transforms a string to lowercase and the first character to uppercase.
@@ -96,7 +104,7 @@ type Titlecase<S extends string> = S extends `${infer A} ${infer B}`
  * @typeParam U - The type that will be merged into `T`.
  */
 type Merge<T, U> = T extends object
-  ? U extends Array<any>
+  ? U extends Array<any> | ReadonlyArray<any>
     ? U
     : U extends object
     ? {