@yipe/dice 0.2.20 → 0.2.22

package/dist/builder/index.js

@@ -2420,7 +2420,9 @@ var Dice = class _Dice {
     if (key === "hit") {
       this.ensureHitDistribution();
     }
-    return this.outcomeData[key];
+    const distribution = this.outcomeData[key];
+    if (distribution === void 0) return void 0;
+    return { ...distribution };
   }
   getFullOutcomeDistribution() {
     return { ...this.outcomeData };
@@ -3338,9 +3340,15 @@ var RollBuilder = class _RollBuilder {
       this.subRollConfigs = countOrConfigs.map((c) => ({ ...c }));
     }
   }
+  create(configs) {
+    return new _RollBuilder(configs);
+  }
   get lastConfig() {
     return this.subRollConfigs[this.subRollConfigs.length - 1];
   }
+  hasHiddenState() {
+    return false;
+  }
   getSubRollConfigs() {
     return this.subRollConfigs.map((c) => ({ ...c }));
   }
@@ -3374,6 +3382,11 @@ var RollBuilder = class _RollBuilder {
       }
       if (isNaN(count)) throw new Error("Invalid NaN value for count argument");
       if (sidesOrDie instanceof _RollBuilder) {
+        if (sidesOrDie.hasHiddenState()) {
+          throw new Error(
+            "Cannot use a roll with hidden state (like a pooled roll) as a die type."
+          );
+        }
         const subRollConfigs = sidesOrDie.getSubRollConfigs();
         if (subRollConfigs.length === 0) {
           const result = new _RollBuilder(0);
@@ -3414,12 +3427,17 @@ var RollBuilder = class _RollBuilder {
     if (sides === 0) return this;
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].sides = sides;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   plus(modOrRoll, die) {
     if (typeof modOrRoll === "number" && isNaN(modOrRoll))
       throw new Error("Invalid NaN value for modOrRoll");
     if (die instanceof _RollBuilder && typeof modOrRoll === "number") {
+      if (die.hasHiddenState()) {
+        throw new Error(
+          "Cannot use a roll with hidden state (like a pooled roll) as a die type."
+        );
+      }
       const count = modOrRoll;
       const subRollConfigs = die.getSubRollConfigs();
       if (subRollConfigs.length === 0) return this;
@@ -3444,7 +3462,7 @@ var RollBuilder = class _RollBuilder {
       if (modOrRoll === 0) return this;
       const newConfigs = this.getSubRollConfigs();
       newConfigs[newConfigs.length - 1].modifier += modOrRoll;
-      return new this.constructor(newConfigs);
+      return this.create(newConfigs);
     }
     return this.add(modOrRoll);
   }
@@ -3462,7 +3480,7 @@ var RollBuilder = class _RollBuilder {
     if (value === this.lastConfig.reroll) return this;
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].reroll = value;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   /** Set finite explode count for max-face explosions (Infinity allowed). */
   explode(count = Infinity) {
@@ -3473,7 +3491,7 @@ var RollBuilder = class _RollBuilder {
     if (count < 0) throw new Error("Explode count must be >= 0");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].explode = count;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   /** Apply per-die minimum value (min > 0). */
   minimum(val) {
@@ -3484,7 +3502,7 @@ var RollBuilder = class _RollBuilder {
     if (val < 0) throw new Error("Minimum value must be >= 0");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].minimum = val + 1;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   bestOf(count) {
     if (count !== void 0 && isNaN(count))
@@ -3493,40 +3511,83 @@ var RollBuilder = class _RollBuilder {
     if (count <= 0) throw new Error("Best of count must be > 0");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].bestOf = count;
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   keepHighest(total, count) {
     if (isNaN(total) || isNaN(count))
       throw new Error("Invalid NaN value for keepHighest");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].keep = { total, count, mode: "highest" };
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   keepLowest(total, count) {
     if (isNaN(total) || isNaN(count))
       throw new Error("Invalid NaN value for keepLowest");
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].keep = { total, count, mode: "lowest" };
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
+  }
+  keepHighestAll(total, count) {
+    if (isNaN(total) || isNaN(count))
+      throw new Error("Invalid NaN value for keepHighestAll");
+    const currentAST = this.toAST();
+    const trialPool = {
+      type: "sum",
+      count: total,
+      child: currentAST
+    };
+    const keepNode = {
+      type: "keep",
+      mode: "highest",
+      count,
+      child: trialPool
+    };
+    const currentExpr = this.toExpression();
+    const expression = `${total}kh${count}(${currentExpr})`;
+    return new PooledRollBuilder(keepNode, expression);
+  }
+  keepLowestAll(total, count) {
+    if (isNaN(total) || isNaN(count))
+      throw new Error("Invalid NaN value for keepLowestAll");
+    const currentAST = this.toAST();
+    const trialPool = {
+      type: "sum",
+      count: total,
+      child: currentAST
+    };
+    const keepNode = {
+      type: "keep",
+      mode: "lowest",
+      count,
+      child: trialPool
+    };
+    const currentExpr = this.toExpression();
+    const expression = `${total}kl${count}(${currentExpr})`;
+    return new PooledRollBuilder(keepNode, expression);
   }
   withAdvantage() {
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].rollType = "advantage";
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   withDisadvantage() {
     const configs = this.getSubRollConfigs();
     configs[configs.length - 1].rollType = "disadvantage";
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   add(anotherRoll) {
     if (anotherRoll === void 0) return this;
+    if (anotherRoll.hasHiddenState()) {
+      throw new Error(
+        "Cannot add a roll with hidden state (like a pooled roll) to a standard roll. Try adding the standard roll to the pooled roll instead: pool.plus(roll)."
+      );
+    }
     const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   withBonus(anotherRoll) {
     const configs = [...this.subRollConfigs, ...anotherRoll.subRollConfigs];
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   addRoll(count = 1) {
     if (isNaN(count)) throw new Error("Invalid NaN value for count");
@@ -3538,7 +3599,7 @@ var RollBuilder = class _RollBuilder {
         isSubtraction: count < 0
       }
     ];
-    return new this.constructor(configs);
+    return this.create(configs);
   }
   scaleDice(scale) {
     const scaleInt = Math.floor(scale);
@@ -3548,7 +3609,7 @@ var RollBuilder = class _RollBuilder {
       if (!config.sides || config.sides <= 0) return config;
       return { ...config, count: config.count * scaleInt };
     });
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   doubleDice() {
     return this.scaleDice(2);
@@ -3560,12 +3621,12 @@ var RollBuilder = class _RollBuilder {
     return new AlwaysCritBuilder(this);
   }
   copy() {
-    return new this.constructor(this.getSubRollConfigs());
+    return this.create(this.getSubRollConfigs());
   }
   withElvenAccuracy() {
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].rollType = "elven accuracy";
-    return new this.constructor(newConfigs);
+    return this.create(newConfigs);
   }
   toExpression() {
     const originalDiceConfigs = this.subRollConfigs.filter(
@@ -3773,12 +3834,33 @@ var RollBuilder = class _RollBuilder {
   maxOf(count) {
     return new MaxOfRollBuilder(this, count);
   }
+  // These methods are implemented via prototype augmentation in ac.ts and dc.ts
+  // They are declared here to provide proper TypeScript types
+  ac(targetAC) {
+    throw new Error("ac() should be implemented via prototype augmentation");
+  }
+  dc(saveDC) {
+    throw new Error("dc() should be implemented via prototype augmentation");
+  }
 };
 var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
   constructor(innerRoll) {
     super(0);
     this.innerRoll = innerRoll;
   }
+  hasHiddenState() {
+    return this.innerRoll.hasHiddenState();
+  }
+  // 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.
+  // If we call .plus() on HalfRollBuilder, it returns a HalfRollBuilder?
+  // No, RollBuilder.plus returns RollBuilder.
+  // The inheritance here is a bit tricky.
+  // Existing code for HalfRollBuilder doesn't seem to implement plus/etc.
+  // So .plus() on a HalfRollBuilder would return a RollBuilder (base class).
+  // Which is fine.
+  // The only issue is if we want it to return HalfRollBuilder, but it doesn't seem designed for that.
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -3810,6 +3892,9 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
     this.diceCount = diceCount;
     this.diceSides = diceSides;
   }
+  hasHiddenState() {
+    return this.innerRoll.hasHiddenState();
+  }
   get lastConfig() {
     return this.innerRoll.lastConfig;
   }
@@ -3865,6 +3950,11 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
 };
 var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
   constructor(baseRoll, attackConfig) {
+    if (baseRoll.hasHiddenState()) {
+      throw new Error(
+        "Cannot create AlwaysHitBuilder from a roll with hidden state."
+      );
+    }
     super(baseRoll.getSubRollConfigs());
     __publicField(this, "attackConfig");
     if (attackConfig) {
@@ -3873,6 +3963,9 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
       this.attackConfig = { critThreshold: 20 };
     }
   }
+  create(configs) {
+    return new RollBuilder(configs);
+  }
   onHit(...args) {
     const damageRoll = RollBuilder.fromArgs(...args);
     return new AttackBuilder(this, damageRoll);
@@ -3907,6 +4000,11 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
 };
 var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
   constructor(baseRoll, attackConfig, fromAlwaysHit = false) {
+    if (baseRoll.hasHiddenState()) {
+      throw new Error(
+        "Cannot create AlwaysCritBuilder from a roll with hidden state."
+      );
+    }
     super(baseRoll.getSubRollConfigs());
     __publicField(this, "attackConfig");
     __publicField(this, "fromAlwaysHit");
@@ -3917,6 +4015,9 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
     }
     this.fromAlwaysHit = fromAlwaysHit || baseRoll instanceof AlwaysHitBuilder;
   }
+  create(configs) {
+    return new RollBuilder(configs);
+  }
   onHit(...args) {
     const damageRoll = RollBuilder.fromArgs(...args);
     return new AttackBuilder(this, damageRoll);
@@ -3953,7 +4054,13 @@ var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
     this.originalExpression = expression;
     this.cachedPMF = parse(expression, 0);
   }
-  toPMF(eps = 0) {
+  hasHiddenState() {
+    return true;
+  }
+  create(configs) {
+    return new RollBuilder(configs);
+  }
+  toPMF(_eps = 0) {
     return this.cachedPMF;
   }
   toExpression() {
@@ -3973,10 +4080,122 @@ var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
     );
   }
 };
+var PooledRollBuilder = class _PooledRollBuilder extends RollBuilder {
+  constructor(baseAST, baseExpression, configs = []) {
+    super(configs.length > 0 ? configs : 0);
+    this.baseAST = baseAST;
+    this.baseExpression = baseExpression;
+  }
+  create(configs) {
+    return new _PooledRollBuilder(this.baseAST, this.baseExpression, configs);
+  }
+  hasHiddenState() {
+    return true;
+  }
+  d(_sides) {
+    throw new Error("Cannot add dice to a pooled roll. The pool is finalized.");
+  }
+  reroll(_value) {
+    throw new Error("Cannot set reroll on a pooled roll.");
+  }
+  explode(_count = Infinity) {
+    throw new Error("Cannot set explode on a pooled roll.");
+  }
+  minimum(_val) {
+    throw new Error("Cannot set minimum on a pooled roll.");
+  }
+  bestOf(_count) {
+    throw new Error("Cannot set bestOf on a pooled roll.");
+  }
+  keepHighest(_total, _count) {
+    throw new Error(
+      "Cannot use keepHighest on a pooled roll. Use keepHighestAll again if you want nested pooling."
+    );
+  }
+  keepLowest(_total, _count) {
+    throw new Error(
+      "Cannot use keepLowest on a pooled roll. Use keepLowestAll again if you want nested pooling."
+    );
+  }
+  withAdvantage() {
+    throw new Error("Cannot set advantage on a pooled roll.");
+  }
+  withDisadvantage() {
+    throw new Error("Cannot set disadvantage on a pooled roll.");
+  }
+  withElvenAccuracy() {
+    throw new Error("Cannot set elven accuracy on a pooled roll.");
+  }
+  toAST() {
+    const configsAST = super.toAST();
+    const isZero = configsAST.type === "constant" && configsAST.value === 0;
+    if (isZero) {
+      return this.baseAST;
+    }
+    const children = [
+      { node: this.baseAST, sign: 1 },
+      { node: configsAST, sign: 1 }
+    ];
+    return { type: "add", children };
+  }
+  toExpression() {
+    const configsExpression = super.toExpression();
+    if (configsExpression === "0") {
+      return this.baseExpression;
+    }
+    if (configsExpression.startsWith("-")) {
+      return `${this.baseExpression} - ${configsExpression.substring(1)}`;
+    }
+    return `${this.baseExpression} + ${configsExpression}`;
+  }
+  copy() {
+    return new _PooledRollBuilder(
+      this.baseAST,
+      this.baseExpression,
+      this.getSubRollConfigs()
+    );
+  }
+  scaleDice(scale) {
+    const scaleInt = Math.floor(scale);
+    if (scaleInt !== scale) throw new Error("Scale must be an integer");
+    if (scaleInt <= 0) throw new Error("Scale must be > 0");
+    const newBaseAST = {
+      type: "sum",
+      count: scaleInt,
+      child: this.baseAST
+    };
+    const newBaseExpr = scaleInt === 1 ? this.baseExpression : `${scaleInt}(${this.baseExpression})`;
+    return new _PooledRollBuilder(
+      newBaseAST,
+      newBaseExpr,
+      this.getSubRollConfigs()
+    );
+  }
+  times(count) {
+    if (isNaN(count)) throw new Error("Invalid NaN value for times");
+    if (Math.floor(count) !== count)
+      throw new Error("times() requires an integer");
+    if (count < 0) throw new Error("times() requires a non-negative integer");
+    const currentAST = this.toAST();
+    const currentExpr = this.toExpression();
+    const sumNode = {
+      type: "sum",
+      count,
+      child: currentAST
+    };
+    const newExpr = count === 1 ? currentExpr : `${count}(${currentExpr})`;
+    return new _PooledRollBuilder(sumNode, newExpr);
+  }
+};
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
   if (sidesOrDie instanceof RollBuilder) {
+    if (sidesOrDie.hasHiddenState()) {
+      throw new Error(
+        "Cannot use a roll with hidden state (like a pooled roll) as a die type."
+      );
+    }
     const subRollConfigs = sidesOrDie.getSubRollConfigs();
     if (subRollConfigs.length === 0) return new RollBuilder(0).plus(modifier);
     const absCount = Math.abs(count);
@@ -3999,7 +4218,12 @@ var rollFn = (count, sidesOrDie, modifier) => {
     return builder.plus(modifier);
   }
 };
-rollFn.d = (sides) => new RollBuilder(1).d(sides);
+rollFn.d = (sides) => {
+  if (typeof sides === "string") {
+    return RollBuilder.fromArgs(sides);
+  }
+  return new RollBuilder(1).d(sides);
+};
 rollFn.hd20 = () => new RollBuilder(1).d20().reroll(1);
 rollFn.d4 = () => new RollBuilder(1).d4();
 rollFn.d6 = () => new RollBuilder(1).d6();
@@ -4010,6 +4234,9 @@ rollFn.d20 = () => new RollBuilder(1).d20();
 rollFn.d100 = () => new RollBuilder(1).d100();
 rollFn.flat = (n) => new RollBuilder(0).plus(n);
 function d(sides) {
+  if (typeof sides === "string") {
+    return RollBuilder.fromArgs(sides);
+  }
   return new RollBuilder(1).d(sides);
 }
 var d4 = new RollBuilder(1).d4();
@@ -4878,6 +5105,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map