@yipe/dice 0.8.0 → 0.8.1

package/dist/builder/index.js

@@ -3452,6 +3452,10 @@ function d20PMF(rerollOne) {
 }
 
 // src/builder/roll.ts
+var rollPMFCache = new LRUCache(4e3);
+function clearRollCache() {
+  rollPMFCache.clear();
+}
 var defaultConfig = {
   count: 1,
   sides: 0,
@@ -3864,8 +3868,16 @@ var RollBuilder = class _RollBuilder {
     }
     return result.replace(/\+ -/g, "-");
   }
+  // Main AST entry point. Cached by the cheap config key across identical rebuilds; see `rollPMFCache`.
   toPMF(eps = 0) {
-    return pmfFromRollBuilder(this, eps);
+    const key = this.cacheKey();
+    if (key === null) return pmfFromRollBuilder(this, eps);
+    const fullKey = `${key}*e${eps}`;
+    const cached = rollPMFCache.get(fullKey);
+    if (cached) return cached;
+    const pmf = pmfFromRollBuilder(this, eps);
+    rollPMFCache.set(fullKey, pmf);
+    return pmf;
   }
   get pmf() {
     return this.toPMF();
@@ -5294,6 +5306,10 @@ RollBuilder.prototype.ac = function(targetAC) {
 };
 
 // src/builder/save.ts
+var savePMFCache = new LRUCache(4e3);
+function clearSaveCache() {
+  savePMFCache.clear();
+}
 var SaveBuilder = class _SaveBuilder {
   constructor(check, failureEffect, saveOutcome = "normal") {
     this.check = check;
@@ -5330,9 +5346,32 @@ var SaveBuilder = class _SaveBuilder {
       weights: { success: psuccess, fail: pfail }
     };
   }
-  // By default, create PMF with no pruning
+  /**
+   * A cheap, complete key for this save's resolved PMF, or `null` when it can't be cached soundly.
+   * {@link resolve} reads exactly three things: the DC check (via `resolveProbabilities`), the failure
+   * effect's PMF, and the save outcome — so composing their keys pins it. A `ParsedRollBuilder` failure
+   * effect returns `null`, which correctly forces this uncached.
+   */
+  cacheKey(eps) {
+    const checkKey = this.check.cacheKey();
+    if (checkKey === null) return null;
+    let failKey = "";
+    if (this.failureEffect) {
+      const k = this.failureEffect.cacheKey();
+      if (k === null) return null;
+      failKey = k;
+    }
+    return `${checkKey}*F${failKey}*O${this.saveOutcome}*e${eps}`;
+  }
+  // By default, create PMF with no pruning. Cached by the cheap config key across identical rebuilds.
   toPMF(eps = 0) {
-    return this.resolve(eps).pmf;
+    const key = this.cacheKey(eps);
+    if (key === null) return this.resolve(eps).pmf;
+    const cached = savePMFCache.get(key);
+    if (cached) return cached;
+    const pmf = this.resolve(eps).pmf;
+    savePMFCache.set(key, pmf);
+    return pmf;
   }
   get pmf() {
     return this.toPMF();
@@ -5368,6 +5407,10 @@ function resolveProbabilities(check) {
 }
 
 // src/builder/dc.ts
+var dcPMFCache = new LRUCache(4e3);
+function clearDCCache() {
+  dcPMFCache.clear();
+}
 var DCBuilder = class _DCBuilder extends RollBuilder {
   constructor(baseRoll, saveConfig) {
     super(baseRoll.getSubRollConfigs());
@@ -5408,7 +5451,22 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
     const expression = new RollBuilder(allConfigs).toExpression();
     return `(${expression} DC ${this.saveConfig.dc})`;
   }
+  /**
+   * The DC check's PMF is fully determined by the save DC plus everything `toPMF` below reads off the roll
+   * configs (`rollType`, `baseReroll`, `modifier`, bonus dice) — all of which `super.cacheKey()` already
+   * serializes. So extend the base key with the DC, mirroring {@link AlwaysHitBuilder.cacheKey}.
+   */
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `DC|${this.saveConfig.dc}|${base}`;
+  }
   toPMF(eps = 0) {
+    const key = this.cacheKey();
+    const fullKey = key === null ? null : `${key}*e${eps}`;
+    if (fullKey !== null) {
+      const cached = dcPMFCache.get(fullKey);
+      if (cached) return cached;
+    }
     const saveDC = this.saveDC;
     const rollType = this.rollType;
     const rerollOne = this.baseReroll > 0;
@@ -5430,7 +5488,9 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
       [0, psuccess > 0 ? psuccess : 0],
       [1, pfail > 0 ? pfail : 0]
     ]);
-    return PMF.fromMap(m, eps);
+    const pmf = PMF.fromMap(m, eps);
+    if (fullKey !== null) dcPMFCache.set(fullKey, pmf);
+    return pmf;
   }
 };
 RollBuilder.prototype.dc = function(saveDC) {
@@ -5438,6 +5498,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, ScaleRollBuilder, builderPMFCache, clearAttackCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, ScaleRollBuilder, builderPMFCache, clearAttackCache, clearDCCache, clearRollCache, clearSaveCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map