@yipe/dice 0.2.0 → 0.2.1

package/dist/builder/index.d.cts

@@ -0,0 +1,255 @@
+import { P as PMF, b as DiceQuery, L as LRUCache } from '../pmf-DIegvlyA.cjs';
+
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode;
+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 RollFactory = {
+    (count: number, sides?: number, modifier?: number): RollBuilder;
+    (count: number, die: RollBuilder, modifier?: number): RollBuilder;
+    d(sides: number): RollBuilder;
+    hd20(): RollBuilder;
+    d4(): RollBuilder;
+    d6(): RollBuilder;
+    d8(): RollBuilder;
+    d10(): RollBuilder;
+    d12(): RollBuilder;
+    d20(): RollBuilder;
+    d100(): RollBuilder;
+    flat(n: number): RollBuilder;
+};
+type RollType = "flat" | "advantage" | "disadvantage" | "elven accuracy";
+type KeepMode = "highest" | "lowest";
+type RollConfig = {
+    count: number;
+    sides: number;
+    modifier: number;
+    reroll: number;
+    explode: number;
+    minimum: number;
+    bestOf: number;
+    keep: {
+        total: number;
+        count: number;
+        mode: KeepMode;
+    } | undefined;
+    rollType: RollType;
+    isSubtraction?: boolean;
+};
+type Resolution = {
+    pmf: PMF;
+    check: PMF;
+    weights: {
+        [key: string]: number;
+    };
+};
+type AttackResolution = Resolution & {
+    hit: PMF;
+    crit: PMF;
+    miss: PMF;
+    weights: {
+        hit: number;
+        crit: number;
+        miss: number;
+    };
+};
+type SaveResolution = Resolution & {
+    saveFail: PMF;
+    saveSuccess: PMF;
+    weights: {
+        success: number;
+        fail: number;
+    };
+};
+interface CheckBuilder {
+    resolve(eps?: number): Resolution;
+    toExpression(): string;
+}
+
+declare const defaultConfig: RollConfig;
+declare class RollBuilder {
+    protected readonly subRollConfigs: readonly RollConfig[];
+    constructor(countOrConfigs?: number | readonly RollConfig[]);
+    protected get lastConfig(): RollConfig;
+    getSubRollConfigs(): readonly RollConfig[];
+    static fromConfig(config: Partial<RollConfig>): RollBuilder;
+    static fromConfigs(configs: Partial<RollConfig>[]): RollBuilder;
+    static fromArgs(...args: any[]): RollBuilder;
+    d(sides: number | undefined): RollBuilder;
+    plus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
+    plus(count: number, die: RollBuilder): RollBuilder;
+    minus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
+    minus(count: number, die: RollBuilder): RollBuilder;
+    /** Apply one-pass reroll threshold (k): reroll faces 1..k once, must keep. */
+    reroll(value: number): RollBuilder;
+    /** Set finite explode count for max-face explosions (Infinity allowed). */
+    explode(count?: number | undefined): RollBuilder;
+    /** Apply per-die minimum value (min > 0). */
+    minimum(val: number | undefined): RollBuilder;
+    bestOf(count: number | undefined): RollBuilder;
+    keepHighest(total: number, count: number): RollBuilder;
+    keepLowest(total: number, count: number): RollBuilder;
+    withAdvantage(): RollBuilder;
+    withDisadvantage(): RollBuilder;
+    add(anotherRoll: RollBuilder | undefined): RollBuilder;
+    withBonus(anotherRoll: RollBuilder): RollBuilder;
+    addRoll(count?: number): RollBuilder;
+    doubleDice(): RollBuilder;
+    copy(): RollBuilder;
+    d4: () => RollBuilder;
+    d6: () => RollBuilder;
+    d8: () => RollBuilder;
+    d10: () => RollBuilder;
+    d12: () => RollBuilder;
+    d20: () => RollBuilder;
+    d100: () => RollBuilder;
+    ac(targetAC: number): ACBuilder;
+    withElvenAccuracy(): RollBuilder;
+    dc(saveDC: number): DCBuilder;
+    toExpression(): string;
+    toPMF(eps?: number): PMF;
+    toQuery(eps?: number): DiceQuery;
+    toAST(): ExpressionNode;
+    private configToSingleExpressionWithoutModifier;
+    getRootDieConfig(): RollConfig | undefined;
+    getAllDieConfigs(): readonly RollConfig[];
+    getBonusDiceConfigs(): RollConfig[];
+    getBonusDicePMFs(check: RollBuilder, eps?: number): PMF[];
+    get modifier(): number;
+    get rollType(): RollType;
+    get baseReroll(): number;
+}
+
+type ActionEffect = RollBuilder;
+declare class AttackBuilder implements CheckBuilder {
+    readonly check: ACBuilder;
+    private readonly hitEffect?;
+    private readonly critEffect?;
+    private readonly missEffect?;
+    constructor(check: ACBuilder, hitEffect?: ActionEffect, critEffect?: ActionEffect | null, missEffect?: ActionEffect);
+    onCrit(val: number): AttackBuilder;
+    onCrit(val: RollBuilder): AttackBuilder;
+    onCrit(count: number, die: RollBuilder): AttackBuilder;
+    onCrit(count: number, sides: number): AttackBuilder;
+    onCrit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onCrit(count: number, sides: number, modifier: number): AttackBuilder;
+    onMiss(val: number): AttackBuilder;
+    onMiss(val: RollBuilder): AttackBuilder;
+    onMiss(count: number, die: RollBuilder): AttackBuilder;
+    onMiss(count: number, sides: number): AttackBuilder;
+    onMiss(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onMiss(count: number, sides: number, modifier: number): AttackBuilder;
+    noCrit(): AttackBuilder;
+    toExpression(): string;
+    resolveProbabilities(check: ACBuilder, eps?: number): {
+        pSuccess: number;
+        pHit: number;
+        pCrit: number;
+        pMiss: number;
+    };
+    resolve(eps?: number): AttackResolution;
+    toPMF(eps?: number): PMF;
+    toQuery(eps?: number): DiceQuery;
+}
+
+interface AttackConfig {
+    ac: number;
+    critThreshold: number;
+}
+declare class ACBuilder extends RollBuilder {
+    readonly attackConfig: AttackConfig;
+    constructor(baseRoll: RollBuilder, ac: number, attackConfig?: AttackConfig);
+    onHit(val: number): AttackBuilder;
+    onHit(val: RollBuilder): AttackBuilder;
+    onHit(count: number, die: RollBuilder): AttackBuilder;
+    onHit(count: number, sides: number): AttackBuilder;
+    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onHit(count: number, sides: number, modifier: number): AttackBuilder;
+    dc(_: number): never;
+    get critThreshold(): number;
+    critOn(threshold: number): ACBuilder;
+    toExpression(): string;
+    toPMF(eps?: number): PMF;
+    copy(): 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;
+    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: 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 function d(sides: number): RollBuilder;
+declare const d4: RollBuilder;
+declare const d6: RollBuilder;
+declare const d8: RollBuilder;
+declare const d10: RollBuilder;
+declare const d12: RollBuilder;
+declare const d20: RollBuilder;
+declare const hd20: RollBuilder;
+declare const d100: RollBuilder;
+declare const flat: (n: number) => RollBuilder;
+declare const roll: RollFactory;
+declare const builderPMFCache: LRUCache<string, PMF>;
+
+export { ACBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, type KeepMode, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };

package/dist/builder/index.d.ts

@@ -0,0 +1,255 @@
+import { P as PMF, b as DiceQuery, L as LRUCache } from '../pmf-DIegvlyA.js';
+
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode;
+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 RollFactory = {
+    (count: number, sides?: number, modifier?: number): RollBuilder;
+    (count: number, die: RollBuilder, modifier?: number): RollBuilder;
+    d(sides: number): RollBuilder;
+    hd20(): RollBuilder;
+    d4(): RollBuilder;
+    d6(): RollBuilder;
+    d8(): RollBuilder;
+    d10(): RollBuilder;
+    d12(): RollBuilder;
+    d20(): RollBuilder;
+    d100(): RollBuilder;
+    flat(n: number): RollBuilder;
+};
+type RollType = "flat" | "advantage" | "disadvantage" | "elven accuracy";
+type KeepMode = "highest" | "lowest";
+type RollConfig = {
+    count: number;
+    sides: number;
+    modifier: number;
+    reroll: number;
+    explode: number;
+    minimum: number;
+    bestOf: number;
+    keep: {
+        total: number;
+        count: number;
+        mode: KeepMode;
+    } | undefined;
+    rollType: RollType;
+    isSubtraction?: boolean;
+};
+type Resolution = {
+    pmf: PMF;
+    check: PMF;
+    weights: {
+        [key: string]: number;
+    };
+};
+type AttackResolution = Resolution & {
+    hit: PMF;
+    crit: PMF;
+    miss: PMF;
+    weights: {
+        hit: number;
+        crit: number;
+        miss: number;
+    };
+};
+type SaveResolution = Resolution & {
+    saveFail: PMF;
+    saveSuccess: PMF;
+    weights: {
+        success: number;
+        fail: number;
+    };
+};
+interface CheckBuilder {
+    resolve(eps?: number): Resolution;
+    toExpression(): string;
+}
+
+declare const defaultConfig: RollConfig;
+declare class RollBuilder {
+    protected readonly subRollConfigs: readonly RollConfig[];
+    constructor(countOrConfigs?: number | readonly RollConfig[]);
+    protected get lastConfig(): RollConfig;
+    getSubRollConfigs(): readonly RollConfig[];
+    static fromConfig(config: Partial<RollConfig>): RollBuilder;
+    static fromConfigs(configs: Partial<RollConfig>[]): RollBuilder;
+    static fromArgs(...args: any[]): RollBuilder;
+    d(sides: number | undefined): RollBuilder;
+    plus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
+    plus(count: number, die: RollBuilder): RollBuilder;
+    minus(modOrRoll: number | RollBuilder | undefined): RollBuilder;
+    minus(count: number, die: RollBuilder): RollBuilder;
+    /** Apply one-pass reroll threshold (k): reroll faces 1..k once, must keep. */
+    reroll(value: number): RollBuilder;
+    /** Set finite explode count for max-face explosions (Infinity allowed). */
+    explode(count?: number | undefined): RollBuilder;
+    /** Apply per-die minimum value (min > 0). */
+    minimum(val: number | undefined): RollBuilder;
+    bestOf(count: number | undefined): RollBuilder;
+    keepHighest(total: number, count: number): RollBuilder;
+    keepLowest(total: number, count: number): RollBuilder;
+    withAdvantage(): RollBuilder;
+    withDisadvantage(): RollBuilder;
+    add(anotherRoll: RollBuilder | undefined): RollBuilder;
+    withBonus(anotherRoll: RollBuilder): RollBuilder;
+    addRoll(count?: number): RollBuilder;
+    doubleDice(): RollBuilder;
+    copy(): RollBuilder;
+    d4: () => RollBuilder;
+    d6: () => RollBuilder;
+    d8: () => RollBuilder;
+    d10: () => RollBuilder;
+    d12: () => RollBuilder;
+    d20: () => RollBuilder;
+    d100: () => RollBuilder;
+    ac(targetAC: number): ACBuilder;
+    withElvenAccuracy(): RollBuilder;
+    dc(saveDC: number): DCBuilder;
+    toExpression(): string;
+    toPMF(eps?: number): PMF;
+    toQuery(eps?: number): DiceQuery;
+    toAST(): ExpressionNode;
+    private configToSingleExpressionWithoutModifier;
+    getRootDieConfig(): RollConfig | undefined;
+    getAllDieConfigs(): readonly RollConfig[];
+    getBonusDiceConfigs(): RollConfig[];
+    getBonusDicePMFs(check: RollBuilder, eps?: number): PMF[];
+    get modifier(): number;
+    get rollType(): RollType;
+    get baseReroll(): number;
+}
+
+type ActionEffect = RollBuilder;
+declare class AttackBuilder implements CheckBuilder {
+    readonly check: ACBuilder;
+    private readonly hitEffect?;
+    private readonly critEffect?;
+    private readonly missEffect?;
+    constructor(check: ACBuilder, hitEffect?: ActionEffect, critEffect?: ActionEffect | null, missEffect?: ActionEffect);
+    onCrit(val: number): AttackBuilder;
+    onCrit(val: RollBuilder): AttackBuilder;
+    onCrit(count: number, die: RollBuilder): AttackBuilder;
+    onCrit(count: number, sides: number): AttackBuilder;
+    onCrit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onCrit(count: number, sides: number, modifier: number): AttackBuilder;
+    onMiss(val: number): AttackBuilder;
+    onMiss(val: RollBuilder): AttackBuilder;
+    onMiss(count: number, die: RollBuilder): AttackBuilder;
+    onMiss(count: number, sides: number): AttackBuilder;
+    onMiss(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onMiss(count: number, sides: number, modifier: number): AttackBuilder;
+    noCrit(): AttackBuilder;
+    toExpression(): string;
+    resolveProbabilities(check: ACBuilder, eps?: number): {
+        pSuccess: number;
+        pHit: number;
+        pCrit: number;
+        pMiss: number;
+    };
+    resolve(eps?: number): AttackResolution;
+    toPMF(eps?: number): PMF;
+    toQuery(eps?: number): DiceQuery;
+}
+
+interface AttackConfig {
+    ac: number;
+    critThreshold: number;
+}
+declare class ACBuilder extends RollBuilder {
+    readonly attackConfig: AttackConfig;
+    constructor(baseRoll: RollBuilder, ac: number, attackConfig?: AttackConfig);
+    onHit(val: number): AttackBuilder;
+    onHit(val: RollBuilder): AttackBuilder;
+    onHit(count: number, die: RollBuilder): AttackBuilder;
+    onHit(count: number, sides: number): AttackBuilder;
+    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onHit(count: number, sides: number, modifier: number): AttackBuilder;
+    dc(_: number): never;
+    get critThreshold(): number;
+    critOn(threshold: number): ACBuilder;
+    toExpression(): string;
+    toPMF(eps?: number): PMF;
+    copy(): 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;
+    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: 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 function d(sides: number): RollBuilder;
+declare const d4: RollBuilder;
+declare const d6: RollBuilder;
+declare const d8: RollBuilder;
+declare const d10: RollBuilder;
+declare const d12: RollBuilder;
+declare const d20: RollBuilder;
+declare const hd20: RollBuilder;
+declare const d100: RollBuilder;
+declare const flat: (n: number) => RollBuilder;
+declare const roll: RollFactory;
+declare const builderPMFCache: LRUCache<string, PMF>;
+
+export { ACBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, type KeepMode, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };