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

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

@@ -1,5 +1,4 @@
-import type { AnyObject, ConstructorOf, EmptyObject, InexactPartial } from "../../../types/utils.d.mts";
-
+import type { AnyObject, InexactPartial, FixedInstanceType, IntentionalPartial, EmptyObject, Identity } from "#utils";
 import type { RollParseNode } from "./_types.d.mts";
 import type DiceTerm from "./terms/dice.d.mts";
 import type PoolTerm from "./terms/pool.d.mts";
@@ -29,14 +28,14 @@ import type RollResolver from "../applications/dice/roll-resolver.d.mts";
  * console.log(r.total);    // 22
  * ```
  */
-declare class Roll<D extends AnyObject = AnyObject> {
+declare class Roll<D extends AnyObject = EmptyObject> {
   /**
    * @param formula - The string formula to parse
    * @param data    - The data object against which to parse attributes within the formula
    *                  (default: `{}`)
    * @param options - (default: `{}`)
    */
-  constructor(formula: string, data?: D, options?: Roll["options"]);
+  constructor(formula: string, data?: D, options?: Roll.Options);
 
   /**
    * The original provided data object which substitutes into attributes of the roll formula
@@ -46,7 +45,7 @@ declare class Roll<D extends AnyObject = AnyObject> {
   /**
    * Options which modify or describe the Roll
    */
-  options: InexactPartial<Roll.Options>;
+  options: Roll.Options;
 
   /**
    * The identified terms of the Roll
@@ -107,8 +106,6 @@ declare class Roll<D extends AnyObject = AnyObject> {
    */
   static RESOLVERS: Map<Roll, RollResolver>; // TODO: Fix this
 
-  /* -------------------------------------------- */
-
   /**
    * Prepare the data structure used for the Roll.
    * This is factored out to allow for custom Roll classes to do special data preparation using provided input.
@@ -168,8 +165,6 @@ declare class Roll<D extends AnyObject = AnyObject> {
    */
   clone(): this;
 
-  /* -------------------------------------------- */
-
   /**
    * Execute the Roll, replacing dice and evaluating the total result
    * @param options - Options which inform how the Roll is evaluated
@@ -190,9 +185,7 @@ declare class Roll<D extends AnyObject = AnyObject> {
     allowStrings,
     allowInteractive,
     ...options
-  }?: InexactPartial<Roll.Options>): Promise<Roll.Evaluated<this>>;
-
-  /* -------------------------------------------- */
+  }?: Roll.Options): Promise<Roll.Evaluated<this>>;
 
   /**
    * Execute the Roll synchronously, replacing dice and evaluating the total result.
@@ -201,7 +194,7 @@ declare class Roll<D extends AnyObject = AnyObject> {
    *
    * @returns The evaluated Roll instance.
    */
-  evaluateSync({ minimize, maximize, allowStrings, strict }?: InexactPartial<Roll.Options>): Roll.Evaluated<this>;
+  evaluateSync({ minimize, maximize, allowStrings, strict }?: Roll.Options): Roll.Evaluated<this>;
 
   /**
    * Evaluate the roll asynchronously.
@@ -209,9 +202,7 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * @param options - Options which inform how evaluation is performed
    * @internal
    */
-  protected _evaluate(options?: InexactPartial<Roll.Options>): Promise<Roll.Evaluated<this>>;
-
-  /* -------------------------------------------- */
+  protected _evaluate(options?: Roll.Options): Promise<Roll.Evaluated<this>>;
 
   /**
    * Evaluate an AST asynchronously.
@@ -219,21 +210,14 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * @param options - Options which inform how evaluation is performed
    *                  (default: `{}`)
    */
-  protected _evaluateASTAsync(
-    node: RollParseNode | RollTerm,
-    options?: InexactPartial<Roll.Options>,
-  ): Promise<string | number>;
-
-  /* -------------------------------------------- */
+  protected _evaluateASTAsync(node: RollParseNode | RollTerm, options?: Roll.Options): Promise<string | number>;
 
   /**
    * Evaluate the roll synchronously.
    * @param options - Options which inform how evaluation is performed
    *                  (default: `{}`)
    */
-  protected _evaluateSync(options?: InexactPartial<Roll.Options>): Roll.Evaluated<this>;
-
-  /* -------------------------------------------- */
+  protected _evaluateSync(options?: Roll.Options): Roll.Evaluated<this>;
 
   /**
    * Evaluate an AST synchronously.
@@ -241,9 +225,7 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * @param options - Options which inform how evaluation is performed
    *                  (default: `{}`)
    */
-  protected _evaluateASTSync(node: RollParseNode | RollTerm, options?: InexactPartial<Roll.Options>): string | number;
-
-  /* -------------------------------------------- */
+  protected _evaluateASTSync(node: RollParseNode | RollTerm, options?: Roll.Options): string | number;
 
   /**
    * Safely evaluate the final total result for the Roll using its component terms.
@@ -251,26 +233,20 @@ declare class Roll<D extends AnyObject = AnyObject> {
    */
   protected _evaluateTotal(): number;
 
-  /* -------------------------------------------- */
-
   /**
    * Alias for evaluate.
-   * @see Roll#evaluate
-   * @param options - Options passed to Roll#evaluate.
+   * @see {@link Roll.evaluate | `Roll#evaluate`}
+   * @param options - Options passed to {@link Roll.evaluate | `Roll#evaluate`}.
    */
-  roll(options?: InexactPartial<Roll.Options>): Promise<Roll.Evaluated<this>>;
-
-  /* -------------------------------------------- */
+  roll(options?: Roll.Options): Promise<Roll.Evaluated<this>>;
 
   /**
    * Create a new Roll object using the original provided formula and data.
    * Each roll is immutable, so this method returns a new Roll instance using the same data.
-   * @param options - Evaluation options passed to Roll#evaluate
+   * @param options - Evaluation options passed to {@link Roll.evaluate | `Roll#evaluate`}
    * @returns A new Roll object, rolled using the same formula and data
    */
-  reroll(options?: InexactPartial<Roll.Options>): Promise<Roll.Evaluated<this>>;
-
-  /* -------------------------------------------- */
+  reroll(options?: Roll.Options): Promise<Roll.Evaluated<this>>;
 
   /**
    * Recompile the formula string that represents this Roll instance from its component terms.
@@ -278,16 +254,12 @@ declare class Roll<D extends AnyObject = AnyObject> {
    */
   resetFormula(): string;
 
-  /* -------------------------------------------- */
-
   /**
    * Propagate flavor text across all terms that do not have any.
    * @param flavor -The flavor text.
    */
   propagateFlavor(flavor: string): void;
 
-  /* -------------------------------------------- */
-
   /** @override */
   toString(): string;
 
@@ -303,10 +275,10 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * @param options - Additional options which modify or describe this Roll
    * @returns The constructed Roll instance
    */
-  static create<D extends AnyObject = AnyObject>(
+  static create<D extends AnyObject = EmptyObject>(
     formula: string,
     data?: D,
-    options?: InexactPartial<Roll.Options>,
+    options?: Roll.Options,
   ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<D>;
 
   /**
@@ -371,8 +343,6 @@ declare class Roll<D extends AnyObject = AnyObject> {
    */
   static parse(formula: string, data: Record<string, unknown>): RollTerm[];
 
-  /* -------------------------------------------- */
-
   /**
    * Instantiate the nodes in an AST sub-tree into RollTerm instances.
    * @param ast - The root of the AST sub-tree.
@@ -422,19 +392,11 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * @param term         - A remaining un-classified string
    * @param options      - Options which customize classification
    *                       (default: `{}`)
-   * @param intermediate - Allow intermediate terms
-   *                       (default: `true`)
-   * @param prior        - The prior classified term
-   * @param next         - The next term to classify
    * @returns A classified RollTerm instance
    */
-  protected static _classifyStringTerm(
+  static _classifyStringTerm(
     term: string,
-    {
-      intermediate,
-      prior,
-      next,
-    }?: InexactPartial<{ intermediate: boolean; prior: RollTerm | string; next: RollTerm | string }>,
+    options?: Roll.ClassifyStringTermOptions, // not: null (destructured)
   ): RollTerm;
 
   /* -------------------------------------------- */
@@ -490,24 +452,14 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * @returns A promise which resolves to the created ChatMessage entity, if create is true
    *          or the Object of prepared chatData otherwise.
    */
-  toMessage<T extends foundry.documents.BaseChatMessage.ConstructorData = EmptyObject, Create extends boolean = true>(
-    messageData?: T,
-    options?: InexactPartial<{
-      /**
-       * The template roll mode to use for the message from CONFIG.Dice.rollModes
-       * @remarks "roll" equivalent to explicit undefined
-       */
-      rollMode: keyof CONFIG.Dice.RollModes | "roll";
-      /**
-       * Whether to automatically create the chat message, or only return the prepared chatData object.
-       * @defaultValue `true`
-       */
-      create: Create;
-    }>,
-  ): Promise<
-    | (true extends Create ? ChatMessage.ConfiguredInstance | undefined : never)
-    | (false extends Create ? Roll.MessageData<T> : never)
-  >;
+  // options: not null (destructured)
+  toMessage<
+    const Create extends boolean | null | undefined,
+    ConcreteMessageData extends Roll.MessageData | null | undefined = undefined,
+  >(
+    messageData?: ConcreteMessageData,
+    options?: Roll.ToMessageOptions<Create>,
+  ): Promise<Roll.ToMessageReturn<Create, ConcreteMessageData>>;
 
   /* -------------------------------------------- */
   /*  Interface Helpers                           */
@@ -551,14 +503,14 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * @param data - Unpacked data representing the Roll
    * @returns A reconstructed Roll instance
    */
-  static fromData<T extends Roll<any>>(this: ConstructorOf<T>, data: Roll.Data): T;
+  static fromData<T extends Roll.AnyConstructor>(this: T, data: Roll.Data): FixedInstanceType<T>;
 
   /**
    * Recreate a Roll instance using a provided JSON string
    * @param json - Serialized JSON data representing the Roll
    * @returns A reconstructed Roll instance
    */
-  static fromJSON(json: string): Roll;
+  static fromJSON<T extends Roll.AnyConstructor>(this: T, json: string): FixedInstanceType<T>;
 
   /**
    * Manually construct a Roll object by providing an explicit set of input terms
@@ -575,15 +527,22 @@ declare class Roll<D extends AnyObject = AnyObject> {
    * roll.formula; // 4d8 + 8
    * ```
    */
-  static fromTerms<T extends Roll<any>>(
-    this: ConstructorOf<T>,
+  static fromTerms<T extends Roll.AnyConstructor>(
+    this: T,
     terms: RollTerm[],
-    options?: InexactPartial<Roll.Options>,
-  ): T;
+    options?: Roll.Options,
+  ): FixedInstanceType<T>;
 }
 
 declare namespace Roll {
-  interface Options extends RollTerm.EvaluationOptions {
+  interface Any extends AnyRoll {}
+  interface AnyConstructor extends Identity<typeof AnyRoll> {}
+
+  // TODO: Make this actually configurable
+  interface ConfiguredClass extends Identity<CONFIG["Dice"]["rolls"][0]> {}
+  interface ConfiguredInstance extends FixedInstanceType<ConfiguredClass> {}
+
+  interface _Options extends RollTerm.EvaluationOptions {
     /**
      * If false, force the use of non-interactive rolls and do not prompt the user to make manual rolls.
      * @defaultValue `true`
@@ -596,6 +555,8 @@ declare namespace Roll {
     strict?: boolean | undefined;
   }
 
+  interface Options extends InexactPartial<_Options> {}
+
   interface SplitGroupOptions {
     openRegexp: RegExp | string;
     closeRegexp: RegExp | string;
@@ -632,14 +593,76 @@ declare namespace Roll {
     total: number | null;
   }
 
-  type MessageData<T extends foundry.documents.BaseChatMessage.ConstructorData> = T & {
-    user: string;
-    rolls: Roll[];
-    content: number;
-    sound: typeof CONFIG.sounds.dice;
-  };
+  type _ClassifyStringTermOptions = InexactPartial<{
+    /**
+     * Allow intermediate terms
+     * @defaultValue `true`
+     */
+    intermediate: boolean | null;
+
+    /** The prior classified term */
+    prior: RollTerm | string | null;
+
+    /** The next term to classify */
+    next: RollTerm | string | null;
+  }>;
+
+  interface ClassifyStringTermOptions extends _ClassifyStringTermOptions {}
+
+  // TODO(LukeAbby): When shims are added then `"user"` should also be added here #3065. Specifically `user` should be added as partial.
+  //
+  // This is `IntentionalPartial` because Foundry merges in defaults with `mergeObject`.
+  interface _MessageData extends IntentionalPartial<ChatMessage.CreateData, "content" | "sound" | "rolls"> {
+    /**
+     * The HTML content of this chat message
+     * @defaultValue `String(this.total)`
+     */
+    content?: ChatMessage.CreateData["content"];
+
+    /**
+     * The URL of an audio file which plays when this message is received
+     * @defaultValue `CONFIG.sounds.dice`
+     */
+    sound?: ChatMessage.CreateData["sound"];
+
+    /**
+     * The URL of an audio file which plays when this message is received
+     *
+     * @deprecated In `Roll.MessageData`, Foundry always overrides `rolls` to `[this]`.
+     * This makes it useless to set. Do not use.
+     */
+    rolls?: ChatMessage.CreateData["rolls"];
+  }
+
+  interface MessageData extends InexactPartial<_MessageData> {}
+
+  type Evaluated<T extends Roll<any>> = T & { _evaluated: true; _total: number; get total(): number };
+
+  interface ToMessageOptions<Create extends boolean | null | undefined> {
+    /**
+     * The template roll mode to use for the message from CONFIG.Dice.rollModes
+     * @remarks "roll" equivalent to explicit undefined
+     */
+    rollMode?: keyof CONFIG.Dice.RollModes | "roll" | null | undefined;
+
+    /**
+     * Whether to automatically create the chat message, or only return the prepared chatData object.
+     * @defaultValue `true`
+     */
+    create?: Create;
+  }
+
+  type ToMessageReturn<
+    Create extends boolean | null | undefined,
+    ConcreteMessageData extends Roll.MessageData | null | undefined = undefined,
+  > =
+    | (ConcreteMessageData extends undefined ? ChatMessage.Implementation | undefined : never)
+    | (Create extends true | undefined ? ChatMessage.Implementation | undefined : never)
+    | (Create extends false | null ? ChatMessage.CreateData : never);
+}
 
-  type Evaluated<T extends Roll> = T & { _evaluated: true; _total: number; get total(): number };
+declare abstract class AnyRoll extends Roll<any> {
+  constructor(...args: never);
 }
 
 export default Roll;

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

@@ -1,8 +1,7 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
-/* eslint-disable import/no-unresolved */ // TODO: Remove when the files are instantiated
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export { default as Coin } from "./coin.mjs";
 export { default as DiceTerm } from "./dice.mjs";

package/src/foundry/client-esm/dice/terms/coin.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";
 
 /**
@@ -24,8 +24,6 @@ declare class Coin extends DiceTerm {
    */
   static MODIFIERS: Coin.Modifiers;
 
-  /* -------------------------------------------- */
-
   override roll({
     minimize,
     maximize,
@@ -36,8 +34,6 @@ declare class Coin extends DiceTerm {
 
   override getResultCSS(result: DiceTerm.Result): (string | null)[];
 
-  /* -------------------------------------------- */
-
   override mapRandomFace(randomUniform: number): number;
 
   /* -------------------------------------------- */
@@ -56,6 +52,9 @@ declare class Coin extends DiceTerm {
 }
 
 declare namespace Coin {
+  interface Any extends AnyCoin {}
+  interface AnyConstructor extends Identity<typeof AnyCoin> {}
+
   interface TermData extends DiceTerm.TermData {
     modifiers: Array<keyof Modifiers>;
   }
@@ -65,4 +64,8 @@ declare namespace Coin {
   }
 }
 
+declare abstract class AnyCoin extends Coin {
+  constructor(...args: never);
+}
+
 export default Coin;