@yipe/dice 0.2.3 → 0.2.5

package/dist/builder/index.cjs

@@ -2568,6 +2568,7 @@ var RollBuilder = class _RollBuilder {
   /** Apply one-pass reroll threshold (k): reroll faces 1..k once, must keep. */
   reroll(value) {
     if (isNaN(value)) throw new Error("Invalid NaN value for reroll");
+    if (value === this.lastConfig.reroll) return this;
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].reroll = value;
     return new this.constructor(newConfigs);
@@ -2664,19 +2665,63 @@ var RollBuilder = class _RollBuilder {
     return new this.constructor(newConfigs);
   }
   toExpression() {
-    const diceConfigs = this.subRollConfigs.filter(
+    const originalDiceConfigs = this.subRollConfigs.filter(
       (config) => config.sides && config.sides > 0
     );
+    const configGroups = /* @__PURE__ */ new Map();
+    for (const config of originalDiceConfigs) {
+      const keyConfig = { ...config };
+      delete keyConfig.count;
+      delete keyConfig.modifier;
+      const key = JSON.stringify(keyConfig);
+      const existingGroup = configGroups.get(key);
+      if (existingGroup) {
+        existingGroup.totalCount += config.count;
+      } else {
+        configGroups.set(key, { config, totalCount: config.count });
+      }
+    }
+    const rootConfig = this.getRootDieConfig();
+    const groupedConfigs = Array.from(configGroups.values());
+    let rootD20Group;
+    if (rootConfig && rootConfig.sides === 20) {
+      const rootIndex = groupedConfigs.findIndex(
+        ({ config }) => config.sides === rootConfig.sides && config.rollType === rootConfig.rollType && config.reroll === rootConfig.reroll && config.explode === rootConfig.explode && config.minimum === rootConfig.minimum && config.bestOf === rootConfig.bestOf && JSON.stringify(config.keep) === JSON.stringify(rootConfig.keep)
+      );
+      if (rootIndex !== -1) {
+        rootD20Group = groupedConfigs.splice(rootIndex, 1)[0];
+      }
+    }
+    const sortedDiceConfigs = groupedConfigs.map(({ config, totalCount }) => ({
+      ...config,
+      count: totalCount
+    })).sort((a, b) => {
+      const aHasPriority = a.reroll > 0 || a.minimum > 0;
+      const bHasPriority = b.reroll > 0 || b.minimum > 0;
+      if (aHasPriority !== bHasPriority) {
+        return aHasPriority ? -1 : 1;
+      }
+      if (b.sides !== a.sides) return b.sides - a.sides;
+      const complexity = (c) => (c.reroll > 0 ? 1 : 0) + (c.minimum > 0 ? 1 : 0) + (c.explode > 0 ? 1 : 0) + (c.bestOf > 0 ? 1 : 0) + (c.keep ? 1 : 0);
+      return complexity(b) - complexity(a);
+    });
+    const diceConfigs = rootD20Group ? [
+      { ...rootD20Group.config, count: rootD20Group.totalCount },
+      ...sortedDiceConfigs
+    ] : sortedDiceConfigs;
     const totalModifier = this.subRollConfigs.reduce(
       (sum, config) => sum + config.modifier,
       0
     );
     if (diceConfigs.length === 0) return totalModifier.toString();
-    const rootConfig = this.getRootDieConfig();
+    const rootDieConfig = this.getRootDieConfig();
+    const newRootConfig = rootDieConfig ? diceConfigs.find(
+      (c) => c.sides === rootDieConfig.sides && c.rollType === rootDieConfig.rollType && c.reroll === rootDieConfig.reroll && c.explode === rootDieConfig.explode && c.minimum === rootDieConfig.minimum && c.bestOf === rootDieConfig.bestOf && c.keep === rootDieConfig.keep
+    ) : void 0;
     const diceExpressions = diceConfigs.map(
       (config) => this.configToSingleExpressionWithoutModifier(
         config,
-        config === rootConfig
+        config === newRootConfig
       )
     );
     let result = "";
@@ -3277,11 +3322,6 @@ var ACBuilder = class _ACBuilder extends RollBuilder {
     const damageRoll = RollBuilder.fromArgs(...args);
     return new AttackBuilder(this, damageRoll);
   }
-  dc(_) {
-    throw new Error(
-      "Cannot use dc() on an AttackRollBuilder. Use ac() for attack rolls instead."
-    );
-  }
   get critThreshold() {
     return this.attackConfig.critThreshold;
   }