@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.5

package/src/foundry/client-esm/dice/terms/dice.d.mts

@@ -1,4 +1,4 @@
-import type { ConstructorOf, InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial, FixedInstanceType, Identity } from "#utils";
 import type { DiceRollParseNode } from "../_types.d.mts";
 
 import type RollTerm from "./term.d.mts";
@@ -24,23 +24,19 @@ declare abstract class DiceTerm extends RollTerm {
    */
   constructor(termData?: InexactPartial<DiceTerm.TermData>);
 
-  get method(): string; // TODO: Convert to CONFIG.Dice.fulfillment.methods
+  get method(): keyof typeof CONFIG.Dice.fulfillment.methods | null | undefined;
 
-  set method(method: string); // TODO: Convert to CONFIG.Dice.fulfillment.methods
-
-  #method: string; // TODO: Convert to CONFIG.Dice.fulfillment.methods
+  set method(method: keyof typeof CONFIG.Dice.fulfillment.methods);
 
   /**  An Array of dice term modifiers which are applied. */
-  modifiers: DiceTerm.TermData["modifiers"];
+  modifiers: string[];
 
   /** The array of dice term results which have been rolled. */
   results: DiceTerm.Result[];
 
-  /* -------------------------------------------- */
-
   /**
    * Define the denomination string used to register this DiceTerm type in CONFIG.Dice.terms
-   * @defaultValue ""
+   * @defaultValue `""`
    */
   static DENOMINATION: string;
 
@@ -73,27 +69,26 @@ declare abstract class DiceTerm extends RollTerm {
   /** The number of dice of this term to roll. Returns undefined if the number is a
    * complex term that has not yet been evaluated.
    */
-  get number(): DiceTerm.TermData["number"] | undefined;
+  get number(): number | undefined;
   /** The number of dice of this term to roll. */
-  set number(value: DiceTerm.TermData["number"]);
+  set number(value: number);
 
   /**
    * The number of dice of this term to roll, before modifiers are applied, or a Roll instance that will be evaluated to
    * a number.
    */
-  _number: DiceTerm.TermData["number"] | Roll;
+  _number: number | Roll;
 
   /**
    * The number of faces on the die. Returns undefined if the faces are represented as a complex term that has not yet
    * been evaluated.
    */
-  get faces(): DiceTerm.TermData["faces"] | undefined;
-  set faces(value: DiceTerm.TermData["faces"]);
+  get faces(): number | undefined;
+  set faces(value: number);
 
   /** The number of faces on the die, or a Roll instance that will be evaluated to a number. */
-  _faces: DiceTerm.TermData["faces"] | Roll;
+  _faces: number | Roll;
 
-  /* -------------------------------------------- */
   /**  The denomination of this DiceTerm instance. */
   get denomination(): string;
 
@@ -119,27 +114,20 @@ declare abstract class DiceTerm extends RollTerm {
    */
   alter(multiply: number, add: number): this;
 
-  /* -------------------------------------------- */
-
   protected _evaluate(options?: InexactPartial<DiceTerm.EvaluationOptions>): this | Promise<this>;
 
-  /* -------------------------------------------- */
-
   /**
    * Evaluate this dice term asynchronously.
    * @param options - Options forwarded to inner Roll evaluation. (Default: `{}`)
    */
   _evaluateAsync(options?: InexactPartial<DiceTerm.EvaluationOptions>): Promise<this>;
 
-  /* -------------------------------------------- */
   /**
    * Evaluate deterministic values of this term synchronously.
    * @param options - Options forwarded to inner Roll evaluation. (Default: `{}`)
    */
   _evaluateSync(options?: InexactPartial<DiceTerm.EvaluationOptions>): this;
 
-  /* -------------------------------------------- */
-
   /**
    * Roll the DiceTerm by mapping a random uniform draw against the faces of the dice term.
    * @param minimize - Minimize the result, obtaining the smallest possible value.
@@ -148,8 +136,6 @@ declare abstract class DiceTerm extends RollTerm {
    */
   roll({ minimize, maximize, ...options }?: InexactPartial<DiceTerm.EvaluationOptions>): Promise<DiceTerm.Result>;
 
-  /* -------------------------------------------- */
-
   /**
    * Generate a roll result value for this DiceTerm based on its fulfillment method.
    * @param  options - Options forwarded to the fulfillment method handler.
@@ -158,8 +144,6 @@ declare abstract class DiceTerm extends RollTerm {
    */
   protected _roll(options?: InexactPartial<DiceTerm.EvaluationOptions>): Promise<number | undefined>;
 
-  /* -------------------------------------------- */
-
   /**
    * Invoke the configured fulfillment handler for this term to produce a result value.
    * @param options -Options forwarded to the fulfillment method handler.
@@ -168,8 +152,6 @@ declare abstract class DiceTerm extends RollTerm {
    */
   #invokeFulfillmentHandler(options?: InexactPartial<DiceTerm.EvaluationOptions>): Promise<number | undefined>;
 
-  /* -------------------------------------------- */
-
   /**
    * Maps a randomly-generated value in the interval [0, 1) to a face value on the die.
    * @param randomUniform - A value to map. Must be in the interval [0, 1).
@@ -177,8 +159,6 @@ declare abstract class DiceTerm extends RollTerm {
    */
   mapRandomFace(randomUniform: number): number;
 
-  /* -------------------------------------------- */
-
   /** Generate a random face value for this die using the configured PRNG. */
   randomFace(): number;
 
@@ -189,8 +169,6 @@ declare abstract class DiceTerm extends RollTerm {
    */
   getResultLabel(result: DiceTerm.Result): string;
 
-  /* -------------------------------------------- */
-
   /**
    * Get the CSS classes that should be used to display each rolled result
    * @param result - The rolled result
@@ -198,8 +176,6 @@ declare abstract class DiceTerm extends RollTerm {
    */
   getResultCSS(result: DiceTerm.Result): (string | null)[];
 
-  /* -------------------------------------------- */
-
   /**
    * Render the tooltip HTML for a Roll instance
    * @returns The data object used to render the default tooltip template for this DiceTerm
@@ -216,15 +192,12 @@ declare abstract class DiceTerm extends RollTerm {
    */
   protected _evaluateModifiers(): void;
 
-  /* -------------------------------------------- */
-
   /**
    * Evaluate a single modifier command, recording it in the array of evaluated modifiers
    * @param command - The parsed modifier command
    * @param modifier -  The full modifier request
    */
   protected _evaluateModifier(command: string, modifier: string): void;
-  /* -------------------------------------------- */
 
   /**
    * A helper comparison function.
@@ -236,50 +209,36 @@ declare abstract class DiceTerm extends RollTerm {
    */
   static compareResult(result: number, comparison: string, target: number): boolean;
 
-  /* -------------------------------------------- */
-
   /**
    * A helper method to modify the results array of a dice term by flagging certain results are kept or dropped.
    * @param results - The results array
    * @param number  - The number to keep or drop
-   * @param keep    - Keep results?
-   *                  (default: `true`)
-   * @param highest - Keep the highest?
-   *                  (default: `true`)
    * @returns The modified results array
    */
   protected static _keepOrDrop(
     results: DiceTerm.Result[],
     number: number,
-    { keep, highest }?: InexactPartial<{ keep: boolean; highest: boolean }>,
+    options?: DiceTerm.KeepOrDropOptions,
   ): DiceTerm.Result;
 
-  /* -------------------------------------------- */
-
   /**
    * A reusable helper function to handle the identification and deduction of failures
-   * @param flagFailure - (default: `false`)
-   * @param flagSuccess - (default: `false`)
    */
   protected static _applyCount(
     results: DiceTerm.Result[],
     comparison: string,
     target: number,
-    { flagSuccess, flagFailure }?: InexactPartial<{ flagSuccess: boolean; flagFailure: boolean }>,
+    options?: DiceTerm.ApplyCountOptions, // not: null (destructured)
   ): void;
 
-  /* -------------------------------------------- */
-
   /**
    * A reusable helper function to handle the identification and deduction of failures
-   * @param deductFailure - (default: `false`)
-   * @param invertFailure - (default: `false`)
    */
   protected static _applyDeduct(
     results: DiceTerm.Result[],
     comparison: string,
     target: number,
-    { deductFailure, invertFailure }?: InexactPartial<{ deductFailure: boolean; invertFailure: boolean }>,
+    options?: DiceTerm.ApplyDeductOptions, // not: null (destructured)
   ): void;
 
   /* -------------------------------------------- */
@@ -290,16 +249,12 @@ declare abstract class DiceTerm extends RollTerm {
    * Determine whether a string expression matches this type of term
    * @param expression - The expression to parse
    * @param options - Additional options which customize the match
-   * @param imputeNumber - Allow the number of dice to be optional, i.e. "d6"
-   *                       (default: `true`)
    */
   static matchTerm(
     expression: string,
-    { imputeNumber }?: InexactPartial<{ imputeNumber: boolean }>,
+    options?: DiceTerm.MatchTermOptions, // not: null (destructured)
   ): RegExpMatchArray | null;
 
-  /* -------------------------------------------- */
-
   /**
    * Construct a term of this type given a matched regular expression array.
    * @param match - The matched regular expression array
@@ -307,7 +262,6 @@ declare abstract class DiceTerm extends RollTerm {
    */
   static fromMatch(match: RegExpMatchArray): DiceTerm;
 
-  /* -------------------------------------------- */
   /** Construct a DiceTerm from parser information. */
   static override fromParseNode(node: DiceRollParseNode): DiceTerm;
 
@@ -315,23 +269,53 @@ declare abstract class DiceTerm extends RollTerm {
   /*  Serialization & Loading                     */
   /* -------------------------------------------- */
 
-  protected static _fromData<T extends RollTerm>(this: ConstructorOf<T>, data: Record<string, unknown>): T;
+  protected static _fromData<T extends RollTerm.AnyConstructor>(
+    this: T,
+    data: Record<string, unknown>,
+  ): FixedInstanceType<T>;
 
   override toJSON(): Record<string, unknown>;
 }
 
 declare namespace DiceTerm {
+  interface Any extends AnyDiceTerm {}
+  interface AnyConstructor extends Identity<typeof AnyDiceTerm> {}
+
   interface Data extends InexactPartial<TermData> {
     class?: string | undefined;
     results: DiceTerm.Result[];
   }
 
   interface TermData {
+    /**
+     * @defaultValue `1`
+     */
     number: number;
+
+    /**
+     * @defaultValue `6`
+     */
     faces: number;
+
+    /**
+     * @defaultValue `undefined`
+     */
+    method: keyof typeof CONFIG.Dice.fulfillment.methods | null | undefined;
+
+    /**
+     * @defaultValue `[]`
+     */
     modifiers: string[];
+
+    /**
+     * @defaultValue `[]`
+     */
     results: Result[];
-    options: DiceTerm.Options;
+
+    /**
+     * @defaultValue `{}`
+     */
+    options: InexactPartial<DiceTerm.Options>;
   }
 
   interface Options extends RollTerm.Options {}
@@ -365,6 +349,48 @@ declare namespace DiceTerm {
     rolls: { result: string; classes: string }[];
   }
 
+  type _KeepOrDropOptions = InexactPartial<{
+    /** Keep results?
+     * @defaultValue true
+     */
+    keep?: boolean | undefined; // not: null (function checks keep===highest)
+    /** Keep the highest?
+     * @defaultValue true
+     */
+    highest?: boolean | undefined; // not: null (function checks keep===highest)
+  }>;
+
+  interface KeepOrDropOptions extends _KeepOrDropOptions {}
+
+  type _ApplyCountOptions = InexactPartial<{
+    /** @defaultValue false */
+    flagSuccess: boolean | null;
+
+    /** @defaultValue false */
+    flagFailure: boolean | null;
+  }>;
+
+  interface ApplyCountOptions extends _ApplyCountOptions {}
+
+  type _ApplyDeductOptions = InexactPartial<{
+    /** @defaultValue false */
+    deductFailure: boolean | null;
+
+    /** @defaultValue false */
+    invertFailure: boolean | null;
+  }>;
+
+  interface ApplyDeductOptions extends _ApplyDeductOptions {}
+
+  type _MatchTermOptions = InexactPartial<{
+    /** Allow the number of dice to be optional, i.e. "d6"
+     * @defaultValue true
+     */
+    imputeNumber: boolean | null;
+  }>;
+
+  interface MatchTermOptions extends _MatchTermOptions {}
+
   interface EvaluationOptions extends RollTerm.EvaluationOptions {
     /**
      * Throw an error if attempting to evaluate a die term in a way that cannot be done
@@ -378,4 +404,8 @@ declare namespace DiceTerm {
   interface Modifiers {}
 }
 
+declare abstract class AnyDiceTerm extends DiceTerm {
+  constructor(...args: never);
+}
+
 export default DiceTerm;

package/src/foundry/client-esm/dice/terms/die.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { Identity, InexactPartial } from "#utils";
 
 import type DiceTerm from "./dice.d.mts";
 
@@ -70,7 +70,7 @@ declare class Die extends DiceTerm {
   reroll(modifier: string, { recursive }?: InexactPartial<{ recursive: boolean }>): Promise<boolean | void>;
 
   /**
-   * @see {@link Die#reroll}
+   * @see {@link Die.reroll | `Die#reroll`}
    */
   rerollRecursive(modifier: string): Promise<boolean | void>;
 
@@ -86,7 +86,7 @@ declare class Die extends DiceTerm {
   explode(modifier: string, { recursive }?: InexactPartial<{ recursive: boolean }>): Promise<boolean | void>;
 
   /**
-   * @see {@link Die#explode}
+   * @see {@link Die.explode | `Die#explode`}
    */
   explodeOnce(modifier: string): Promise<boolean | void>;
 
@@ -211,8 +211,11 @@ declare class Die extends DiceTerm {
 }
 
 declare namespace Die {
+  interface Any extends AnyDie {}
+  interface AnyConstructor extends Identity<typeof AnyDie> {}
+
   interface TermData extends DiceTerm.TermData {
-    modifiers: Array<keyof (typeof Die)["MODIFIERS"]>;
+    modifiers: Array<keyof Modifiers>;
   }
 
   interface Modifiers {
@@ -238,4 +241,8 @@ declare namespace Die {
   }
 }
 
+declare abstract class AnyDie extends Die {
+  constructor(...args: never);
+}
+
 export default Die;

package/src/foundry/client-esm/dice/terms/fate.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { Identity, InexactPartial } from "#utils";
 
 import type DiceTerm from "./dice.d.mts";
 import type Die from "./die.d.mts";
@@ -31,8 +31,11 @@ declare class FateDie extends DiceTerm {
 }
 
 declare namespace FateDie {
+  interface Any extends AnyFateDie {}
+  interface AnyConstructor extends Identity<typeof AnyFateDie> {}
+
   interface TermData extends DiceTerm.TermData {
-    modifiers: Array<keyof (typeof FateDie)["MODIFIERS"]>;
+    modifiers: Array<keyof Modifiers>;
   }
 
   interface Modifiers {
@@ -47,4 +50,8 @@ declare namespace FateDie {
   }
 }
 
+declare abstract class AnyFateDie extends FateDie {
+  constructor(...args: never);
+}
+
 export default FateDie;

package/src/foundry/client-esm/dice/terms/function.d.mts

@@ -1,4 +1,4 @@
-import type { ConstructorOf, InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial, FixedInstanceType } from "#utils";
 import type { FunctionRollParseNode } from "../_types.d.mts";
 
 import type RollTerm from "./term.d.mts";
@@ -8,19 +8,19 @@ import type DiceTerm from "./dice.d.mts";
  * A type of RollTerm used to apply a function.
  */
 declare class FunctionTerm extends RollTerm {
-  constructor(termData?: InexactPartial<FunctionTerm.TermData>);
+  constructor(termData: FunctionTerm.TermData);
 
-  /* The name of the configured function, or one in the Math environment, which should be applied to the term. */
+  /** The name of the configured function, or one in the Math environment, which should be applied to the term. **/
   fn: string;
 
   /** An array of string argument terms for the function. */
   terms: string[];
 
-  /* The cached Roll instances for each function argument. */
+  /** The cached Roll instances for each function argument. **/
   rolls: Roll[];
 
-  /* The cached result of evaluating the method arguments. */
-  result: string | number;
+  /** The cached result of evaluating the method arguments. **/
+  result: string | number | undefined; // note: it will be undefined if the function has not yet been evaluated
 
   /** Is this term intermediate, and should be evaluated first as part of the simplification process? */
   override isIntermediate: true;
@@ -59,8 +59,6 @@ declare class FunctionTerm extends RollTerm {
    */
   protected _evaluateSync(options?: InexactPartial<DiceTerm.EvaluationOptions>): this;
 
-  /* -------------------------------------------- */
-
   /**
    * Parse a function argument from its evaluated Roll instance.
    * @param roll - The evaluated Roll instance that wraps the argument.
@@ -70,30 +68,32 @@ declare class FunctionTerm extends RollTerm {
   /* -------------------------------------------- */
   /*  Saving and Loading                          */
   /* -------------------------------------------- */
-  protected static override _fromData<T extends RollTerm>(this: ConstructorOf<T>, data: Record<string, unknown>): T;
+  protected static override _fromData<T extends RollTerm.AnyConstructor>(
+    this: T,
+    data: Record<string, unknown>,
+  ): FixedInstanceType<T>;
 
-  /* -------------------------------------------- */
   override toJSON(): Record<string, unknown>;
 
-  /* -------------------------------------------- */
   static override fromParseNode(node: FunctionRollParseNode): RollTerm;
 }
 
 declare namespace FunctionTerm {
-  interface Data extends InexactPartial<TermData> {
+  interface Data extends TermData {
+    fn: string;
     class: string | undefined;
     evaluated: boolean;
   }
 
   interface TermData {
-    /* The name of the configured function, or one in the Math environment, which should be applied to the term. */
+    /** The name of the configured function, or one in the Math environment, which should be applied to the term. */
     fn: string;
     /** An array of string argument terms for the function. */
-    terms: string[];
-    /* The cached Roll instances for each function argument. */
-    rolls: Roll[];
-    /* The cached result of evaluating the method arguments. */
-    result: string | number;
+    terms?: string[] | undefined;
+    /** The cached Roll instances for each function argument. */
+    rolls?: Roll[] | undefined;
+    /** The cached result of evaluating the method arguments. */
+    result?: string | number | undefined;
     options?: InexactPartial<FunctionTerm.Options>;
   }
 

package/src/foundry/client-esm/dice/terms/numeric.d.mts

@@ -1,11 +1,11 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial } from "#utils";
 import type RollTerm from "./term.d.mts";
 
 /**
  * A type of RollTerm used to represent static numbers.
  */
 declare class NumericTerm extends RollTerm {
-  constructor({ number, options }: NumericTerm.TermData);
+  constructor(termData: NumericTerm.TermData);
 
   number: NumericTerm.TermData["number"];
 
@@ -32,8 +32,6 @@ declare class NumericTerm extends RollTerm {
    */
   static matchTerm(expression: string): RegExpMatchArray | null;
 
-  /* -------------------------------------------- */
-
   /**
    * Construct a term of this type given a matched regular expression array.
    * @param match -  The matched regular expression array
@@ -47,7 +45,7 @@ declare namespace NumericTerm {
     number: number;
 
     /**
-     * @defaultValue `{}`
+     * @defaultValue `undefined`
      */
     options?: InexactPartial<RollTerm.Options>;
   }

package/src/foundry/client-esm/dice/terms/operator.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial } from "#utils";
 
 import type RollTerm from "./term.d.mts";
 
@@ -6,7 +6,7 @@ import type RollTerm from "./term.d.mts";
  * A type of RollTerm used to denote and perform an arithmetic operation.
  */
 declare class OperatorTerm extends RollTerm {
-  constructor({ operator, options }?: InexactPartial<OperatorTerm.TermData>);
+  constructor(termData: OperatorTerm.TermData);
 
   /** The term's operator value. */
   operator: OperatorTerm.TermData["operator"];

package/src/foundry/client-esm/dice/terms/parenthetical.d.mts

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type { InexactPartial } from "#utils";
 import type { ParentheticalRollParseNode } from "../_types.d.mts";
 
 import type RollTerm from "./term.d.mts";
@@ -8,13 +8,13 @@ import type DiceTerm from "./dice.d.mts";
  * A type of RollTerm used to enclose a parenthetical expression to be recursively evaluated.
  */
 declare class ParentheticalTerm extends RollTerm {
-  constructor({ term, roll, options }: ParentheticalTerm.TermData);
+  constructor({ term, roll, options }?: ParentheticalTerm.TermData);
 
   /** The original provided string term used to construct the parenthetical */
-  term: ParentheticalTerm.TermData["term"];
+  term: string | undefined; // only one of term or roll is expected
 
   /** Alternatively, an already-evaluated Roll instance may be passed directly */
-  roll: ParentheticalTerm.TermData["roll"];
+  roll: Roll | undefined; // only one of term or roll is expected
 
   /**
    * Is this term intermediate, and should be evaluated first as part of the simplification process?
@@ -54,7 +54,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 total(): string | number | null | undefined;
+  override get total(): number | undefined;
 
   override get expression(): string;
 
@@ -69,8 +69,6 @@ declare class ParentheticalTerm extends RollTerm {
 
   protected _evaluateSync(roll: Roll, options?: InexactPartial<RollTerm.EvaluationOptions>): this;
 
-  /* -------------------------------------------- */
-
   /**
    * 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
@@ -88,18 +86,19 @@ declare class ParentheticalTerm extends RollTerm {
    */
   static fromTerms(terms: RollTerm[], options?: InexactPartial<RollTerm.Options>): ParentheticalTerm;
 
-  /* -------------------------------------------- */
-
   /** Construct a Parenthetical from parser information. */
   static override fromParseNode(node: ParentheticalRollParseNode): ParentheticalTerm;
 }
 
 declare namespace ParentheticalTerm {
-  interface TermData {
+  /** @internal */
+  interface _TermData {
     term: string;
     roll: Roll;
     options?: InexactPartial<RollTerm.Options>;
   }
+
+  interface TermData extends InexactPartial<ParentheticalTerm._TermData> {}
 }
 
 export default ParentheticalTerm;