@yipe/dice 0.1.0 → 0.1.2

package/README.md

@@ -1,15 +1,23 @@
-<!-- [![npm version](https://img.shields.io/npm/v/@dpr/dice.svg)](https://www.npmjs.com/package/@dpr/dice)
-[![Build Status](https://github.com/yipe/dpr/actions/workflows/ci.yml/badge.svg)](https://github.com/yipe/dpr/actions)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) -->
+[![npm version](https://img.shields.io/npm/v/@yipe/dice.svg)](https://www.npmjs.com/package/@yipe/dice)
+[![License: MIT](https://img.shields.io/badge/License-MIT-007ec6.svg)](LICENSE)
+![TypeScript](https://img.shields.io/badge/TypeScript-Ready-3178c6?logo=typescript)
+![Size](https://img.shields.io/bundlephobia/minzip/@yipe/dice?logo=npm&logoColor=fff&label=Size)
+![Dice](https://dprcalc.com/api/roll.svg)
 
-# 🎲 @dpr/dice
+![Last Commit](https://img.shields.io/github/last-commit/yipe/dice?logo=github)
+![Dependencies](https://img.shields.io/librariesio/release/npm/@yipe/dice?logo=npm)
+[![GitHub issues](https://img.shields.io/github/issues/yipe/dice.svg?logo=github)](https://github.com/yipe/dice/issues)
+[![Build Status](https://github.com/yipe/dice/actions/workflows/ci.yml/badge.svg)](https://github.com/yipe/dice/actions)
+[![Tests](https://img.shields.io/badge/tests-passing-4c1.svg?logo=vitest&logoColor=white)](https://github.com/yipe/dice/actions/workflows/ci.yml)
+
+# 🎲 @yipe/dice
 
 A TypeScript library for **D&D 5e damage-per-round (DPR) calculations**, designed for players, Dungeon Masters, and developers who want to analyze combat mathematically.
 
 This library powers [dprcalc.com](https://dprcalc.com) and provides a precise, composable way to model dice rolls, attacks, and outcomes with probability mass functions (PMFs) — not just averages. This allows for rich charting and statistics with full outcome attribution.
 
 ```ts
-import { parse } from "@dpr/dice";
+import { parse } from "@yipe/dice";
 
 const attack = parse("(d20 + 8 AC 16) * (1d8 + 4) crit (2d8 + 4)");
 console.log("DPR:", attack.mean());
@@ -29,9 +37,9 @@ console.log("DPR:", attack.mean());
 
 ```bash
 # Install with npm or yarn
-npm install @dpr/dice
+npm install @yipe/dice
 # or
-yarn add @dpr/dice
+yarn add @yipe/dice
 ```
 
 ## 📦 Core Concepts
@@ -48,7 +56,7 @@ yarn add @dpr/dice
 Here's a simple example of calculating damage for a basic attack:
 
 ```ts
-import { parse, DiceQuery } from "@dpr/dice";
+import { parse, DiceQuery } from "@yipe/dice";
 
 const query = parse("(d20 + 8 AC 16) * (1d4 + 4) crit (2d4 + 4)").toQuery();
 
@@ -70,7 +78,7 @@ DPR: 4.35
 Conditional damage ("once-per-turn damage riders") like Sneak Attack can be modeled easily:
 
 ```ts
-import { parse, DiceQuery } from "@dpr/dice";
+import { parse, DiceQuery } from "@yipe/dice";
 
 function damageRiderExample() {
   const attack = parse("(d20 + 8 AC 16) * (1d4 + 4) crit (2d4 + 4)");
@@ -107,7 +115,7 @@ function damageRiderExample() {
 You can generate full statistical distributions for visualization or reporting.
 
 ```ts
-import { parse, DiceQuery } from "@dpr/dice";
+import { parse, DiceQuery } from "@yipe/dice";
 
 const query2 = parse("(d20 + 8 AC 16) * (1d4 + 4) crit (2d4 + 4)").toQuery();
 console.table(query2.toChartSeries());
@@ -227,7 +235,6 @@ Here is the basic example:
 
 ## 🧱 Roadmap
 
-- [ ] **Publish** to npm as `@dpr/dice`
 - [ ] Create a **web playground** with live examples
 - [ ] Consider creating higher-level APIs: `Turn`, `Attack`, `DamageRider`
 - [ ] Simplify and improve PMF and Query interface ergonomics

package/dist/index.cjs

@@ -1,10 +1,14 @@
 'use strict';
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
 // src/lru-cache.ts
 var LRUCache = class {
   constructor(maxSize = 1e3) {
     this.maxSize = maxSize;
-    this.cache = /* @__PURE__ */ new Map();
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
   }
   get(key) {
     const value = this.cache.get(key);
@@ -43,12 +47,13 @@ var LRUCache = class {
 };
 
 // src/types.ts
-var COMPUTATIONAL_EPS = 1e-40;
-var TEST_EPS = 1e-10;
+var EPS = 1e-12;
 
 // src/query.ts
 var _DiceQuery = class _DiceQuery {
   constructor(singles, combined) {
+    __publicField(this, "singles");
+    __publicField(this, "combined");
     this.singles = Array.isArray(singles) ? singles : [singles];
     const c = combined ?? PMF.convolveMany(this.singles);
     this.combined = Math.abs(c.mass() - 1) <= 1e-12 ? c : c.normalize();
@@ -995,7 +1000,7 @@ var _DiceQuery = class _DiceQuery {
   outcomeTotals(outcomes = this.outcomeKeys()) {
     const totals = /* @__PURE__ */ new Map();
     outcomes.forEach((o) => totals.set(o, 0));
-    for (const [x, row] of this.combined.map) {
+    for (const [, row] of this.combined.map) {
       for (const o of outcomes) {
         const p = row.count[o] || 0;
         totals.set(o, (totals.get(o) || 0) + p);
@@ -1210,7 +1215,7 @@ var _DiceQuery = class _DiceQuery {
    * const bonusAttack = parse("(d20 + 3 AC 15) * (1d6 + 1)");
    * const bothAttacks = mainAttack.convolve(bonusAttack);
    */
-  convolve(other, eps) {
+  convolve(other) {
     const singles = [...this.singles, ...other.singles];
     return new _DiceQuery(singles);
   }
@@ -1223,7 +1228,7 @@ var _DiceQuery = class _DiceQuery {
    *
    * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]
    */
-  firstSuccessSplit(successOutcome, subsetOutcome, eps = COMPUTATIONAL_EPS) {
+  firstSuccessSplit(successOutcome, subsetOutcome, eps = EPS) {
     const pmfs = this.singles;
     if (!pmfs.length) {
       throw new Error("firstSuccessSplitFromPMFs: pmfs must be non-empty");
@@ -1266,33 +1271,40 @@ var _DiceQuery = class _DiceQuery {
     return [a, b, any, none];
   }
 };
-_DiceQuery.DEFAULT_OUTCOMES = [
+__publicField(_DiceQuery, "DEFAULT_OUTCOMES", [
   "hit",
   "crit",
   "missNone"
-];
+]);
 var DiceQuery = _DiceQuery;
-var EPSILON = COMPUTATIONAL_EPS;
 var pmfCache = new LRUCache(1e3);
 var _PMF = class _PMF {
-  constructor(map = /* @__PURE__ */ new Map(), epsilon = EPSILON, normalized = false, identifier = `anon#${_PMF.__anonIdCounter++}`, _preservedProvidence = true) {
+  constructor(map = /* @__PURE__ */ new Map(), epsilon = EPS, normalized = false, identifier = `anon#${_PMF.__anonIdCounter++}`, _preservedProvidence = true) {
     this.map = map;
     this.epsilon = epsilon;
     this.normalized = normalized;
     this.identifier = identifier;
     this._preservedProvidence = _preservedProvidence;
-  }
-  static empty(epsilon = EPSILON, identifier = "empty") {
+    // Cached computed values
+    __publicField(this, "_support");
+    __publicField(this, "_min");
+    __publicField(this, "_max");
+    __publicField(this, "_totalMass");
+    __publicField(this, "_mean");
+    __publicField(this, "_variance");
+    __publicField(this, "_stdev");
+  }
+  static empty(epsilon = EPS, identifier = "empty") {
     return new _PMF(/* @__PURE__ */ new Map(), epsilon, false, identifier);
   }
   // This has a single bin at value 0, mass of 1
-  static zero(epsilon = EPSILON) {
+  static zero(epsilon = EPS) {
     const m = /* @__PURE__ */ new Map();
     m.set(0, { p: 1, count: { miss: 1 }, attr: {} });
     return new _PMF(m, epsilon, false, "zero");
   }
   // This creates a single bin at value 0, but with weight 0.
-  static emptyMass(epsilon = EPSILON) {
+  static emptyMass() {
     return _PMF.zero().scaleMass(0);
   }
   //  Makes PMF iterable over [damage, bin] pairs.
@@ -1458,6 +1470,12 @@ var _PMF = class _PMF {
   preservedProvidence() {
     return this._preservedProvidence;
   }
+  getPowerCacheKey(n, eps) {
+    const id = this.identifier;
+    let key = `${id}`;
+    for (let i = 1; i < n; i++) key += `+${id}`;
+    return `${key}@${eps}`;
+  }
   /**
    * Efficiently computes this PMF convolved with itself `n` times.
    * Uses exponentiation by squaring to reduce total convolutions.
@@ -1474,7 +1492,7 @@ var _PMF = class _PMF {
     }
     if (n === 1) return this;
     const epsilon = eps ?? this.epsilon;
-    const key = getPowerCacheKey(this, n, epsilon);
+    const key = this.getPowerCacheKey(n, epsilon);
     {
       const cached = pmfCache?.get(key);
       if (cached) return cached;
@@ -1500,7 +1518,7 @@ var _PMF = class _PMF {
   /*
    * Helper for chaining multiple identical attacks
    */
-  replicate(n, eps = this.epsilon) {
+  replicate(n) {
     if (!Number.isInteger(n) || n <= 0) {
       throw new Error("combineN(n): n must be a positive integer");
     }
@@ -1873,7 +1891,7 @@ var _PMF = class _PMF {
    * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)
    * - Order-independent cache keys work better with consistent build patterns
    */
-  static convolveMany(pmfList, eps = EPSILON) {
+  static convolveMany(pmfList, eps = EPS) {
     if (pmfList.length === 0) return _PMF.empty(eps);
     if (pmfList.length === 1) return pmfList[0];
     return _PMF.reduceConvolveLeft(pmfList, eps);
@@ -1888,7 +1906,7 @@ var _PMF = class _PMF {
   static fromJSON(jsonData) {
     return new _PMF(
       new Map(jsonData.bins),
-      EPSILON,
+      EPS,
       !!jsonData.normalized,
       jsonData.identifier || "fromJSON"
     );
@@ -2098,22 +2116,17 @@ var _PMF = class _PMF {
   }
 };
 // Unique ID generator for anonymous PMFs to avoid cache key collisions
-_PMF.__anonIdCounter = 1;
+__publicField(_PMF, "__anonIdCounter", 1);
 var PMF = _PMF;
-function getPowerCacheKey(base, n, eps) {
-  const id = base.identifier;
-  let key = `${id}`;
-  for (let i = 1; i < n; i++) key += `+${id}`;
-  return `${key}@${eps}`;
-}
 
 // src/dice.ts
 var Dice = class _Dice {
   constructor(x = 0) {
-    this.faces = {};
-    this.privateData = {};
-    this.outcomeData = {};
-    this.hasHitDistributionCalculated = false;
+    __publicField(this, "faces", {});
+    __publicField(this, "privateData", {});
+    __publicField(this, "outcomeData", {});
+    __publicField(this, "hasHitDistributionCalculated", false);
+    __publicField(this, "identifier");
     if (x <= 0) return;
     for (let i = 1; i <= x; i++) {
       this.faces[i] = 1;
@@ -2420,7 +2433,7 @@ var Dice = class _Dice {
    * Convert dice to PMF using OutcomeType labels directly from damage distribution.
    * This is much cleaner than the original complex distribution conversion.
    */
-  toPMF(numEpsilon = COMPUTATIONAL_EPS) {
+  toPMF(numEpsilon = EPS) {
     const total = this.total();
     if (total === 0) return PMF.empty(numEpsilon);
     this.ensureHitDistribution();
@@ -2782,20 +2795,12 @@ function parseArgumentInternal(s, n) {
     case "k":
       assertToken(s, "k");
       return parseKeep(s, n);
-    case "0":
-    case "1":
-    case "2":
-    case "3":
-    case "4":
-    case "5":
-    case "6":
-    case "7":
-    case "8":
-    case "9":
     case "n":
       return parseNumber(s, n);
+    default:
+      if (isDigit(c)) return parseNumber(s, n);
+      return;
   }
-  return;
 }
 function parseBinaryArgument(arg, arr, n) {
   if (arr.length >= 4 && arr[0] === "h" && peek(arr, "half")) {
@@ -2941,16 +2946,15 @@ function parseOperation(s) {
   return;
 }
 
-exports.COMPUTATIONAL_EPS = COMPUTATIONAL_EPS;
 exports.Dice = Dice;
 exports.DiceQuery = DiceQuery;
+exports.EPS = EPS;
 exports.LRUCache = LRUCache;
 exports.PMF = PMF;
-exports.TEST_EPS = TEST_EPS;
 exports.clearParserCache = clearParserCache;
 exports.getCachingEnabled = getCachingEnabled;
-exports.getPowerCacheKey = getPowerCacheKey;
 exports.parse = parse;
+exports.pmfCache = pmfCache;
 exports.setCachingEnabled = setCachingEnabled;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map