@yipe/dice 0.2.21 → 0.2.22

package/dist/builder/index.d.cts

@@ -1,54 +1,9 @@
-import { P as PMF, C as CritConfig, i as DiceQuery, L as LRUCache } from '../pmf-BC1poIqF.cjs';
-
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
-type DieNode = {
-    type: "die";
-    sides: number;
-    reroll?: number;
-    minimum?: number;
-    explode?: number;
-};
-type ConstantNode = {
-    type: "constant";
-    value: number;
-};
-type SumNode = {
-    type: "sum";
-    count: number;
-    child: ExpressionNode;
-};
-type AddNode = {
-    type: "add";
-    children: {
-        node: ExpressionNode;
-        sign: 1 | -1;
-    }[];
-};
-type KeepNode = {
-    type: "keep";
-    mode: "highest" | "lowest";
-    count: number;
-    child: SumNode | KeepNode;
-};
-type D20RollNode = {
-    type: "d20Roll";
-    rollType: "advantage" | "disadvantage" | "elven accuracy";
-    child: ExpressionNode;
-};
-type HalfNode = {
-    type: "half";
-    child: ExpressionNode;
-};
-type MaxOfNode = {
-    type: "maxOf";
-    count: number;
-    child: ExpressionNode;
-};
+import { P as PMF, i as DiceQuery, C as CritConfig, L as LRUCache } from '../pmf-BC1poIqF.cjs';
 
 type RollFactory = {
     (count: number, sides?: number, modifier?: number): RollBuilder;
     (count: number, die: RollBuilder, modifier?: number): RollBuilder;
-    d(sides: number): RollBuilder;
+    d(sides: number | string): RollBuilder;
     hd20(): RollBuilder;
     d4(): RollBuilder;
     d6(): RollBuilder;
@@ -108,6 +63,87 @@ interface CheckBuilder {
     readonly pmf: PMF;
 }
 
+type SaveOutcome = "normal" | "half";
+declare class SaveBuilder implements CheckBuilder {
+    readonly check: DCBuilder;
+    private readonly failureEffect?;
+    private readonly saveOutcome;
+    constructor(check: DCBuilder, failureEffect?: RollBuilder, saveOutcome?: SaveOutcome);
+    saveHalf(): SaveBuilder;
+    toExpression(): string;
+    resolve(eps?: number): SaveResolution;
+    toPMF(eps?: number): PMF;
+    get pmf(): PMF;
+    toQuery(eps?: number): DiceQuery;
+}
+
+interface SaveConfig {
+    dc: number;
+}
+declare class DCBuilder extends RollBuilder {
+    private readonly saveConfig;
+    constructor(baseRoll: RollBuilder, saveConfig?: SaveConfig);
+    dc(saveDC: number): DCBuilder;
+    get saveDC(): number;
+    add(anotherRoll: RollBuilder): DCBuilder;
+    addRoll(count?: number): DCBuilder;
+    onSaveFailure(val: number): SaveBuilder;
+    onSaveFailure(val: string): SaveBuilder;
+    onSaveFailure(val: RollBuilder): SaveBuilder;
+    onSaveFailure(count: number, die: RollBuilder): SaveBuilder;
+    onSaveFailure(count: number, sides: number): SaveBuilder;
+    onSaveFailure(count: number, die: RollBuilder, modifier: number): SaveBuilder;
+    onSaveFailure(count: number, sides: number, modifier: number): SaveBuilder;
+    withElvenAccuracy(): never;
+    toExpression(): string;
+    toPMF(eps?: number): PMF;
+}
+
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
+type DieNode = {
+    type: "die";
+    sides: number;
+    reroll?: number;
+    minimum?: number;
+    explode?: number;
+};
+type ConstantNode = {
+    type: "constant";
+    value: number;
+};
+type SumNode = {
+    type: "sum";
+    count: number;
+    child: ExpressionNode;
+};
+type AddNode = {
+    type: "add";
+    children: {
+        node: ExpressionNode;
+        sign: 1 | -1;
+    }[];
+};
+type KeepNode = {
+    type: "keep";
+    mode: "highest" | "lowest";
+    count: number;
+    child: SumNode | KeepNode;
+};
+type D20RollNode = {
+    type: "d20Roll";
+    rollType: "advantage" | "disadvantage" | "elven accuracy";
+    child: ExpressionNode;
+};
+type HalfNode = {
+    type: "half";
+    child: ExpressionNode;
+};
+type MaxOfNode = {
+    type: "maxOf";
+    count: number;
+    child: ExpressionNode;
+};
+
 declare const defaultConfig: RollConfig;
 declare class RollBuilder {
     protected readonly subRollConfigs: readonly RollConfig[];
@@ -168,6 +204,8 @@ declare class RollBuilder {
     get baseReroll(): number;
     half(): HalfRollBuilder;
     maxOf(count: number): MaxOfRollBuilder;
+    ac(targetAC: number): ACBuilder;
+    dc(saveDC: number): DCBuilder;
 }
 declare class HalfRollBuilder extends RollBuilder {
     private readonly innerRoll;
@@ -325,54 +363,8 @@ declare class ACBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
     copy(): ACBuilder;
 }
-declare module "./roll" {
-    interface RollBuilder {
-        ac(targetAC: number): ACBuilder;
-    }
-}
-
-type SaveOutcome = "normal" | "half";
-declare class SaveBuilder implements CheckBuilder {
-    readonly check: DCBuilder;
-    private readonly failureEffect?;
-    private readonly saveOutcome;
-    constructor(check: DCBuilder, failureEffect?: RollBuilder, saveOutcome?: SaveOutcome);
-    saveHalf(): SaveBuilder;
-    toExpression(): string;
-    resolve(eps?: number): SaveResolution;
-    toPMF(eps?: number): PMF;
-    get pmf(): PMF;
-    toQuery(eps?: number): DiceQuery;
-}
-
-interface SaveConfig {
-    dc: number;
-}
-declare class DCBuilder extends RollBuilder {
-    private readonly saveConfig;
-    constructor(baseRoll: RollBuilder, saveConfig?: SaveConfig);
-    dc(saveDC: number): DCBuilder;
-    get saveDC(): number;
-    add(anotherRoll: RollBuilder): DCBuilder;
-    addRoll(count?: number): DCBuilder;
-    onSaveFailure(val: number): SaveBuilder;
-    onSaveFailure(val: string): SaveBuilder;
-    onSaveFailure(val: RollBuilder): SaveBuilder;
-    onSaveFailure(count: number, die: RollBuilder): SaveBuilder;
-    onSaveFailure(count: number, sides: number): SaveBuilder;
-    onSaveFailure(count: number, die: RollBuilder, modifier: number): SaveBuilder;
-    onSaveFailure(count: number, sides: number, modifier: number): SaveBuilder;
-    withElvenAccuracy(): never;
-    toExpression(): string;
-    toPMF(eps?: number): PMF;
-}
-declare module "./roll" {
-    interface RollBuilder {
-        dc(saveDC: number): DCBuilder;
-    }
-}
 
-declare function d(sides: number): RollBuilder;
+declare function d(sides: number | string): RollBuilder;
 declare const d4: RollBuilder;
 declare const d6: RollBuilder;
 declare const d8: RollBuilder;

package/dist/builder/index.d.ts

@@ -1,54 +1,9 @@
-import { P as PMF, C as CritConfig, i as DiceQuery, L as LRUCache } from '../pmf-BC1poIqF.js';
-
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
-type DieNode = {
-    type: "die";
-    sides: number;
-    reroll?: number;
-    minimum?: number;
-    explode?: number;
-};
-type ConstantNode = {
-    type: "constant";
-    value: number;
-};
-type SumNode = {
-    type: "sum";
-    count: number;
-    child: ExpressionNode;
-};
-type AddNode = {
-    type: "add";
-    children: {
-        node: ExpressionNode;
-        sign: 1 | -1;
-    }[];
-};
-type KeepNode = {
-    type: "keep";
-    mode: "highest" | "lowest";
-    count: number;
-    child: SumNode | KeepNode;
-};
-type D20RollNode = {
-    type: "d20Roll";
-    rollType: "advantage" | "disadvantage" | "elven accuracy";
-    child: ExpressionNode;
-};
-type HalfNode = {
-    type: "half";
-    child: ExpressionNode;
-};
-type MaxOfNode = {
-    type: "maxOf";
-    count: number;
-    child: ExpressionNode;
-};
+import { P as PMF, i as DiceQuery, C as CritConfig, L as LRUCache } from '../pmf-BC1poIqF.js';
 
 type RollFactory = {
     (count: number, sides?: number, modifier?: number): RollBuilder;
     (count: number, die: RollBuilder, modifier?: number): RollBuilder;
-    d(sides: number): RollBuilder;
+    d(sides: number | string): RollBuilder;
     hd20(): RollBuilder;
     d4(): RollBuilder;
     d6(): RollBuilder;
@@ -108,6 +63,87 @@ interface CheckBuilder {
     readonly pmf: PMF;
 }
 
+type SaveOutcome = "normal" | "half";
+declare class SaveBuilder implements CheckBuilder {
+    readonly check: DCBuilder;
+    private readonly failureEffect?;
+    private readonly saveOutcome;
+    constructor(check: DCBuilder, failureEffect?: RollBuilder, saveOutcome?: SaveOutcome);
+    saveHalf(): SaveBuilder;
+    toExpression(): string;
+    resolve(eps?: number): SaveResolution;
+    toPMF(eps?: number): PMF;
+    get pmf(): PMF;
+    toQuery(eps?: number): DiceQuery;
+}
+
+interface SaveConfig {
+    dc: number;
+}
+declare class DCBuilder extends RollBuilder {
+    private readonly saveConfig;
+    constructor(baseRoll: RollBuilder, saveConfig?: SaveConfig);
+    dc(saveDC: number): DCBuilder;
+    get saveDC(): number;
+    add(anotherRoll: RollBuilder): DCBuilder;
+    addRoll(count?: number): DCBuilder;
+    onSaveFailure(val: number): SaveBuilder;
+    onSaveFailure(val: string): SaveBuilder;
+    onSaveFailure(val: RollBuilder): SaveBuilder;
+    onSaveFailure(count: number, die: RollBuilder): SaveBuilder;
+    onSaveFailure(count: number, sides: number): SaveBuilder;
+    onSaveFailure(count: number, die: RollBuilder, modifier: number): SaveBuilder;
+    onSaveFailure(count: number, sides: number, modifier: number): SaveBuilder;
+    withElvenAccuracy(): never;
+    toExpression(): string;
+    toPMF(eps?: number): PMF;
+}
+
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
+type DieNode = {
+    type: "die";
+    sides: number;
+    reroll?: number;
+    minimum?: number;
+    explode?: number;
+};
+type ConstantNode = {
+    type: "constant";
+    value: number;
+};
+type SumNode = {
+    type: "sum";
+    count: number;
+    child: ExpressionNode;
+};
+type AddNode = {
+    type: "add";
+    children: {
+        node: ExpressionNode;
+        sign: 1 | -1;
+    }[];
+};
+type KeepNode = {
+    type: "keep";
+    mode: "highest" | "lowest";
+    count: number;
+    child: SumNode | KeepNode;
+};
+type D20RollNode = {
+    type: "d20Roll";
+    rollType: "advantage" | "disadvantage" | "elven accuracy";
+    child: ExpressionNode;
+};
+type HalfNode = {
+    type: "half";
+    child: ExpressionNode;
+};
+type MaxOfNode = {
+    type: "maxOf";
+    count: number;
+    child: ExpressionNode;
+};
+
 declare const defaultConfig: RollConfig;
 declare class RollBuilder {
     protected readonly subRollConfigs: readonly RollConfig[];
@@ -168,6 +204,8 @@ declare class RollBuilder {
     get baseReroll(): number;
     half(): HalfRollBuilder;
     maxOf(count: number): MaxOfRollBuilder;
+    ac(targetAC: number): ACBuilder;
+    dc(saveDC: number): DCBuilder;
 }
 declare class HalfRollBuilder extends RollBuilder {
     private readonly innerRoll;
@@ -325,54 +363,8 @@ declare class ACBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
     copy(): ACBuilder;
 }
-declare module "./roll" {
-    interface RollBuilder {
-        ac(targetAC: number): ACBuilder;
-    }
-}
-
-type SaveOutcome = "normal" | "half";
-declare class SaveBuilder implements CheckBuilder {
-    readonly check: DCBuilder;
-    private readonly failureEffect?;
-    private readonly saveOutcome;
-    constructor(check: DCBuilder, failureEffect?: RollBuilder, saveOutcome?: SaveOutcome);
-    saveHalf(): SaveBuilder;
-    toExpression(): string;
-    resolve(eps?: number): SaveResolution;
-    toPMF(eps?: number): PMF;
-    get pmf(): PMF;
-    toQuery(eps?: number): DiceQuery;
-}
-
-interface SaveConfig {
-    dc: number;
-}
-declare class DCBuilder extends RollBuilder {
-    private readonly saveConfig;
-    constructor(baseRoll: RollBuilder, saveConfig?: SaveConfig);
-    dc(saveDC: number): DCBuilder;
-    get saveDC(): number;
-    add(anotherRoll: RollBuilder): DCBuilder;
-    addRoll(count?: number): DCBuilder;
-    onSaveFailure(val: number): SaveBuilder;
-    onSaveFailure(val: string): SaveBuilder;
-    onSaveFailure(val: RollBuilder): SaveBuilder;
-    onSaveFailure(count: number, die: RollBuilder): SaveBuilder;
-    onSaveFailure(count: number, sides: number): SaveBuilder;
-    onSaveFailure(count: number, die: RollBuilder, modifier: number): SaveBuilder;
-    onSaveFailure(count: number, sides: number, modifier: number): SaveBuilder;
-    withElvenAccuracy(): never;
-    toExpression(): string;
-    toPMF(eps?: number): PMF;
-}
-declare module "./roll" {
-    interface RollBuilder {
-        dc(saveDC: number): DCBuilder;
-    }
-}
 
-declare function d(sides: number): RollBuilder;
+declare function d(sides: number | string): RollBuilder;
 declare const d4: RollBuilder;
 declare const d6: RollBuilder;
 declare const d8: RollBuilder;

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 };
@@ -3832,6 +3834,14 @@ 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) {
@@ -4208,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();
@@ -4219,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();