@dicelette/core 1.19.0 → 1.20.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Engine } from 'random-js';
+import { Engine, Random } from 'random-js';
 import { z } from 'zod';
 
 /**
@@ -9,7 +9,7 @@ import { z } from 'zod';
  * Random stats = 6
  * result = "1d20>3"
  */
-declare function createCriticalCustom(dice: string, customCritical: CustomCritical, template: StatisticalTemplate): string;
+declare function createCriticalCustom(dice: string, customCritical: CustomCritical, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Parse the string provided and turn it as a readable dice for dice parser
  * @param dice {string}
@@ -24,6 +24,41 @@ declare function roll(dice: string, engine?: Engine | null): Resultat | undefine
  */
 declare function calculator(sign: Sign, value: number, total: number): number;
 
+declare class DiceTypeError extends Error {
+    readonly dice: string;
+    readonly cause: string | undefined;
+    readonly method: unknown;
+    constructor(dice: string, cause?: string, method?: unknown);
+}
+declare class FormulaError extends Error {
+    readonly formula: string;
+    readonly cause: string | undefined;
+    readonly method: unknown;
+    constructor(formula: string, cause?: string, method?: unknown);
+}
+declare class MaxGreater extends Error {
+    readonly name: string;
+    readonly value: number;
+    readonly max: number;
+    constructor(value: number, max: number);
+}
+declare class EmptyObjectError extends Error {
+    readonly name: string;
+    constructor();
+}
+declare class TooManyDice extends Error {
+    readonly name: string;
+    constructor();
+}
+declare class TooManyStats extends Error {
+    readonly name: string;
+    constructor();
+}
+declare class NoStatisticsError extends Error {
+    readonly name: string;
+    constructor();
+}
+
 interface Resultat {
     /**
      * Original dice throw
@@ -198,6 +233,61 @@ interface CustomCritical {
     affectSkill?: boolean;
 }
 
+declare const COMMENT_REGEX: RegExp;
+declare const SIGN_REGEX: RegExp;
+declare const SIGN_REGEX_SPACE: RegExp;
+declare const SYMBOL_DICE = "&";
+declare const DETECT_CRITICAL: RegExp;
+
+interface StatisticalSchema extends StatisticalTemplate {
+    /**
+     * Specifies the URL for the schema definition
+     * This property is optional and should contain a valid URI.
+     */
+    $schema?: string;
+}
+
+/**
+ * Definition of the Zod schema for template data
+ */
+
+declare const templateSchema: z.ZodObject<{
+    charName: z.ZodOptional<z.ZodBoolean>;
+    statistics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        max: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>;
+        min: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>;
+        combinaison: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
+        exclude: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    total: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>;
+    forceDistrib: z.ZodOptional<z.ZodBoolean>;
+    diceType: z.ZodOptional<z.ZodString>;
+    critical: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+        success: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        failure: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>, z.ZodTransform<{
+        success?: string | number | undefined;
+        failure?: string | number | undefined;
+    }, {
+        success?: string | number | undefined;
+        failure?: string | number | undefined;
+    }>>>;
+    customCritical: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        sign: z.ZodEnum<{
+            "<": "<";
+            ">": ">";
+            ">=": ">=";
+            "<=": "<=";
+            "!=": "!=";
+            "==": "==";
+        }>;
+        value: z.ZodString;
+        onNaturalDice: z.ZodOptional<z.ZodBoolean>;
+        affectSkill: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    damage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+
 /**
  * Escape regex string
  * @param string {string}
@@ -232,16 +322,40 @@ declare function isNumber(value: unknown): boolean;
  * Replace the `{exp}` in the dice.
  * If the `{exp}` has a default value in the form of `{exp || defaultValue}`, it will be replaced by the default value.
  * @param {string} dice
+ * @param engine
  * @returns {string} the dice with the {exp} replaced by a random value
  */
-declare function replaceExpByRandom(dice: string): string;
+declare function replaceExpByRandom(dice: string, engine?: Engine | null): string;
+/**
+ * Utility function to get a random integer between min and max and using the specified engine
+ * @param min {number}
+ * @param max {number}
+ * @param engine {Engine | null} Engine to use, default to nodeCrypto
+ * @param rng {Random | undefined} Random instance to use, see https://www.npmjs.com/package/random-js#usage
+ * @returns {number} Random integer between min and max
+ */
+declare function randomInt(min: number, max: number, engine?: Engine | null, rng?: Random): number;
+/**
+ * Utility function that allow to get the id of an engine
+ * @param engine {unknown} Engine to identify
+ * @returns {string} Id of the engine or "unknown"
+ * @private
+ */
+declare function getEngineId(engine: unknown): string;
+/**
+ * Utility function to get the engine from its name
+ * @param engine {"nativeMath" | "browserCrypto" | "nodeCrypto"} The engine name
+ * @returns {Engine} The engine
+ * @public
+ */
+declare function getEngine(engine: "nativeMath" | "browserCrypto" | "nodeCrypto"): Engine;
 
 /**
  * Verify if the provided dice work with random value
  * @param testDice {string}
  * @param allStats {Record<string,number>}
  */
-declare function evalStatsDice(testDice: string, allStats?: Record<string, number>): string;
+declare function evalStatsDice(testDice: string, allStats?: Record<string, number>, engine?: Engine | null): string;
 /**
  * Generate a random dice and remove the formula (+ evaluate it)
  * Used for diceDamage only
@@ -249,13 +363,13 @@ declare function evalStatsDice(testDice: string, allStats?: Record<string, numbe
  * @param template {StatisticalTemplate}
  * @returns
  */
-declare function diceRandomParse(value: string, template: StatisticalTemplate): string;
+declare function diceRandomParse(value: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Same as damageDice but for DiceType
  * @param dice {string}
  * @param template {StatisticalTemplate}
  */
-declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate): string;
+declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Random the combinaison and evaluate it to check if everything is valid
  * @param combinaison {Record<string,string>}
@@ -274,17 +388,17 @@ declare function evalOneCombinaison(combinaison: string, stats: Record<string, n
  * @param {boolean} verify - If true, will roll the dices to check if everything is valid
  * @returns {StatisticalTemplate}
  */
-declare function verifyTemplateValue(template: unknown, verify?: boolean): StatisticalTemplate;
+declare function verifyTemplateValue(template: unknown, verify?: boolean, engine?: Engine | null): StatisticalTemplate;
 /**
  * Test each damage roll from the template.damage
  * @param {StatisticalTemplate} template
  */
-declare function testDiceRegistered(template: StatisticalTemplate): void;
+declare function testDiceRegistered(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Test all combinaison with generated random value
  * @param {StatisticalTemplate} template
  */
-declare function testStatCombinaison(template: StatisticalTemplate): void;
+declare function testStatCombinaison(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Generate a random stat based on the template and the statistical min and max
  * @param {number|undefined} total
@@ -292,96 +406,6 @@ declare function testStatCombinaison(template: StatisticalTemplate): void;
  * @param {number | undefined} min
  * @returns
  */
-declare function generateRandomStat(total?: number | undefined, max?: number, min?: number): number;
-
-declare class DiceTypeError extends Error {
-    readonly dice: string;
-    readonly cause: string | undefined;
-    readonly method: unknown;
-    constructor(dice: string, cause?: string, method?: unknown);
-}
-declare class FormulaError extends Error {
-    readonly formula: string;
-    readonly cause: string | undefined;
-    readonly method: unknown;
-    constructor(formula: string, cause?: string, method?: unknown);
-}
-declare class MaxGreater extends Error {
-    readonly name: string;
-    readonly value: number;
-    readonly max: number;
-    constructor(value: number, max: number);
-}
-declare class EmptyObjectError extends Error {
-    readonly name: string;
-    constructor();
-}
-declare class TooManyDice extends Error {
-    readonly name: string;
-    constructor();
-}
-declare class TooManyStats extends Error {
-    readonly name: string;
-    constructor();
-}
-declare class NoStatisticsError extends Error {
-    readonly name: string;
-    constructor();
-}
-
-declare const COMMENT_REGEX: RegExp;
-declare const SIGN_REGEX: RegExp;
-declare const SIGN_REGEX_SPACE: RegExp;
-declare const SYMBOL_DICE = "&";
-declare const DETECT_CRITICAL: RegExp;
-
-/**
- * Definition of the Zod schema for template data
- */
-
-declare const templateSchema: z.ZodObject<{
-    charName: z.ZodOptional<z.ZodBoolean>;
-    statistics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        max: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>;
-        min: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>;
-        combinaison: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
-        exclude: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    total: z.ZodOptional<z.ZodPipe<z.ZodNumber, z.ZodTransform<number | undefined, number>>>;
-    forceDistrib: z.ZodOptional<z.ZodBoolean>;
-    diceType: z.ZodOptional<z.ZodString>;
-    critical: z.ZodOptional<z.ZodPipe<z.ZodObject<{
-        success: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-        failure: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    }, z.core.$strip>, z.ZodTransform<{
-        success?: string | number | undefined;
-        failure?: string | number | undefined;
-    }, {
-        success?: string | number | undefined;
-        failure?: string | number | undefined;
-    }>>>;
-    customCritical: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        sign: z.ZodEnum<{
-            ">=": ">=";
-            "<=": "<=";
-            "<": "<";
-            ">": ">";
-            "!=": "!=";
-            "==": "==";
-        }>;
-        value: z.ZodString;
-        onNaturalDice: z.ZodOptional<z.ZodBoolean>;
-        affectSkill: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    damage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>;
-
-interface StatisticalSchema extends StatisticalTemplate {
-    /**
-     * Specifies the URL for the schema definition
-     * This property is optional and should contain a valid URI.
-     */
-    $schema?: string;
-}
+declare function generateRandomStat(total?: number | undefined, max?: number, min?: number, engine?: Engine | null): number;
 
-export { COMMENT_REGEX, type Compare, type ComparedValue, type Critical, type CustomCritical, type CustomCriticalMap, DETECT_CRITICAL, DiceTypeError, EmptyObjectError, FormulaError, MaxGreater, type Modifier, NoStatisticsError, type Resultat, SIGN_REGEX, SIGN_REGEX_SPACE, SYMBOL_DICE, type Sign, type Statistic, type StatisticalSchema, type StatisticalTemplate, TooManyDice, TooManyStats, calculator, createCriticalCustom, diceRandomParse, diceTypeRandomParse, escapeRegex, evalCombinaison, evalOneCombinaison, evalStatsDice, generateRandomStat, generateStatsDice, isNumber, replaceExpByRandom, replaceFormulaInDice, roll, standardizeDice, templateSchema, testDiceRegistered, testStatCombinaison, verifyTemplateValue };
+export { COMMENT_REGEX, type Compare, type ComparedValue, type Critical, type CustomCritical, type CustomCriticalMap, DETECT_CRITICAL, DiceTypeError, EmptyObjectError, FormulaError, MaxGreater, type Modifier, NoStatisticsError, type Resultat, SIGN_REGEX, SIGN_REGEX_SPACE, SYMBOL_DICE, type Sign, type Statistic, type StatisticalSchema, type StatisticalTemplate, TooManyDice, TooManyStats, calculator, createCriticalCustom, diceRandomParse, diceTypeRandomParse, escapeRegex, evalCombinaison, evalOneCombinaison, evalStatsDice, generateRandomStat, generateStatsDice, getEngine, getEngineId, isNumber, randomInt, replaceExpByRandom, replaceFormulaInDice, roll, standardizeDice, templateSchema, testDiceRegistered, testStatCombinaison, verifyTemplateValue };