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

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

@@ -1,235 +0,0 @@
-declare global {
-  /**
-   * A type of RollTerm which encloses a pool of multiple inner Rolls which are evaluated jointly.
-   *
-   * A dice pool represents a set of Roll expressions which are collectively modified to compute an effective total
-   * across all Rolls in the pool. The final total for the pool is defined as the sum over kept rolls, relative to any
-   * success count or margin.
-   *
-   * @example
-   * ```typescript
-   * // Keep the highest of the 3 roll expressions
-   * let pool = new PoolTerm({
-   *   rolls: ["4d6", "3d8 - 1", "2d10 + 3"],
-   *   modifiers: ["kh"]
-   * });
-   * pool.evaluate();
-   * ```
-   */
-  class PoolTerm extends RollTerm {
-    constructor({ terms, modifiers, rolls, results, options }?: PoolTermConstructorData);
-
-    /**
-     * The original provided terms to the Dice Pool
-     */
-    terms: PoolTerm.TermData['terms'];
-
-    /**
-     * The string modifiers applied to resolve the pool
-     */
-    modifiers: PoolTerm.TermData['modifiers'];
-
-    /**
-     * Each component term of a dice pool is evaluated as a Roll instance
-     */
-    rolls: PoolTerm.TermData['rolls'];
-
-    /**
-     * The array of dice pool results which have been rolled
-     */
-    results: PoolTerm.TermData['results'];
-
-    /**
-     * Define the modifiers that can be used for this particular DiceTerm type.
-     */
-    static MODIFIERS: PoolTerm.Modifiers;
-
-    /**
-     * The regular expression pattern used to identify the opening of a dice pool expression.
-     * @defaultValue `/{/g`
-     */
-    static OPEN_REGEXP: RegExp;
-
-    /**
-     * A regular expression pattern used to identify the closing of a dice pool expression
-     * @defaultValue
-     * ```typescript
-     * new RegExp(`}${DiceTerm.MODIFIERS_REGEXP_STRING}?(?:%F[0-9]+%)?`, "g")
-     * ```
-     */
-    static CLOSE_REGEXP: RegExp;
-
-    /**
-     * A regular expression pattern used to match the entirety of a DicePool expression.
-     */
-    static REGEXP: RegExp;
-
-    /**
-     * @defaultValue `["terms", "modifiers", "rolls", "results"]`
-     */
-    static SERIALIZE_ATTRIBUTES: string[];
-
-    /**
-     * Return an Array of each individual DiceTerm instances contained within the PoolTerm.
-     */
-    get dice(): DiceTerm[];
-
-    get expression(): string;
-
-    get total(): undefined | number;
-
-    /**
-     * Return an array of rolled values which are still active within the PoolTerm
-     */
-    get values(): number[];
-
-    /**
-     * Alter the DiceTerm by adding or multiplying the number of dice which are rolled
-     * @param args - Arguments passed to each contained Roll#alter method.
-     * @returns The altered pool
-     */
-    alter(...args: Parameters<Roll['alter']>): this;
-
-    protected _evaluateSync({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): this;
-
-    protected _evaluate({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): Promise<this>;
-
-    /**
-     * Use the same logic as for the DiceTerm to avoid duplication
-     * @see DiceTerm#_evaluateModifiers
-     */
-    protected _evaluateModifiers(): void;
-
-    /**
-     * Use the same logic as for the DiceTerm to avoid duplication
-     * @see DiceTerm#_evaluateModifier
-     */
-    protected _evaluateModifier(command: string, modifier: string): void;
-
-    protected static _fromData<T extends RollTerm>(this: ConstructorOf<T>, data: object): T;
-
-    toJSON(): object;
-
-    /**
-     * Given a string formula, create and return an evaluated PoolTerm object
-     * @param formula - The string formula to parse
-     * @param options - Additional options applied to the PoolTerm
-     * @returns The evaluated PoolTerm object or null if the formula is invalid
-     */
-    static fromExpression<T extends RollTerm>(
-      this: ConstructorOf<T>,
-      formula: string,
-      options?: RollTerm.Options
-    ): T | null;
-
-    /**
-     * Create a PoolTerm by providing an array of existing Roll objects
-     * @param rolls - An array of Roll objects from which to create the pool
-     * @returns The constructed PoolTerm comprised of the provided rolls
-     */
-    static fromRolls<T extends PoolTerm>(this: ConstructorOf<T>, rolls?: Roll[]): T;
-
-    /**
-     * Keep a certain number of highest or lowest dice rolls from the result set.
-     * @example
-     * `{1d6,1d8,1d10,1d12}kh2` Keep the 2 best rolls from the pool
-     * @example
-     * `{1d12,6}kl` Keep the lowest result in the pool
-     *
-     * @param modifier - The matched modifier query
-     */
-    keep(modifier: string): ReturnType<Die['keep']>;
-
-    /**
-     * Keep a certain number of highest or lowest dice rolls from the result set.
-     * @example
-     * `{1d6,1d8,1d10,1d12}dl3` Drop the 3 worst results in the pool
-     * @example
-     * `{1d12,6}dh` Drop the highest result in the pool
-     *
-     * @param modifier - The matched modifier query
-     */
-    drop(modifier: string): ReturnType<Die['drop']>;
-
-    /**
-     * Count the number of successful results which occurred in the pool.
-     * Successes are counted relative to some target, or relative to the maximum possible value if no target is given.
-     * Applying a count-success modifier to the results re-casts all results to 1 (success) or 0 (failure)
-     * @example
-     * `20d20cs` Count the number of dice which rolled a 20
-     * @example
-     * `20d20cs>10` Count the number of dice which rolled higher than 10
-     * @example
-     * `20d20cs<10` Count the number of dice which rolled less than 10
-     *
-     * @param modifier - The matched modifier query
-     */
-    countSuccess(modifier: string): ReturnType<Die['countSuccess']>;
-
-    /**
-     * Count the number of failed results which occurred in a given result set.
-     * Failures are counted relative to some target, or relative to the lowest possible value if no target is given.
-     * Applying a count-failures modifier to the results re-casts all results to 1 (failure) or 0 (non-failure)
-     * @example
-     * `6d6cf` Count the number of dice which rolled a 1 as failures
-     * @example
-     * `6d6cf<=3` Count the number of dice which rolled less than 3 as failures
-     * @example
-     * `6d6cf>4` Count the number of dice which rolled greater than 4 as failures
-     *
-     * @param modifier - The matched modifier query
-     */
-    countFailures(modifier: string): ReturnType<Die['countFailures']>;
-  }
-
-  namespace PoolTerm {
-    /**
-     * @remarks This interface is not defined by foundry itself. It only exists
-     * to allow module and system authors to use it for declaration merging,
-     * enabling them to add additional modifiers for {@link PoolTerm}s.
-     */
-    interface Modifiers {
-      k: 'keep';
-      kh: 'keep';
-      kl: 'keep';
-      d: 'drop';
-      dh: 'drop';
-      dl: 'drop';
-      cs: 'countSuccess';
-      cf: 'countFailures';
-    }
-
-    type TermData = Required<PoolTermConstructorData>;
-  }
-}
-
-interface PoolTermConstructorData {
-  /**
-   * @defaultValue `[]`
-   */
-  terms?: string[];
-
-  get isDeterministic(): boolean;
-
-  /**
-   * @defaultValue `[]`
-   */
-  modifiers?: string[];
-
-  /**
-   * @defaultValue `[]`
-   */
-  rolls?: Roll[];
-
-  /**
-   * @defaultValue `[]`
-   */
-  results?: DiceTerm.Result[];
-
-  /**
-   * @defaultValue `{}`
-   */
-  options?: RollTerm.Options;
-}
-
-export {};

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

@@ -1,31 +0,0 @@
-declare global {
-  /**
-   * A type of RollTerm used to represent strings which have not yet been matched.
-   */
-  class StringTerm extends RollTerm {
-    constructor({ term, options }: StringTermConstructorData);
-
-    term: StringTermConstructorData['term'];
-
-    /**
-     * @defaultValue `["term"]`
-     */
-    static SERIALIZE_ATTRIBUTES: string[];
-
-    get expression(): string;
-
-    get total(): string;
-
-    override get isDeterministic(): boolean;
-
-    evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): never;
-  }
-}
-
-interface StringTermConstructorData {
-  term: string;
-
-  options?: RollTerm.Options;
-}
-
-export {};

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

@@ -1,134 +0,0 @@
-/**
- * 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;
-}
-
-declare const twist: MersenneTwister;