@league-of-foundry-developers/foundry-vtt-types 9.280.0 → 12.331.1-beta

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

@@ -0,0 +1,160 @@
+import type { ConstructorOf, InexactPartial } from "../../../../types/utils.mts";
+import type { RollParseNode } from "../_types.mts";
+
+import type RollResolver from "../../applications/dice/roll-resolver.d.mts";
+
+declare abstract class RollTerm {
+  constructor({ options }?: InexactPartial<{ options: RollTerm.Options }>);
+
+  /** An object of additional options which describes and modifies the term. */
+  options: RollTerm.Options;
+
+  /** An internal flag for whether the term has been evaluated. */
+  protected _evaluated: boolean;
+
+  /** A reference to the Roll at the root of the evaluation tree. */
+  protected _root: Roll;
+
+  /**
+   * Is this term intermediate, and should be evaluated first as part of the simplification process?
+   * @defaultValue `false`
+   */
+  isIntermediate: boolean;
+
+  /**
+   * A regular expression pattern which identifies optional term-level flavor text
+   * @defaultValue `(?:\\[([^\\]]+)\\])`
+   */
+  static FLAVOR_REGEXP_STRING: string;
+
+  /**
+   * A regular expression which identifies term-level flavor text
+   * @defaultValue `new RegExp(RollTerm.FLAVOR_REGEXP_STRING, "G")`
+   */
+  static FLAVOR_REGEXP: RegExp;
+
+  /**
+   * A regular expression used to match a term of this type
+   * @defaultValue `undefined`
+   */
+  static REGEXP: RegExp;
+
+  /* -------------------------------------------- */
+  /*  RollTerm Attributes                         */
+  /* -------------------------------------------- */
+
+  /** An array of additional attributes which should be retained when the term is serialized */
+  static SERIALIZE_ATTRIBUTES: string[];
+
+  /** A string representation of the formula expression for this RollTerm, prior to evaluation */
+  get expression(): string;
+
+  /** A string representation of the formula, including optional flavor text. */
+  get formula(): string;
+
+  /** A string or numeric representation of the final output for this term, after evaluation. */
+  get total(): number | string | null | undefined;
+
+  /** 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;
+
+  /** A reference to the RollResolver app being used to externally resolve this term. */
+  get resolver(): RollResolver; // TODO: Implement this
+
+  /* -------------------------------------------- */
+  /*  RollTerm Methods                            */
+  /* -------------------------------------------- */
+
+  /**
+   * Evaluate the term, processing its inputs and finalizing its total.
+   * @param options - (default: `{}`)
+   * @returns A Promise if the term is non-deterministic.
+   */
+  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
+
+  /**
+   * Evaluate the term.
+   * @param options - (default: `{}`)
+   * @returns A Promise if the term is non-deterministic.
+   */
+  protected _evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
+
+  /**
+   * Determine if evaluating a given RollTerm with certain evaluation options can be done so deterministically.
+   */
+  static isDeterministic(
+    term: RollTerm,
+    { minimize, maximize }?: InexactPartial<{ minimize: boolean; maximize: boolean }>,
+  ): boolean;
+
+  /* -------------------------------------------- */
+  /*  Serialization and Loading                   */
+  /* -------------------------------------------- */
+
+  /**
+   * Construct a RollTerm from a provided data object
+   * @param data - Provided data from an un-serialized term
+   * @returns The constructed RollTerm
+   */
+  static fromData(data: Record<string, unknown>): RollTerm;
+
+  /** Construct a RollTerm from parser information. */
+  static fromParseNode(node: RollParseNode): RollTerm;
+
+  /**
+   * * Define term-specific logic for how a de-serialized data object is restored as a functional RollTerm
+   * @param data - The de-serialized term data
+   * @returns The re-constructed RollTerm object
+   */
+  protected static _fromData<T extends RollTerm>(this: ConstructorOf<T>, data: Record<string, unknown>): T;
+
+  /**
+   * Reconstruct a RollTerm instance from a provided JSON string
+   * @param json - A serialized JSON representation of a DiceTerm
+   * @returns A reconstructed RollTerm from the provided JSON
+   */
+  static fromJSON(json: string): RollTerm;
+
+  /**
+   * Serialize the RollTerm to a JSON string which allows it to be saved in the database or embedded in text.
+   * This method should return an object suitable for passing to the JSON.stringify function.
+   */
+  toJSON(): Record<string, unknown>;
+}
+
+declare namespace RollTerm {
+  interface Options {
+    flavor?: string | unknown;
+  }
+
+  interface EvaluationOptions {
+    /**
+     * Maximize the result, obtaining the largest possible value.
+     * @defaultValue `false`
+     * */
+    maximize: boolean;
+
+    /**
+     * Minimize the result, obtaining the smallest possible value
+     * @defaultValue `false`
+     */
+    minimize: boolean;
+
+    /**
+     * If true, string terms will not throw an error when evaluated.
+     * @defaultValue `false`
+     */
+    allowStrings: boolean;
+  }
+
+  interface Data {
+    class: string;
+    evaluated: boolean;
+    options: Options;
+  }
+}
+
+export default RollTerm;

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

@@ -0,0 +1,134 @@
+/**
+ * A standalone, pure JavaScript implementation of the Mersenne Twister pseudo random number generator.
+ *
+ * author: Raphael Pigulla \<pigulla\@four66.com\>
+ * version: 0.2.3
+ * license:
+ * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. The names of its contributors may not be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+declare class MersenneTwister {
+  /**
+   * Instantiates a new Mersenne Twister.
+   * @param seed - The initial seed value, if not provided the current timestamp will be used.
+   */
+  constructor(seed?: number);
+
+  /**
+   * Initializes the state vector by using one unsigned 32-bit integer "seed", which may be zero.
+   *
+   * since: 0.1.0
+   * @param seed - The seed value.
+   */
+  seed(seed: number): number;
+
+  /**
+   * Initializes the state vector by using an array key[] of unsigned 32-bit integers of the specified length. If
+   * length is smaller than 624, then each array of 32-bit integers gives distinct initial state vector. This is
+   * useful if you want a larger seed space than 32-bit word.
+   *
+   * since: 0.1.0
+   * @param vector - The seed vector.
+   */
+  seedArray(vector: number[]): void;
+
+  /**
+   * Generates a random unsigned 32-bit integer.
+   *
+   * since: 0.1.0
+   */
+  int(): number;
+
+  /**
+   * Generates a random unsigned 31-bit integer.
+   *
+   * since: 0.1.0
+   */
+  int31(): number;
+
+  /**
+   * Generates a random real in the interval [0;1] with 32-bit resolution.
+   *
+   * since: 0.1.0
+   */
+  real(): number;
+
+  /**
+   * Generates a random real in the interval ]0;1[ with 32-bit resolution.
+   *
+   * since: 0.1.0
+   */
+  realx(): number;
+
+  /**
+   * Generates a random real in the interval [0;1[ with 32-bit resolution.
+   *
+   * since: 0.1.0
+   */
+  rnd(): number;
+
+  /**
+   * Generates a random real in the interval [0;1[ with 32-bit resolution.
+   *
+   * Same as .rnd() method - for consistency with Math.random() interface.
+   *
+   * since: 0.2.0
+   * @see {@link MersenneTwister#rnd}
+   */
+  random(): number;
+
+  /**
+   * Generates a random real in the interval [0;1[ with 53-bit resolution.
+   *
+   * since: 0.1.0
+   */
+  rndHiRes(): number;
+
+  /**
+   * A pseudo-normal distribution using the Box-Muller transform.
+   * @param mu    - The normal distribution mean
+   * @param sigma - The normal distribution standard deviation
+   */
+  normal(mu: number, sigma: number): number;
+
+  /**
+   * A factory method for generating random uniform rolls
+   * @see {@link MersenneTwister#random}
+   */
+  static random(): number;
+
+  /**
+   * A factory method for generating random normal rolls
+   * @see {@link MersenneTwister#normal}
+   */
+  static normal(mu: number, sigma: number): number;
+}
+
+export default MersenneTwister;

package/src/foundry/client-esm/helpers/_module.d.mts

@@ -0,0 +1,8 @@
+// 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 */
+
+export * as types from "./_types.mjs";
+
+export { default as CompendiumArt } from "./compendium-art.mjs";

package/src/foundry/client-esm/helpers/_types.d.mts

@@ -0,0 +1,51 @@
+import type { SchemaField } from "../../common/data/fields.d.mts";
+import type { PrototypeToken } from "../data/_module.d.mts";
+
+export interface CompendiumArtInfo {
+  /**
+   * The path to the Actor's portrait image.
+   */
+  actor?: string | undefined;
+
+  /**
+   * The path to the token image, or an object to merge into the Actor's prototype token.
+   */
+  token?: string | SchemaField.InnerAssignmentType<PrototypeToken.Schema> | undefined;
+
+  /**
+   *An optional credit string for use by the game system to apply in an appropriate place.
+   */
+  credit?: string | undefined;
+}
+
+/**
+ * A mapping of compendium pack IDs to Document IDs to art information.
+ */
+export type CompendiumArtMapping = Record<string, Record<string, CompendiumArtInfo>>;
+
+export interface CompendiumArtDescriptor {
+  /**
+   * The ID of the package providing the art.
+   */
+  packageId: string;
+
+  /**
+   * The title of the package providing the art.
+   */
+  title: string;
+
+  /**
+   * The path to the art mapping file.
+   */
+  mapping: string;
+
+  /**
+   * An optional credit string for use by the game system to apply in an appropriate place.
+   */
+  credit?: string | undefined;
+
+  /**
+   * The package's user-configured priority.
+   */
+  priority: number;
+}

package/src/foundry/client-esm/helpers/compendium-art.d.mts

@@ -0,0 +1,47 @@
+import type { CompendiumArtDescriptor, CompendiumArtInfo, CompendiumArtMapping } from "./_types.d.mts";
+
+/**
+ * A class responsible for managing package-provided art and applying it to Documents in compendium packs.
+ */
+declare class CompendiumArt extends Map<string, CompendiumArtInfo> {
+  /**
+   * The key for the package manifest flag used to store the mapping information.
+   * @defaultValue `"compendiumArtMappings"`
+   */
+  readonly FLAG: string;
+
+  /**
+   * The key for the setting used to store the World's art preferences.
+   * @defaultValue `"compendiumArtConfiguration"`
+   */
+  readonly SETTING: string;
+
+  /**
+   * Whether art application is enabled. This should be switched off when performing client-side compendium migrations
+   * in order to avoid persisting injected data.
+   * @defaultValue `true`
+   */
+  enabled: boolean;
+
+  /**
+   * Retrieve all active packages that provide art mappings in priority order.
+   */
+  getPackages(): CompendiumArtDescriptor[];
+
+  /**
+   * Collate Document art mappings from active packages.
+   * @internal
+   */
+  _registerArt(): Promise<void>;
+
+  /**
+   * Parse a provided art mapping and store it for reference later, and update compendium indices to use the provided
+   * art.
+   * @param packageId - The ID of the package providing the mapping.
+   * @param mapping   - The art mapping information provided by the package.
+   * @param credit    - An optional credit string for use by the game system to apply in an appropriate place.
+   */
+  #parseArtMapping(packageId: string, mapping: CompendiumArtMapping, credit?: string): Promise<void>;
+}
+
+export default CompendiumArt;