@yipe/dice 0.7.0 → 0.8.0

package/dist/builder/index.js

@@ -3501,6 +3501,17 @@ var RollBuilder = class _RollBuilder {
   getSubRollConfigs() {
     return this.subRollConfigs.map((c) => ({ ...c }));
   }
+  /**
+   * A cheap, stable string that FULLY identifies this builder's PMF — used by {@link AttackBuilder.toPMF}
+   * to cache resolved attack PMFs across rebuilds without walking the AST via {@link toExpression}. A plain
+   * roll is fully determined by its {@link RollConfig} array (count/sides/modifier/reroll/explode/minimum/
+   * bestOf/keep/rollType/isSubtraction), so serializing that is sound. Subclasses whose PMF depends on
+   * hidden state NOT captured by `subRollConfigs` (half/scale/max/parsed/pooled/composite transforms) return
+   * `null` to opt OUT of caching — a conservative miss is always safe; a wrong key would corrupt DPR.
+   */
+  cacheKey() {
+    return JSON.stringify(this.subRollConfigs);
+  }
   // for testing
   static fromConfig(config) {
     return new _RollBuilder([{ ...defaultConfig, ...config }]);
@@ -4009,6 +4020,9 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   // No need to override create if we don't expose RollBuilder methods that use it,
   // but HalfRollBuilder extends RollBuilder so it does.
   // However, HalfRollBuilder seems to just wrap another roll.
@@ -4053,6 +4067,9 @@ var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -4097,6 +4114,9 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   hasHiddenState() {
     return this.innerRoll.hasHiddenState();
   }
+  cacheKey() {
+    return null;
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -4174,6 +4194,10 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
   get critThreshold() {
     return this.attackConfig.critThreshold;
   }
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `H|${this.attackConfig.critThreshold}|${base}`;
+  }
   // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?
   critOn(critThreshold) {
     const newConfig = { critThreshold };
@@ -4224,6 +4248,10 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
   get critThreshold() {
     return this.attackConfig.critThreshold;
   }
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `C|${this.fromAlwaysHit ? 1 : 0}|${this.attackConfig.critThreshold}|${this.attackConfig.ac ?? ""}|${base}`;
+  }
   critOn(critThreshold) {
     const newConfig = { critThreshold, ac: this.attackConfig.ac };
     return new _AlwaysCritBuilder(this, newConfig, this.fromAlwaysHit);
@@ -4254,6 +4282,9 @@ var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   create(configs) {
     return new RollBuilder(configs);
   }
@@ -4289,6 +4320,9 @@ var PooledRollBuilder = class _PooledRollBuilder extends RollBuilder {
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   d(_sides) {
     throw new Error("Cannot add dice to a pooled roll. The pool is finalized.");
   }
@@ -4392,6 +4426,9 @@ var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder
   hasHiddenState() {
     return true;
   }
+  cacheKey() {
+    return null;
+  }
   getSubRollConfigs() {
     return [];
   }
@@ -4944,6 +4981,10 @@ function getASTSignature(node) {
 }
 
 // src/builder/attack.ts
+var attackPMFCache = new LRUCache(4e3);
+function clearAttackCache() {
+  attackPMFCache.clear();
+}
 var AttackBuilder = class _AttackBuilder {
   constructor(check, hitEffect, critEffect, missEffect) {
     this.check = check;
@@ -5122,9 +5163,46 @@ var AttackBuilder = class _AttackBuilder {
       weights: { hit: phit, crit: pcrit, miss: pmiss }
     };
   }
-  // By default, create PMF with no pruning
+  /**
+   * A cheap, complete key for this attack's resolved PMF, or `null` when it can't be cached soundly (an
+   * effect whose PMF isn't captured by its {@link RollConfig}s — see {@link RollBuilder.cacheKey}). Composed
+   * from the check + hit/crit/miss effect keys + `eps`. `critEffect === null` (noCrit) and `undefined`
+   * (auto-double the hit dice) are distinct crit states, encoded separately.
+   */
+  cacheKey(eps) {
+    const checkKey = this.check.cacheKey();
+    if (checkKey === null) return null;
+    let hitKey = "";
+    if (this.hitEffect) {
+      const k = this.hitEffect.cacheKey();
+      if (k === null) return null;
+      hitKey = k;
+    }
+    let critKey;
+    if (this.critEffect === null) critKey = "n";
+    else if (this.critEffect === void 0) critKey = "a";
+    else {
+      const k = this.critEffect.cacheKey();
+      if (k === null) return null;
+      critKey = k;
+    }
+    let missKey = "";
+    if (this.missEffect) {
+      const k = this.missEffect.cacheKey();
+      if (k === null) return null;
+      missKey = k;
+    }
+    return `${checkKey}*H${hitKey}*C${critKey}*M${missKey}*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 = attackPMFCache.get(key);
+    if (cached) return cached;
+    const pmf = this.resolve(eps).pmf;
+    attackPMFCache.set(key, pmf);
+    return pmf;
   }
   get pmf() {
     return this.toPMF();
@@ -5152,6 +5230,10 @@ var ACBuilder = class _ACBuilder extends RollBuilder {
   get critThreshold() {
     return this.attackConfig.critThreshold;
   }
+  cacheKey() {
+    const base = super.cacheKey();
+    return base === null ? null : `A|${this.attackConfig.ac}|${this.attackConfig.critThreshold}|${base}`;
+  }
   // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?
   critOn(threshold) {
     const newConfig = {
@@ -5356,6 +5438,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, 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, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map