@dicelette/core 1.0.10 → 1.1.1

package/core/utils.ts

@@ -1,65 +0,0 @@
-import { evaluate } from "mathjs";
-import removeAccents from "remove-accents";
-
-/**
- * Escape regex string
- * @param string {string}
- */
-export function escapeRegex(string: string) {
-	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-
-/**
- * Replace the stat name by their value using stat and after evaluate any formula using `replaceFormulaInDice`
- * @param originalDice {dice}
- * @param stats {[name: string]: number}
- */
-export function generateStatsDice(originalDice: string, stats?: {[name: string]: number}) {
-	let dice = originalDice;
-	if (stats && Object.keys(stats).length > 0) {
-		//damage field support adding statistic, like : 1d6 + strength
-		//check if the value contains a statistic & calculate if it's okay
-		//the dice will be converted before roll 
-		const allStats = Object.keys(stats);
-		for (const stat of allStats) {
-			const regex = new RegExp(escapeRegex(removeAccents(stat)), "gi");
-			if (dice.match(regex)) {
-				const statValue = stats[stat];
-				dice = dice.replace(regex, statValue.toString());
-			}
-		}
-	}
-	return replaceFormulaInDice(dice);
-	
-}
-
-/**
- * Replace the {{}} in the dice string and evaluate the interior if any
- * @param dice {string}
- */
-export function replaceFormulaInDice(dice: string) {
-	const formula = /(?<formula>\{{2}(.+?)\}{2})/gmi;
-	const formulaMatch = formula.exec(dice);
-	if (formulaMatch?.groups?.formula) {
-		const formula = formulaMatch.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
-		try {
-			const result = evaluate(formula);
-			return cleanedDice(dice.replace(formulaMatch.groups.formula, result.toString()));
-		} catch (error) {
-			throw new Error(`[error.invalidFormula, common.space]: ${formulaMatch.groups.formula}`);
-		}
-	}
-	return cleanedDice(dice);
-}
-
-/**
- * Replace the ++ +- -- by their proper value:
- * - `++` = `+`
- * - `+-` = `-`
- * - `--` = `+`
- * @param dice {string}
- */
-export function cleanedDice(dice: string) {
-	return dice.replaceAll("+-", "-").replaceAll("--", "+").replaceAll("++", "+");
-}

package/core/verify_template.ts

@@ -1,263 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { evaluate } from "mathjs";
-import {Random } from "random-js";
-import removeAccents from "remove-accents";
-
-import { Statistic, StatisticalTemplate } from "..";
-import { roll } from "./dice";
-import { escapeRegex, replaceFormulaInDice } from "./utils";
-
-/**
- * Verify if the provided dice work with random value
- * @param testDice {string}
- * @param stats {[name: string]: number}
- */
-export function evalStatsDice(testDice: string, stats?: {[name: string]: number}) {
-	let dice = testDice;
-	if (stats && Object.keys(stats).length > 0) {
-		const allStats = Object.keys(stats);
-		for (const stat of allStats) {
-			const regex = new RegExp(escapeRegex(removeAccents(stat)), "gi");
-			if (testDice.match(regex)) {
-				const statValue = stats[stat];
-				dice = testDice.replace(regex, statValue.toString());
-			}
-		}
-	}	
-	try {
-		if (!roll(replaceFormulaInDice(dice))) throw new Error(`[error.invalidDice.withoutDice, common.space] ${dice}`);
-		return testDice;
-	} catch (error) {
-		throw new Error(`[error.invalidDice.withoutDice, common.space]: ${testDice}\n${(error as Error).message}`);
-	}
-}
-
-/**
- * Generate a random dice and remove the formula (+ evaluate it)
- * Used for diceDamage only
- * @param value {string}
- * @param template {StatisticalTemplate}
- * @returns 
- */
-export function diceRandomParse(value: string, template: StatisticalTemplate) {
-	if (!template.statistics) return value;
-	value = removeAccents(value);
-	const allStats = Object.keys(template.statistics).map(stat => removeAccents(stat).toLowerCase());
-	let newDice = value;
-	for (const stat of allStats) {
-		const regex = new RegExp(escapeRegex(stat), "gi");
-		if (value.match(regex)) {
-			let max: undefined | number = undefined;
-			let min: undefined | number = undefined;
-			const stats = template.statistics?.[stat];
-			if (stats) {
-				max = template.statistics[removeAccents(stat).toLowerCase()].max;
-				min = template.statistics[removeAccents(stat).toLowerCase()].min;
-			}
-			const total = template.total || 100;
-			const randomStatValue = generateRandomStat(total, max, min);
-			newDice = value.replace(regex, randomStatValue.toString());
-		}
-	}
-	return replaceFormulaInDice(newDice);
-}
-
-/**
- * Same as damageDice but for DiceType
- * @param dice {string}
- * @param template {StatisticalTemplate}
- */
-export function diceTypeRandomParse(dice: string, template: StatisticalTemplate) {
-	if (!template.statistics) return dice;
-	const firstStatNotCombinaison = Object.keys(template.statistics).find(stat => !template.statistics?.[stat].combinaison);
-	if (!firstStatNotCombinaison) return dice;
-	const stats = template.statistics[firstStatNotCombinaison];
-	const {min, max} = stats;
-	const total = template.total || 100;
-	const randomStatValue = generateRandomStat(total, max, min);
-	return replaceFormulaInDice(dice.replace("$", randomStatValue.toString()));
-}
-
-/**
- * Random the combinaison and evaluate it to check if everything is valid
- * @param combinaison {[name: string]: string}
- * @param stats {[name: string]: string|number}
- */
-export function evalCombinaison(combinaison: {[name: string]: string}, stats: {[name: string]: string | number}) {
-	const newStats: {[name: string]: number} = {};
-	for (const [stat, combin] of Object.entries(combinaison)) {
-		//replace the stats in formula
-		let formula = removeAccents(combin);
-		for (const [statName, value] of Object.entries(stats)) {
-			const regex = new RegExp(removeAccents(statName), "gi");
-			formula = formula.replace(regex, value.toString());
-		}
-		try {
-			const result = evaluate(formula);
-			newStats[stat] = result;
-		} catch (error) {
-			throw new Error(`[error.invalidFormula, common.space]: ${stat}`);
-		}
-	}
-	return newStats;
-}
-
-/**
- * Evaluate one selected combinaison
- * @param combinaison {string}
- * @param stats {[name: string]: string|number}
- */
-export function evalOneCombinaison(combinaison: string, stats: {[name: string]: string | number}) {
-	let formula = removeAccents(combinaison);
-	for (const [statName, value] of Object.entries(stats)) {
-		const regex = new RegExp(removeAccents(statName), "gi");
-		formula = formula.replace(regex, value.toString());
-	}
-	try {
-		return evaluate(formula);
-	} catch (error) {
-		throw new Error(`[error.invalidFormula, common.space]: ${combinaison}`);
-	}
-}
-
-/**
- * Parse the provided JSON and verify each field to check if everything could work when rolling
- * @param {any} template 
- * @returns {StatisticalTemplate}
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function verifyTemplateValue(template: any): StatisticalTemplate {
-	const statistiqueTemplate: StatisticalTemplate = {
-		diceType: "",
-		statistics: {} as Statistic
-	};
-	if (!template.statistics) statistiqueTemplate.statistics = undefined;
-	else if (template.statistics && Object.keys(template.statistics).length > 0) {
-		for (const [key, value] of Object.entries(template.statistics)) {
-			const dataValue = value as { max?: number, min?: number, combinaison?: string };
-			if (dataValue.max && dataValue.min && dataValue.max <= dataValue.min)
-				throw new Error("[error.maxGreater]");				
-			if (dataValue.max && dataValue.max <= 0 ) dataValue.max = undefined;
-			if (dataValue.min && dataValue.min <= 0 ) dataValue.min = undefined;
-			let formula = dataValue.combinaison ? removeAccents(dataValue.combinaison).toLowerCase() : undefined;
-			formula = formula && formula.trim().length > 0 ? formula : undefined;
-			if (!statistiqueTemplate.statistics) {
-				statistiqueTemplate.statistics = {} as Statistic;
-			}
-			statistiqueTemplate.statistics[key] = {
-				max: dataValue.max,
-				min: dataValue.min,
-				combinaison: formula || undefined,
-			};
-		}
-	}
-	if (template.diceType) {
-		try {
-			statistiqueTemplate.diceType = template.diceType;
-			diceTypeRandomParse(template.diceType, statistiqueTemplate);
-		} catch (e) {
-			throw new Error((e as Error).message);
-		}
-	}
-
-	
-	if (template.critical && Object.keys(template.critical).length > 0){
-		statistiqueTemplate.critical = {
-			failure: template.critical.failure ?? undefined,
-			success: template.critical.success ?? undefined
-		};
-
-	}
-	if (template.total) {
-		if (template.total <= 0)
-			template.total = undefined;
-		statistiqueTemplate.total = template.total;
-	}
-	if (template.charName) statistiqueTemplate.charName = template.charName;
-	if (template.damage) statistiqueTemplate.damage = template.damage;
-	try {
-		testDamageRoll(statistiqueTemplate);
-		testCombinaison(statistiqueTemplate);
-	} catch (error) {
-		throw new Error((error as Error).message);
-	}
-	return statistiqueTemplate;
-}
-
-/**
- * Test each damage roll from the template.damage
- * @param {StatisticalTemplate} template 
- */
-export function testDamageRoll(template: StatisticalTemplate) {
-	if (!template.damage) return;
-	if (Object.keys(template.damage).length === 0) throw new Error("[error.emptyObject]");
-	if (Object.keys(template.damage).length > 25) throw new Error("[error.tooManyDice]");
-	for (const [name, dice] of Object.entries(template.damage)) {
-		if (!dice) continue;
-		const randomDiceParsed = diceRandomParse(dice, template);
-		try {
-			roll(randomDiceParsed);
-		} catch (error) {
-			throw new Error(`[error.invalidDice, common.space] ${name}`);
-		}
-	}
-}
-
-
-
-/**
- * Test all combinaison with generated random value
- * @param {StatisticalTemplate} template 
- */
-export function testCombinaison(template: StatisticalTemplate) {
-	if (!template.statistics) return;
-	const onlyCombinaisonStats = Object.fromEntries(Object.entries(template.statistics).filter(([_, value]) => value.combinaison !== undefined));
-	const allOtherStats = Object.fromEntries(Object.entries(template.statistics).filter(([_, value]) => !value.combinaison));	
-	if (Object.keys(onlyCombinaisonStats).length===0) return;
-	const allStats = Object.keys(template.statistics).filter(stat => !template.statistics![stat].combinaison);
-	if (allStats.length === 0) 
-		throw new Error("[error.noStat]");
-	const error= [];
-	for (const [stat, value] of Object.entries(onlyCombinaisonStats)) {
-		let formula = value.combinaison as string;
-		for (const [other, data] of Object.entries(allOtherStats)) {
-			const {max, min} = data;
-			const total = template.total || 100;
-			const randomStatValue = generateRandomStat(total, max, min);
-			const regex = new RegExp(other, "gi");
-			formula = formula.replace(regex, randomStatValue.toString());
-		}
-		try {
-			evaluate(formula);
-		} catch (e) {
-			error.push(stat);
-		}
-	}
-	if (error.length > 0) 
-		throw new Error(`[error.invalidFormula, common.space] ${error.join(", ")}`);
-	return;
-}
-
-/**
- * Generate a random stat based on the template and the statistical min and max
- * @param {number|undefined} total
- * @param {number | undefined} max 
- * @param {number | undefined} min 
- * @returns 
- */
-export function generateRandomStat(total: number | undefined = 100, max?: number, min?: number) {
-	let randomStatValue = total + 1;
-	while (randomStatValue >= total) {
-		const random = new Random();
-		if (max && min)
-			randomStatValue = random.integer(min, max);
-		else if (max)
-			randomStatValue = random.integer(0, max);
-		else if (min)
-			randomStatValue = random.integer(min, total);
-		else
-			randomStatValue = random.integer(0, total);
-	}
-	return randomStatValue;
-}
-

package/index.ts

@@ -1,4 +0,0 @@
-export * from "./core/dice";
-export * from "./core/interface";
-export * from "./core/utils";
-export * from "./core/verify_template";

package/jest.config.js

@@ -1,6 +0,0 @@
-/** @type {import('ts-jest').JestConfigWithTsJest} */
-module.exports = {
-	preset: "ts-jest",
-	testEnvironment: "node",
-	verbose: true,
-};

package/tests/verify_template.test.ts

@@ -1,243 +0,0 @@
-// FILEPATH: /c:/Users/simonettili/Documents/Github/discord-dicelette/src/utils/verify_template.test.ts
-import * as core from "..";
-
-
-describe("verify_template", () => {
-	describe("evalCombinaison", () => {
-		it("should evaluate the combination correctly", () => {
-			const combinaison = { stat1: "stat2 + 3" };
-			const stats = { stat2: 2 };
-			const result = core.evalCombinaison(combinaison, stats);
-			expect(result).toEqual({ stat1: 5 });
-		});
-
-		it("should throw an error for invalid formula", () => {
-			const combinaison = { stat1: "stat2 + " };
-			const stats = { stat2: 2 };
-			expect(() => core.evalCombinaison(combinaison, stats)).toThrow();
-		});
-	});
-
-	describe("verifyRandomGenerator", () => {
-		// Add more tests for different scenarios
-		it("should verify the random generator correctly", () => {
-			const total = 100;
-			const max = 50;
-			const min = 10;
-			const result = core.generateRandomStat(total, max, min);
-			expect(result).toBeGreaterThanOrEqual(min);
-			expect(result).toBeLessThanOrEqual(max);
-			expect(result).toBeLessThanOrEqual(total);
-		});
-		
-		it ("should verify with no max", () => {
-			const total = 100;
-			const min = 1;
-			const result = core.generateRandomStat(total, undefined, min);
-			expect(result).toBeGreaterThanOrEqual(min);
-			expect(result).toBeLessThanOrEqual(total);
-		});
-
-		it ("should verify with no min", () => {
-			const total = 100;
-			const max = 99;
-			const result = core.generateRandomStat(total, max, undefined);
-			expect(result).toBeGreaterThanOrEqual(0);
-			expect(result).toBeLessThanOrEqual(max);
-		});
-
-		it ("should verify with no min and max", () => {
-			const total = 100;
-			const result = core.generateRandomStat(total, undefined, undefined);
-			expect(result).toBeGreaterThanOrEqual(0);
-			expect(result).toBeLessThanOrEqual(total);
-		});
-
-		it ("should verify with no total", () => {
-			const max = 99;
-			const min = 1;
-			const result = core.generateRandomStat(undefined, max, min);
-			expect(result).toBeGreaterThanOrEqual(min);
-			expect(result).toBeLessThanOrEqual(max);
-		});
-
-		it ("should verify with no total, min and max", () => {
-			const result = core.generateRandomStat(undefined, undefined, undefined);
-			expect(result).toBeGreaterThanOrEqual(0);
-			expect(result).toBeLessThanOrEqual(100);
-		});
-	});
-
-	describe("verifyTemplateValue", () => {
-		// Add more tests for different scenarios
-		it("should verify the template correctly", () => {
-			const template = {
-				statistics: { stat1: { max: 10, min: 1 } },
-				diceType: "1d20+{{ceil(($-10)/2)}}>20",
-				damage: {
-					"piercing": "1d6+2",
-				}
-			};
-			const result = core.verifyTemplateValue(template);
-			expect(result).toEqual(template);
-		});
-
-		it("testing no statistic, only damage", () => {
-			const template = {
-				diceType: "d6",
-				damage: {
-					"piercing": "1d6+2>20",
-				}
-			};
-			const result = core.verifyTemplateValue(template);
-			expect(result).toEqual(template);
-		});
-
-		it("should throw an error for invalid dice type", () => {
-			const template = {
-				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
-				diceType: "invalid",
-			};
-			expect(() => core.verifyTemplateValue(template)).toThrow();
-		});
-	});
-
-	describe("combinaison", () => {
-		// Add more tests for different scenarios
-		it("should throw an error because they are no stat2", () => {
-			const template: core.StatisticalTemplate = {
-				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
-				diceType: "d6",
-			};
-			expect(() => core.testCombinaison(template)).toThrow();
-		});
-		it("validate formula for dice", () => {
-			const template: core.StatisticalTemplate = {
-				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
-				diceType: "d6+{{$}}>20",
-			};
-			expect(() => core.testCombinaison(template)).toThrow();
-		});
-		it("validate formula for dice", () => {
-			const template: core.StatisticalTemplate = {
-				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
-				diceType: "d6+5>{{$}}",
-			};
-			expect(() => core.testCombinaison(template)).toThrow();
-		});
-		
-
-		
-		
-		it("create combinaison dice formula for skill dice with statistic", () => {
-			const testTemplate: core.StatisticalTemplate = {
-				statistics: { stat1: { max: 10, min: 1 } },
-				diceType: "1d20",
-				damage: {
-					"piercing": "1d6 + stat1>stat1",
-				}
-			};
-			const expectedFormula = core.diceRandomParse("1d20 + {{ceil((stat1-10)/2)}}>stat1", testTemplate);
-			expect(expectedFormula).toEqual(expectedFormula);
-		});
-		it("Test a roll with a combinaison on the dice", () => {
-			const template: core.StatisticalTemplate = {
-				statistics: { stat1: { max: 10, min: 1, combinaison: "stat2 + 3" } },
-				diceType: "1d20",
-				damage: {
-					"piercing": "1d20stat1*2>stat1",
-				}
-			};
-			expect(() => core.testDamageRoll(template)).not.toThrow();
-		});
-		it("Test a roll with a combinaison on the dice and accents", () => {
-			const template: core.StatisticalTemplate = {
-				statistics: { éducation: { max: 10, min: 1 } },
-				diceType: "1d20",
-				damage: {
-					"piercing": "1déducation>20",
-				}
-			};
-			expect(() => core.testDamageRoll(template)).not.toThrow();
-		});
-	});
-	describe("roll_string_creation", () => {
-		it("creating roll dice with formula", () => {
-			const dice = "1d20+$>20";
-			const userStat = 10;
-			const calculation = core.replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
-			const formula = `${calculation} coucou`;
-			const expectedFormula = "1d20+10>20 coucou";
-			expect(formula).toEqual(expectedFormula);
-		});
-		it("creating roll dice with success formula", () => {
-			const dice = "1d20+5>{{$*2}}";
-			const userStat = 10;
-			const calculation = core.replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
-			const formula = `${calculation} coucou`;
-			const expectedFormula = "1d20+5>20 coucou";
-			expect(formula).toEqual(expectedFormula);
-		});
-		it("creating roll dice with complicated formula", () => {
-			const dice = "1d20+{{ceil((10-$)/2)}}>20";
-			const userStat = 5;
-			const calculation = core.replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
-			const formula = `${calculation} coucou`;
-			const expectedFormula = "1d20+3>20 coucou";
-			expect(formula).toEqual(expectedFormula);
-		});
-		it("creating roll dice with negative formula", () => {
-			const dice = "1d20+{{ceil(($-10)/2)}}>20";
-			const userStat = 5;
-			const calculation = core.replaceFormulaInDice(dice.replaceAll("$", userStat.toString()));
-			const expectedFormula = "1d20-2>20";
-			expect(calculation).toEqual(expectedFormula);
-		});
-	});
-	describe("skill_dice_creation", () => {
-		it("creating roll dice with face formula", () => {
-			let dice = "1dstat1>20";
-			const userStat = {
-				stat1: 5,
-				stat2: 10
-			};
-			dice = core.generateStatsDice(dice, userStat);
-			const formula = `${dice} cc`;
-			const expectedFormula = "1d5>20 cc";
-			expect(formula).toEqual(expectedFormula);
-		});
-		it("creating complicated roll dice with face formula", () => {
-			let dice = "1d20+{{ceil((stat1-10)/2)}}>20";
-			const userStat = {
-				stat1: 10,
-				stat2: 10
-			};
-			dice = core.generateStatsDice(dice, userStat);
-			const formula = `${dice} cc`;
-			const expectedFormula = "1d20+0>20 cc";
-			expect(formula).toEqual(expectedFormula);
-		});
-		it("create a simple dice adding bonus superior to stats", () => {
-			let dice = "1d20+stat1>stat1";
-			const userStat = {
-				stat1: 5,
-				stat2: 10
-			};
-			dice = core.generateStatsDice(dice, userStat);
-			const formula = `${dice} cc`;
-			const expectedFormula = "1d20+5>5 cc";
-			expect(formula).toEqual(expectedFormula);
-		});
-		it("creating complicated roll dice with comparator as formula", () => {
-			let dice = "1d20+stat1>{{ceil(stat1/2)}}";
-			const userStat = {
-				stat1: 5,
-				stat2: 10
-			};
-			dice = core.generateStatsDice(dice, userStat);
-			const formula = `${dice} cc`;
-			const expectedFormula = "1d20+5>3 cc";
-			expect(formula).toEqual(expectedFormula);
-		});
-	});
-});

package/tree.txt

@@ -1,25 +0,0 @@
-
-   Source: E:\Documents\Github\dicelette\core
-
-Mode            Length Hierarchy
-----            ------ ---------
-d----        121,97 KB core
--a---        216,00  B ├── .eslintrc.js
--a---          2,13 KB ├── .gitignore
--a---        125,00  B ├── index.ts
--a---        142,00  B ├── jest.config.js
--a---         34,98 KB ├── LICENSE
--a---        829,00  B ├── package.json
--a---         76,68 KB ├── pnpm-lock.yaml
--a---          6,14 KB ├── README.md
--a---          0,00  B ├── tree.txt
--a---        783,00  B ├── tsconfig.json
-d----          8,04 KB ├── tests
--a---          8,04 KB │   └── verify_template.test.ts
-d----         14,39 KB ├── core
--a---          3,08 KB │   ├── dice.ts
--a---          2,01 KB │   ├── utils.ts
--a---          9,30 KB │   └── verify_template.ts
-d----          1,48 KB └── @types
--a---          1,48 KB     └── index.d.ts
-

package/tsconfig.json

@@ -1,32 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "rootDir": "./",
-        "strict": true,
-        "moduleResolution": "node",
-        "importHelpers": true,
-        "experimentalDecorators": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "allowSyntheticDefaultImports": true,
-        "allowJs": true,
-        "checkJs": false,
-        "resolveJsonModule": true,
-        "forceConsistentCasingInFileNames": true,
-        "removeComments": true,
-        "typeRoots": [
-            "node_modules/@types",
-            "./core/@types"
-        ],
-        "sourceMap": false,
-        "baseUrl": "./"
-    },
-    "include": [
-        "./**/*.ts"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ],
-}