calculation-breakdown 0.0.0-stage → 0.1.2

package/CHANGELOG-ARCHIVE.md

@@ -0,0 +1,3 @@
+# Changelog archive
+
+Full notes for older releases. See the [changelog](CHANGELOG.md) for current releases.

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+Notable changes, starting with 0.1.0. The latest five releases are detailed here; older releases are archived.
+
+## 0.1.2 — 2026-10-26
+
+- Added an opt-in locale mode to the playground that preserves calculation edits, keeps the default example limited to the calculation, and falls back to semantic keys without generated dictionary placeholders.
+- Made the playground vertically scrollable and its three panels usable on mobile screens.
+- Fixed the deployed playground by including every browser ESM module, and kept release artifact inspection JSON-safe by suppressing duplicate package lifecycle scripts.
+
+## 0.1.1 — 2026-10-26
+
+- Added the guarded npm, Git tag, release-PR, and GitHub Pages deployment workflow used by `payload-vars`.
+
+## 0.1.0 — 2026-10-26
+
+### Added
+
+- Added the typed calculation breakdown builder, localized human-readable formatter, and interactive invoice playground.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ThisMeansMore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,180 @@
-# Temporary Holding Version
+# calculation-breakdown
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Typed, serializable breakdowns of calculations performed elsewhere.
+
+Use `calculation-breakdown` to record how an authoritative result was produced without coupling that record to a particular UI, locale, or business domain. A breakdown can describe invoice totals, taxes, discounts, fees, credits, exchange-rate conversions, usage charges, allocations, prorations, and other financial calculations.
+
+The package has no runtime dependencies and supports browsers and Node.js 18+. **It does not perform arithmetic or calculate results.** Your application supplies every value and the authoritative result. The package only creates a structured record that other systems can render, localize, store, or audit.
+
+## Why use it?
+
+- Keep calculation traces typed alongside financial domain code.
+- Serialize breakdowns as plain JSON for APIs, ledgers, invoices, logs, and audit records.
+- Render the same calculation differently for customers, finance teams, and internal tools.
+- Preserve decimal inputs exactly by representing monetary and numeric values as strings.
+- Attach domain-specific semantic labels without embedding presentation text.
+
+## Install
+
+```sh
+npm install calculation-breakdown
+```
+
+## Playground
+
+The deployed playground is available at
+[thismeansmore.github.io/calculation-breakdown/playground/](https://thismeansmore.github.io/calculation-breakdown/playground/).
+
+Explore the builder, customize the formula rendering with CSS, and see the result in
+a live preview:
+
+```sh
+npm run playground
+```
+
+Then open `http://127.0.0.1:4173/playground/`. The playground runs entirely in
+the browser against the package's built ESM output. Builder and CSS changes are
+previewed automatically, both editors provide syntax coloring, and the locale
+switch demonstrates English and Czech
+human-readable output. The sample UI color-codes values and explains their
+semantics with accessible hover and keyboard-focus tooltips, demonstrating how a product
+can make a calculation trace approachable without changing its serialized data. Its
+money renderer keeps ISO currency codes in metadata while using locale-aware currency
+symbols and placement in the preview. The invoice scenario combines quantity-based
+and duration-based lines, percentage
+discounts, dynamically prorated annual insurance through December 31, subtotal,
+tax, and the final amount in one calculation tree.
+The in-card Table / Formula / Formula with names switch demonstrates an annotated
+expression with optional inline semantic names and an automatically inferred invoice
+view. In the named formula mode, tooltips contain only the longer descriptions. The
+table formatter discovers semantic groups and results directly from the calculation,
+uses dictionary names for column labels, and groups compatible shapes together. It
+contains no invoice-specific content rules.
+Mark selected groups with
+`group(expression, { wrap: true, semantic: 'invoiceLine' })` to give visual
+renderers an explicit line-wrapping hint and a localized group heading. The
+playground honors this metadata.
+
+GitHub Pages deploys the committed `docs/` directory from `main`. `npm run build`
+regenerates it from the playground source and the local ESM build, so the deployed
+demo always exercises the package code from the same commit.
+
+## Releasing
+
+Releases follow the same guarded release-branch workflow as `payload-vars`.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the exact prepare, review, merge,
+publish, npm-integrity, and GitHub Pages verification steps.
+
+## Usage
+
+```ts
+import {
+    CalculationBreakdownBuilder,
+    toHumanString,
+} from 'calculation-breakdown';
+
+type TSemantic =
+    | 'invoiceSubtotal'
+    | 'taxRate'
+    | 'invoiceTotal';
+
+const builder = new CalculationBreakdownBuilder<TSemantic>();
+
+const breakdown = builder
+    .breakdown(({ money, percent, add, multiply }) =>
+        add(
+            money('invoiceSubtotal', '125.00', 'USD'),
+            multiply(
+                money('invoiceSubtotal', '125.00', 'USD'),
+                percent('taxRate', '0.20'),
+            ),
+        ),
+    )
+    .result(({ money }) => money('invoiceTotal', '150.00', 'USD'))
+    .build();
+
+const english = toHumanString(breakdown, {
+    locale: 'en',
+    includeNames: true,
+    dictionary: {
+        en: {
+            invoiceSubtotal: 'subtotal',
+            taxRate: {
+                name: 'tax rate',
+                description: 'The percentage applied to the subtotal.',
+            },
+            invoiceTotal: 'invoice total',
+        },
+    },
+});
+```
+
+The resulting JSON describes:
+
+```text
+125.00 USD subtotal + (125.00 USD subtotal × 20% tax rate) = 150.00 USD invoice total
+```
+
+Values use decimal strings so their exact representation survives JSON serialization. The generic semantic union prevents unknown domain keys during type checking. Consumers can map each value's `type` to formatting and its `semantic` to localized labels, ledger concepts, or reporting categories.
+
+Set `includeNames: false` to render only formatted values. It defaults to `true`.
+
+## Builders
+
+- `money(semantic, amount, currency)`
+- `duration(semantic, amount, unit, options?)`
+- `number(semantic, value)`
+- `percent(semantic, value)` for fractional values (`'0.20'` renders as `20%`)
+- `constant(value)` for semantic-free numeric constants
+- `group(expression, options?)` for explicit brackets and optional `wrap`,
+  `semantic`, authoritative grouped `result` metadata (for example, a line
+  subtotal), a semantic `role` (`detail` by default or `summary`), and an
+  `orientation` hint (`horizontal` by default or `vertical`)
+- `operator(left, operator, right)`
+- Helpers: `add`, `subtract`, `multiply`, `divide`, `minimum`, `maximum`
+- Decimal.js-style aliases: `sub`, `mul`, `div`, `min`, `max`
+
+For inferred tables, detail groups expose their semantic values as columns. A
+`role: 'summary'` group renders as `group name | group result`. Formula renderers
+still retain the complete expression; the role describes meaning rather than a
+universal visual layout.
+
+Detail groups default to `orientation: 'horizontal'`, allowing compatible groups
+to share inferred columns. Use `orientation: 'vertical'` to retain every detail as
+stacked `semantic name | value` rows. Orientation does not remove formula details.
+
+Decimal.js-style names are also accepted by `operator`. They normalize to the
+long-form names in the serialized output, so both naming styles produce the
+same stable schema.
+
+## Human-readable output
+
+Use the exported `toHumanString` helper to render any plain breakdown, including
+one restored from JSON. The builder exposes the same formatter as a convenience:
+
+```ts
+const czech = builder.toHumanString({
+    locale: 'cs',
+    dictionary: {
+        cs: {
+            invoiceSubtotal: 'mezisoučet',
+            taxRate: {
+                name: 'sazba daně',
+                description: 'Procentní sazba použitá pro výpočet daně.',
+            },
+            invoiceTotal: 'celkem',
+        },
+    },
+});
+```
+
+English (`en`) and Czech (`cs`) are supported. The locale controls decimal
+separators and duration-unit names; the dictionary groups domain-specific labels
+by locale. Each semantic accepts a short string or `{ name, description }` for
+richer UIs. Missing dictionary entries fall back to their semantic keys. Rendering
+does not modify the calculation, and `build()` continues to return detached,
+deeply frozen plain JSON data.
+
+Duration rounding metadata accepts `rounding: 'up' | 'down' | 'nearest'` and a positive numeric `step`. For example, steps `0.1`, `1`, and `10` mean tenths, whole units, and multiples of ten.
+
+The built output is detached and deeply frozen. It contains no localized text, HTML, CSS, colors, or executable calculation logic, making it suitable for transport and storage across financial applications.

package/dist/calculation-breakdown-builder.d.ts

@@ -0,0 +1,56 @@
+import { type ICalculationBreakdownHumanStringOptions } from './calculation-breakdown-human-string.js';
+import type { ICalculationBreakdown, ICalculationBreakdownNodeBuilder } from './calculation-breakdown.interface.js';
+import type { TCalculationBreakdownNode, TCalculationBreakdownValue } from './calculation-breakdown.type.js';
+/**
+ * Records a typed, serializable breakdown of a calculation performed elsewhere.
+ *
+ * This builder does not evaluate operations or calculate the result. The calling
+ * application supplies every value, including the authoritative result.
+ *
+ * @typeParam Semantic - String union used to label the domain meaning of values.
+ *
+ * @example
+ * ```ts
+ * const breakdown = new CalculationBreakdownBuilder<'price' | 'total'>()
+ *     .breakdown(({ money, constant, multiply }) =>
+ *         multiply(money('price', '100.00', 'USD'), constant('0.9')),
+ *     )
+ *     .result(({ money }) => money('total', '90.00', 'USD'))
+ *     .build();
+ * ```
+ */
+export declare class CalculationBreakdownBuilder<Semantic extends string> {
+    private breakdownValue?;
+    private resultValue?;
+    private readonly nodeBuilder;
+    /**
+     * Sets the root node that describes the calculation.
+     *
+     * @param create - Callback that describes the calculation using typed factories.
+     * @returns This builder for fluent chaining.
+     */
+    breakdown(create: (builder: ICalculationBreakdownNodeBuilder<Semantic>) => TCalculationBreakdownNode<Semantic>): this;
+    /**
+     * Sets the authoritative result calculated by the calling application.
+     *
+     * @param create - Callback that constructs a money, duration, or number value.
+     * @returns This builder for fluent chaining.
+     */
+    result(create: (builder: ICalculationBreakdownNodeBuilder<Semantic>) => TCalculationBreakdownValue<Semantic>): this;
+    /**
+     * Produces a detached, deeply frozen calculation breakdown.
+     *
+     * @throws {CalculationBreakdownError} If either the breakdown or result is missing.
+     */
+    build(): ICalculationBreakdown<Semantic>;
+    /** Builds and renders the calculation using localized semantic labels. */
+    toHumanString(options: ICalculationBreakdownHumanStringOptions<Semantic>): string;
+    private createMoney;
+    private createDuration;
+    private createNumber;
+    private createPercent;
+    private createConstant;
+    private createGroup;
+    private createOperation;
+}
+//# sourceMappingURL=calculation-breakdown-builder.d.ts.map

package/dist/calculation-breakdown-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculation-breakdown-builder.d.ts","sourceRoot":"","sources":["../src/calculation-breakdown-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,KAAK,uCAAuC,EAC/C,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EACR,qBAAqB,EAIrB,gCAAgC,EAOnC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAIR,yBAAyB,EAIzB,0BAA0B,EAC7B,MAAM,iCAAiC,CAAC;AA6GzC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,2BAA2B,CAAC,QAAQ,SAAS,MAAM;IAC5D,OAAO,CAAC,cAAc,CAAC,CAAsC;IAC7D,OAAO,CAAC,WAAW,CAAC,CAAuC;IAE3D,OAAO,CAAC,QAAQ,CAAC,WAAW,CA4BtB;IAEN;;;;;OAKG;IACH,SAAS,CACL,MAAM,EAAE,CACJ,OAAO,EAAE,gCAAgC,CAAC,QAAQ,CAAC,KAClD,yBAAyB,CAAC,QAAQ,CAAC,GACzC,IAAI;IAKP;;;;;OAKG;IACH,MAAM,CACF,MAAM,EAAE,CACJ,OAAO,EAAE,gCAAgC,CAAC,QAAQ,CAAC,KAClD,0BAA0B,CAAC,QAAQ,CAAC,GAC1C,IAAI;IAKP;;;;OAIG;IACH,KAAK,IAAI,qBAAqB,CAAC,QAAQ,CAAC;IAsBxC,0EAA0E;IAC1E,aAAa,CACT,OAAO,EAAE,uCAAuC,CAAC,QAAQ,CAAC,GAC3D,MAAM;IAIT,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,cAAc;IA0BtB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,WAAW;IA8CnB,OAAO,CAAC,eAAe;CAqB1B"}

package/dist/calculation-breakdown-builder.js

@@ -0,0 +1,242 @@
+import { CalculationBreakdownError } from './calculation-breakdown.error.js';
+import { toHumanString, } from './calculation-breakdown-human-string.js';
+const DECIMAL_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+const CURRENCY_PATTERN = /^[A-Z]{3}$/;
+const DURATION_UNITS = new Set([
+    'milliseconds',
+    'seconds',
+    'minutes',
+    'hours',
+    'days',
+]);
+const ROUNDING_MODES = new Set([
+    'up',
+    'down',
+    'nearest',
+]);
+const GROUP_ROLES = new Set([
+    'detail',
+    'summary',
+]);
+const GROUP_ORIENTATIONS = new Set([
+    'horizontal',
+    'vertical',
+]);
+const OPERATORS = new Set([
+    'add',
+    'subtract',
+    'multiply',
+    'divide',
+    'minimum',
+    'maximum',
+]);
+const OPERATOR_ALIASES = {
+    sub: 'subtract',
+    mul: 'multiply',
+    div: 'divide',
+    min: 'minimum',
+    max: 'maximum',
+};
+function assertSemantic(semantic) {
+    if (semantic.trim().length === 0) {
+        throw new CalculationBreakdownError('INVALID_SEMANTIC', 'Semantic must be a non-empty string.');
+    }
+}
+function assertDecimal(value) {
+    if (!DECIMAL_PATTERN.test(value)) {
+        throw new CalculationBreakdownError('INVALID_DECIMAL', `Invalid decimal string: ${value}`);
+    }
+}
+function assertDurationOptions(options) {
+    if (!options)
+        return;
+    const hasRounding = options.rounding !== undefined;
+    const hasStep = options.step !== undefined;
+    const step = options.step;
+    if (hasRounding &&
+        !ROUNDING_MODES.has(options.rounding)) {
+        throw new CalculationBreakdownError('INVALID_ROUNDING', `Invalid rounding mode: ${String(options.rounding)}`);
+    }
+    if (hasRounding !== hasStep) {
+        throw new CalculationBreakdownError('INVALID_ROUNDING_STEP', 'Rounding and step must be provided together.');
+    }
+    if (hasStep &&
+        (step === undefined || !Number.isFinite(step) || step <= 0)) {
+        throw new CalculationBreakdownError('INVALID_ROUNDING_STEP', 'Rounding step must be a positive finite number.');
+    }
+}
+function deepFreeze(value) {
+    if (typeof value !== 'object' || value === null || Object.isFrozen(value)) {
+        return value;
+    }
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return value;
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Records a typed, serializable breakdown of a calculation performed elsewhere.
+ *
+ * This builder does not evaluate operations or calculate the result. The calling
+ * application supplies every value, including the authoritative result.
+ *
+ * @typeParam Semantic - String union used to label the domain meaning of values.
+ *
+ * @example
+ * ```ts
+ * const breakdown = new CalculationBreakdownBuilder<'price' | 'total'>()
+ *     .breakdown(({ money, constant, multiply }) =>
+ *         multiply(money('price', '100.00', 'USD'), constant('0.9')),
+ *     )
+ *     .result(({ money }) => money('total', '90.00', 'USD'))
+ *     .build();
+ * ```
+ */
+export class CalculationBreakdownBuilder {
+    breakdownValue;
+    resultValue;
+    nodeBuilder = {
+        money: (semantic, amount, currency) => this.createMoney(semantic, amount, currency),
+        duration: (semantic, amount, unit, options) => this.createDuration(semantic, amount, unit, options),
+        number: (semantic, value) => this.createNumber(semantic, value),
+        percent: (semantic, value) => this.createPercent(semantic, value),
+        constant: (value) => this.createConstant(value),
+        group: (expression, options) => this.createGroup(expression, options),
+        operator: (left, operator, right) => this.createOperation(left, operator, right),
+        add: (left, right) => this.createOperation(left, 'add', right),
+        subtract: (left, right) => this.createOperation(left, 'subtract', right),
+        sub: (left, right) => this.createOperation(left, 'sub', right),
+        multiply: (left, right) => this.createOperation(left, 'multiply', right),
+        mul: (left, right) => this.createOperation(left, 'mul', right),
+        divide: (left, right) => this.createOperation(left, 'divide', right),
+        div: (left, right) => this.createOperation(left, 'div', right),
+        minimum: (left, right) => this.createOperation(left, 'minimum', right),
+        min: (left, right) => this.createOperation(left, 'min', right),
+        maximum: (left, right) => this.createOperation(left, 'maximum', right),
+        max: (left, right) => this.createOperation(left, 'max', right),
+    };
+    /**
+     * Sets the root node that describes the calculation.
+     *
+     * @param create - Callback that describes the calculation using typed factories.
+     * @returns This builder for fluent chaining.
+     */
+    breakdown(create) {
+        this.breakdownValue = create(this.nodeBuilder);
+        return this;
+    }
+    /**
+     * Sets the authoritative result calculated by the calling application.
+     *
+     * @param create - Callback that constructs a money, duration, or number value.
+     * @returns This builder for fluent chaining.
+     */
+    result(create) {
+        this.resultValue = create(this.nodeBuilder);
+        return this;
+    }
+    /**
+     * Produces a detached, deeply frozen calculation breakdown.
+     *
+     * @throws {CalculationBreakdownError} If either the breakdown or result is missing.
+     */
+    build() {
+        if (!this.breakdownValue) {
+            throw new CalculationBreakdownError('MISSING_BREAKDOWN', 'A breakdown is required before building.');
+        }
+        if (!this.resultValue) {
+            throw new CalculationBreakdownError('MISSING_RESULT', 'A result is required before building.');
+        }
+        return deepFreeze(cloneJson({
+            breakdown: this.breakdownValue,
+            result: this.resultValue,
+        }));
+    }
+    /** Builds and renders the calculation using localized semantic labels. */
+    toHumanString(options) {
+        return toHumanString(this.build(), options);
+    }
+    createMoney(semantic, amount, currency) {
+        assertSemantic(semantic);
+        assertDecimal(amount);
+        if (!CURRENCY_PATTERN.test(currency)) {
+            throw new CalculationBreakdownError('INVALID_CURRENCY', `Currency must be a three-letter uppercase code: ${currency}`);
+        }
+        return deepFreeze({ type: 'money', semantic, amount, currency });
+    }
+    createDuration(semantic, amount, unit, options) {
+        assertSemantic(semantic);
+        assertDecimal(amount);
+        if (!DURATION_UNITS.has(unit)) {
+            throw new CalculationBreakdownError('INVALID_DURATION_UNIT', `Unsupported duration unit: ${unit}`);
+        }
+        assertDurationOptions(options);
+        return deepFreeze({
+            type: 'duration',
+            semantic,
+            amount,
+            unit,
+            ...(options?.rounding ? { rounding: options.rounding } : {}),
+            ...(options?.step !== undefined ? { step: options.step } : {}),
+        });
+    }
+    createNumber(semantic, value) {
+        assertSemantic(semantic);
+        assertDecimal(value);
+        return deepFreeze({ type: 'number', semantic, value });
+    }
+    createPercent(semantic, value) {
+        assertSemantic(semantic);
+        assertDecimal(value);
+        return deepFreeze({ type: 'percent', semantic, value });
+    }
+    createConstant(value) {
+        assertDecimal(value);
+        return deepFreeze({ type: 'constant', value });
+    }
+    createGroup(expression, options) {
+        if (options?.semantic !== undefined) {
+            assertSemantic(options.semantic);
+        }
+        if (options?.role !== undefined &&
+            !GROUP_ROLES.has(options.role)) {
+            throw new CalculationBreakdownError('INVALID_GROUP_ROLE', `Unsupported group role: ${String(options.role)}`);
+        }
+        if (options?.orientation !== undefined &&
+            !GROUP_ORIENTATIONS.has(options.orientation)) {
+            throw new CalculationBreakdownError('INVALID_GROUP_ORIENTATION', `Unsupported group orientation: ${String(options.orientation)}`);
+        }
+        return deepFreeze({
+            type: 'group',
+            expression,
+            ...(options?.wrap === true ? { wrap: true } : {}),
+            ...(options?.semantic !== undefined
+                ? { semantic: options.semantic }
+                : {}),
+            ...(options?.result !== undefined
+                ? { result: options.result }
+                : {}),
+            ...(options?.role !== undefined
+                ? { role: options.role }
+                : {}),
+            ...(options?.orientation !== undefined
+                ? { orientation: options.orientation }
+                : {}),
+        });
+    }
+    createOperation(left, operator, right) {
+        const normalizedOperator = OPERATOR_ALIASES[operator] ?? operator;
+        if (!OPERATORS.has(normalizedOperator)) {
+            throw new CalculationBreakdownError('INVALID_OPERATOR', `Unsupported operator: ${operator}`);
+        }
+        return deepFreeze({
+            type: 'operation',
+            operator: normalizedOperator,
+            operands: [left, right],
+        });
+    }
+}
+//# sourceMappingURL=calculation-breakdown-builder.js.map

package/dist/calculation-breakdown-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculation-breakdown-builder.js","sourceRoot":"","sources":["../src/calculation-breakdown-builder.ts"],"names":[],"mappings":"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"}

package/dist/calculation-breakdown-human-string.d.ts

@@ -0,0 +1,24 @@
+import type { ICalculationBreakdown } from './calculation-breakdown.interface.js';
+/** Locales supported by the built-in human-readable renderer. */
+export type TCalculationBreakdownLocale = 'en' | 'cs';
+/** A semantic label with optional explanatory copy for richer UIs. */
+export interface ICalculationBreakdownDictionaryEntry {
+    readonly name: string;
+    readonly description: string;
+}
+/** A short label or a label with explanatory copy. */
+export type TCalculationBreakdownDictionaryEntry = string | ICalculationBreakdownDictionaryEntry;
+/** Semantic labels grouped by supported locale. */
+export type TCalculationBreakdownDictionary<Semantic extends string> = Partial<Record<TCalculationBreakdownLocale, Partial<Record<Semantic, TCalculationBreakdownDictionaryEntry>>>>;
+/** Options for rendering a calculation breakdown as human-readable text. */
+export interface ICalculationBreakdownHumanStringOptions<Semantic extends string> {
+    /** Language and decimal separator used by the renderer. */
+    readonly locale: TCalculationBreakdownLocale;
+    /** Localized labels for domain semantics. Missing labels use the semantic key. */
+    readonly dictionary: TCalculationBreakdownDictionary<Semantic>;
+    /** Whether semantic names are appended to values. Defaults to true. */
+    readonly includeNames?: boolean;
+}
+/** Renders a plain calculation breakdown without changing its serialized form. */
+export declare function toHumanString<Semantic extends string>(calculation: ICalculationBreakdown<Semantic>, options: ICalculationBreakdownHumanStringOptions<Semantic>): string;
+//# sourceMappingURL=calculation-breakdown-human-string.d.ts.map

package/dist/calculation-breakdown-human-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculation-breakdown-human-string.d.ts","sourceRoot":"","sources":["../src/calculation-breakdown-human-string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAOlF,iEAAiE;AACjE,MAAM,MAAM,2BAA2B,GAAG,IAAI,GAAG,IAAI,CAAC;AAEtD,sEAAsE;AACtE,MAAM,WAAW,oCAAoC;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAChC;AAED,sDAAsD;AACtD,MAAM,MAAM,oCAAoC,GAC1C,MAAM,GACN,oCAAoC,CAAC;AAE3C,mDAAmD;AACnD,MAAM,MAAM,+BAA+B,CAAC,QAAQ,SAAS,MAAM,IAAI,OAAO,CAC1E,MAAM,CACF,2BAA2B,EAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,oCAAoC,CAAC,CAAC,CAClE,CACJ,CAAC;AAEF,4EAA4E;AAC5E,MAAM,WAAW,uCAAuC,CACpD,QAAQ,SAAS,MAAM;IAEvB,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,+BAA+B,CAAC,QAAQ,CAAC,CAAC;IAC/D,uEAAuE;IACvE,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACnC;AAiID,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,QAAQ,SAAS,MAAM,EACjD,WAAW,EAAE,qBAAqB,CAAC,QAAQ,CAAC,EAC5C,OAAO,EAAE,uCAAuC,CAAC,QAAQ,CAAC,GAC3D,MAAM,CAER"}

package/dist/calculation-breakdown-human-string.js

@@ -0,0 +1,86 @@
+const INFIX_OPERATORS = {
+    add: '+',
+    subtract: '−',
+    multiply: '×',
+    divide: '÷',
+};
+function localizeDecimal(value, locale) {
+    return locale === 'cs' ? value.replace('.', ',') : value;
+}
+function decimalToPercent(value) {
+    const negative = value.startsWith('-');
+    const unsigned = negative ? value.slice(1) : value;
+    const [whole = '0', fraction = ''] = unsigned.split('.');
+    const digits = `${whole}${fraction}`;
+    const decimalIndex = whole.length + 2;
+    const padded = digits.padEnd(decimalIndex, '0');
+    const integer = padded
+        .slice(0, decimalIndex)
+        .replace(/^0+(?=\d)/, '');
+    const decimals = padded.slice(decimalIndex).replace(/0+$/, '');
+    return `${negative ? '-' : ''}${integer}${decimals ? `.${decimals}` : ''}`;
+}
+function localizeDurationUnit(amount, unit, locale) {
+    const singularUnit = unit.slice(0, -1);
+    const unitPart = new Intl.NumberFormat(locale, {
+        style: 'unit',
+        unit: singularUnit,
+        unitDisplay: 'long',
+        useGrouping: false,
+    })
+        .formatToParts(Number(amount))
+        .find((part) => part.type === 'unit');
+    if (!unitPart) {
+        throw new Error(`Unable to localize duration unit: ${unit}`);
+    }
+    return unitPart.value;
+}
+function labelValue(value, semantic, options) {
+    if (options.includeNames === false)
+        return value;
+    const entry = options.dictionary[options.locale]?.[semantic];
+    const label = typeof entry === 'string' ? entry : (entry?.name ?? semantic);
+    return `${value} ${label}`;
+}
+function renderValue(value, options) {
+    const rawDecimal = value.type === 'number' || value.type === 'percent'
+        ? value.value
+        : value.amount;
+    const decimal = localizeDecimal(rawDecimal, options.locale);
+    if (value.type === 'money') {
+        return labelValue(`${decimal} ${value.currency}`, value.semantic, options);
+    }
+    if (value.type === 'duration') {
+        return labelValue(`${decimal} ${localizeDurationUnit(value.amount, value.unit, options.locale)}`, value.semantic, options);
+    }
+    if (value.type === 'percent') {
+        return labelValue(`${localizeDecimal(decimalToPercent(value.value), options.locale)}%`, value.semantic, options);
+    }
+    return labelValue(decimal, value.semantic, options);
+}
+function renderNode(node, options, nested = false) {
+    if (node.type === 'constant') {
+        return localizeDecimal(node.value, options.locale);
+    }
+    if (node.type === 'group') {
+        const result = node.result
+            ? ` = ${renderValue(node.result, options)}`
+            : '';
+        return `(${renderNode(node.expression, options)}${result})`;
+    }
+    if (node.type !== 'operation') {
+        return renderValue(node, options);
+    }
+    const [left, right] = node.operands;
+    if (node.operator === 'minimum' || node.operator === 'maximum') {
+        const functionName = node.operator === 'minimum' ? 'min' : 'max';
+        return `${functionName}(${renderNode(left, options)}, ${renderNode(right, options)})`;
+    }
+    const rendered = `${renderNode(left, options, true)} ${INFIX_OPERATORS[node.operator]} ${renderNode(right, options, true)}`;
+    return nested ? `(${rendered})` : rendered;
+}
+/** Renders a plain calculation breakdown without changing its serialized form. */
+export function toHumanString(calculation, options) {
+    return `${renderNode(calculation.breakdown, options)} = ${renderValue(calculation.result, options)}`;
+}
+//# sourceMappingURL=calculation-breakdown-human-string.js.map