shareneus 1.6.22 → 1.6.23

package/dist/transaction-calculations/index.d.ts

@@ -0,0 +1 @@
+export { TransactionCalculationEngine } from "./transaction-calculation-engine";

package/dist/transaction-calculations/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionCalculationEngine = void 0;
+var transaction_calculation_engine_1 = require("./transaction-calculation-engine");
+Object.defineProperty(exports, "TransactionCalculationEngine", { enumerable: true, get: function () { return transaction_calculation_engine_1.TransactionCalculationEngine; } });

package/dist/transaction-calculations/transaction-calculation-engine.d.ts

@@ -0,0 +1,242 @@
+export interface ReverseCalculationInput {
+    total: number;
+    qty: number;
+    discount: number;
+    overallDiscount: number;
+    totalTaxRate: number;
+    isIndependentTax: boolean;
+}
+export interface TaxTotalOptions {
+    includeTaxInTotal: boolean;
+}
+export declare class TransactionCalculationEngine {
+    /**
+     * Summarizes a taxes array.
+     *
+     * Supported row shapes (case-tolerant):
+     *  - `{ Amt: number }`  (preferred for totals)
+     *  - `{ Rate: number }` (preferred for reverse calc if Amt not present)
+     */
+    static getTaxesSummary(taxes: any): {
+        taxAmount: number;
+        taxRate: number;
+    };
+    static sumTaxAmountFromRows(rows: unknown): number;
+    static calculateTotalFromTaxRows(input: {
+        baseAmount: number;
+        taxRows: unknown;
+        options: TaxTotalOptions;
+    }): number;
+    static calculateSubtotalFromTotalUsingTaxes(input: {
+        total: number;
+        taxRows: unknown;
+        includeTaxInTotal: boolean;
+    }): number;
+    static reverseCalculateAmountAndUnitPriceFromTotal(input: {
+        qty: number;
+        total: number;
+        disc: number;
+        recDisc: number;
+        noDisc: boolean;
+        taxRows: unknown;
+        includeTaxInTotal: boolean;
+    }): {
+        amount: number;
+        unitPrice: number;
+    };
+    static calculatePriceFromTotal(input: ReverseCalculationInput): number;
+    /**
+     * Returns the sum of all component rates for a tax code id.
+     *
+     * Safe for missing inputs:
+     *  - empty TaxCodes
+     *  - TCode not found
+     *  - empty Components
+     */
+    static getGSTRateSumByTaxCode(TCode: any, TaxCodes: any[]): number;
+    /**
+     * Calculates the raw base amount for an item:
+     *   unAmt = qty * unpr
+     *
+     * Returns a shallow copy of the item with `unAmt` set.
+     */
+    static calculateItemAmount(item: any): any;
+    /**
+     * Calculates the item-level (record-level) discount applied to a single item.
+     *
+     * Rules:
+     *  - If `NoDisc` is true  → recDisc = 0
+     *  - Else if `perc` exists → recDisc = qty * unpr * (perc / 100)
+     *  - Else                  → recDisc = disc (flat amount)
+     *
+     * Returns a shallow copy of the item with `recDisc` set.
+     */
+    static calculateItemDiscount(item: any): any;
+    /**
+     * Calculates subtotal, tax amount, and total for an item using forward logic
+     * (price/qty → total).
+     *
+     *   subtotal  = (qty * unpr) − recDisc
+     *   taxAmount = subtotal * (tax / 100)
+     *   total     = subtotal + taxAmount
+     *
+     * Returns a shallow copy of the item with `subtotal`, `taxAmount`, and
+     * `total` set.
+     */
+    static calculateItemForwardTotal(item: any): any;
+    /**
+     * Calculates subtotal, taxAmount, and total for an item using a `Taxes` array.
+     *
+     * Rules:
+     *  - subtotal  = (qty * unpr) − recDisc
+     *  - taxAmount = Σ Taxes[].Amt  (if missing/0, falls back to Σ Taxes[].Rate %)
+     *  - total     = subtotal + taxAmount  (when includeTaxInTotal = true)
+     *
+     * Notes:
+     *  - If you want a "pre-tax total" line, pass includeTaxInTotal = false.
+     */
+    static calculateItemForwardTotalUsingTaxes(item: any, options?: {
+        includeTaxInTotal?: boolean;
+    }): any;
+    /**
+     * Reverse-calculates `unpr` from a manually entered `total`.
+     *
+     * Steps:
+     *   subtotal  = total / (1 + tax / 100)   [strips tax]
+     *   baseAmt   = subtotal + recDisc         [adds back discount]
+     *   unpr      = baseAmt / qty              [per-unit price]
+     *
+     * Guards:
+     *  - If `qty` is 0 the calculation is skipped and the item is returned unchanged.
+     *  - If `tax` is 0 the divisor reduces to 1 (safe).
+     *
+     * Returns a shallow copy of the item with `unpr` (and derived `unAmt`) updated.
+     */
+    static calculateReverseFromTotal(item: any): any;
+    /**
+     * Reverse-calculates `unpr` from a manually entered `total`, supporting the
+     * same `disc`/`perc` semantics as `calculateItemDiscount`.
+     *
+     * This is intentionally tolerant of existing calling conventions:
+     *  - `item.extraDisc` can be provided to represent an additional discount
+     *    amount that should be added on top of the row discount (e.g. overall /
+     *    record-level discount allocation). It is ignored when `NoDisc` is true.
+     *  - When `tax` is 0, tax stripping becomes a no-op.
+     *
+     * Returns a shallow copy of the item with `unpr`, `unAmt`, and `recDisc` set.
+     */
+    static calculateReverseFromTotalUsingDiscPerc(item: any): any;
+    /**
+     * Reverse-calculates `unpr` from a manually entered `total` using a `Taxes` array.
+     *
+     * When taxes contain `Amt` rows, the reverse "strips tax" by subtracting the
+     * summed tax amount. If tax `Amt` is 0/missing, it falls back to stripping by
+     * summed tax `Rate` (same as `calculateReverseFromTotalUsingDiscPerc`).
+     *
+     * Inputs:
+     *  - qty, total, disc, perc, extraDisc, NoDisc
+     *  - Taxes: array of `{ Amt?, Rate? }`
+     */
+    static calculateReverseFromTotalUsingDiscPercAndTaxes(item: any, options?: {
+        includeTaxInTotal?: boolean;
+    }): any;
+    /**
+     * Applies an item-only discount (`PDisc` / `PPerc`) to an array of items.
+     *
+     * Rules:
+     *  - Items with `NoDisc = true` are skipped.
+     *  - If `PPerc` is provided: each item's share = its netAmt * (PPerc / 100)
+     *  - Otherwise: `PDisc` is distributed proportionally by each item's `unAmt`.
+     *
+     * The `recDisc` on each item is **added to** any existing item-level discount
+     * so that both record-level and overall PDisc coexist correctly.
+     *
+     * Returns a new array of updated item objects.
+     */
+    static applyPDiscountToItems(items: any[], PDisc: any, PPerc: any): any[];
+    /**
+     * Applies an ops-only discount (`LDisc` / `LPerc`) to an array of ops.
+     *
+     * Rules:
+     *  - If `LPerc` is provided: each op's share = its `amount` * (LPerc / 100)
+     *  - Otherwise: `LDisc` is distributed proportionally by each op's `amount`.
+     *
+     * Returns a new array of updated ops objects.
+     */
+    static applyLDiscountToOps(ops: any[], LDisc: any, LPerc: any): any[];
+    /**
+     * Applies a cross-line discount (`Disc` / `Prec`) proportionally across
+     * both items and ops.
+     *
+     * Rules:
+     *  - Items with `NoDisc = true` are excluded from the base but returned unchanged.
+     *  - If `Prec` is provided: share = row's base * (Prec / 100)
+     *  - Otherwise: `Disc` is distributed proportionally across the combined base
+     *    (items by `unAmt`, ops by `amount`).
+     *
+     * Returns `{ items, ops }` with updated `recDisc` values.
+     */
+    static applyCommonDiscount(items: any[], ops: any[], Disc: any, Prec: any): {
+        items: any[];
+        ops: any[];
+    };
+    /**
+     * Orchestration method that applies all transaction-level discounts in the
+     * correct order:
+     *
+     *   1. applyPDiscountToItems  (PDisc / PPerc)
+     *   2. applyLDiscountToOps   (LDisc / LPerc)
+     *   3. applyCommonDiscount   (Disc  / Prec)
+     *
+     * The `recDisc` on each line starts fresh from its item-level discount
+     * (already computed by `calculateItemDiscount`) before overall discounts
+     * are stacked on top.
+     *
+     * Returns `{ items, ops }`.
+     */
+    static distributeRecordDiscount(items: any[], ops: any[], transaction: any): {
+        items: any[];
+        ops: any[];
+    };
+    /**
+     * Master recalculation method.
+     *
+     * Call whenever any value in the transaction changes:
+     *   qty | unpr | disc | perc | tax | PDisc | PPerc | LDisc | LPerc | Disc | Prec
+     *   or when items / ops are added or removed.
+     *
+     * Processing pipeline:
+     *   For each item:
+     *     a. calculateItemAmount          → unAmt
+     *     b. calculateItemDiscount        → item-level recDisc
+     *   →  distributeRecordDiscount       → stacks overall discounts onto recDisc
+     *   For each item:
+     *     c. calculateItemForwardTotal    → subtotal, taxAmount, total
+     *   For each op:
+     *     d. recalculate op total         → amount − recDisc
+     *   →  computeTransactionTotals       → subTotal, taxTotal, grandTotal
+     *
+     * Returns a new transaction object (shallow-copied) with updated
+     * `Items`, `Ops`, and summary totals (`SubTotal`, `TaxTotal`, `Total`).
+     *
+     * The original transaction object is never mutated.
+     *
+     * ⚠️  When writing results back to Reactive Form controls always use
+     *     `{ emitEvent: false }` to prevent triggering another recalculation.
+     */
+    static recalculateTransaction(transaction: any): any;
+    /**
+     * Computes summary totals from already-calculated items and ops.
+     *
+     *   subTotal   = Σ item.subtotal + Σ op.total
+     *   taxTotal   = Σ item.taxAmount
+     *   grandTotal = subTotal + taxTotal
+     *
+     * Returns `{ subTotal, taxTotal, grandTotal }`.
+     */
+    static computeTransactionTotals(items: any[], ops: any[]): {
+        subTotal: number;
+        taxTotal: number;
+        grandTotal: number;
+    };
+}

package/dist/transaction-calculations/transaction-calculation-engine.js

@@ -0,0 +1,701 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionCalculationEngine = void 0;
+const math_operations_1 = require("../shared/math-operations");
+/**
+ * TransactionCalculationEngine
+ *
+ * Reusable pure-calculation module for ERP-style transactions:
+ *   Invoice | Bill | Sales Order | Delivery Challan | Purchase Order
+ *
+ * All methods are static and side-effect-free.
+ * Callers are responsible for writing results back to Reactive Form controls
+ * using { emitEvent: false } to prevent infinite loops.
+ *
+ * Monetary values are not rounded by this engine.
+ *
+ * Item fields used:
+ *   qty, unpr, unAmt, disc, perc, recDisc, tax, total, NoDisc
+ *
+ * Ops fields used:
+ *   amount, recDisc
+ *
+ * Transaction-level discount fields:
+ *   PDisc / PPerc  → items only
+ *   LDisc / LPerc  → ops only
+ *   Disc  / Prec   → items + ops proportionally
+ */
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function toNum(value) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+}
+function isNullOrEmpty(value) {
+    return (value === null || value === undefined || value === '' || value === 'null');
+}
+function getTaxesArray(value) {
+    var _a, _b;
+    const taxes = (_b = (_a = value === null || value === void 0 ? void 0 : value.Taxes) !== null && _a !== void 0 ? _a : value === null || value === void 0 ? void 0 : value.taxes) !== null && _b !== void 0 ? _b : value;
+    return Array.isArray(taxes) ? taxes : [];
+}
+function sumTaxAmountFromTaxes(taxes) {
+    const rows = getTaxesArray(taxes);
+    return rows.reduce((sum, row) => { var _a; return (0, math_operations_1.Add)(sum, toNum((_a = row === null || row === void 0 ? void 0 : row.Amt) !== null && _a !== void 0 ? _a : row === null || row === void 0 ? void 0 : row.amt)); }, 0);
+}
+function sumTaxRateFromTaxes(taxes) {
+    const rows = getTaxesArray(taxes);
+    return rows.reduce((sum, row) => { var _a; return (0, math_operations_1.Add)(sum, toNum((_a = row === null || row === void 0 ? void 0 : row.Rate) !== null && _a !== void 0 ? _a : row === null || row === void 0 ? void 0 : row.rate)); }, 0);
+}
+/**
+ * Distribute a flat discount amount across a set of rows proportionally
+ * by each row's `baseKey` value. Returns an array of share amounts aligned
+ * with the input rows.
+ *
+ * The last row absorbs any remainder so the sum always equals discAmt.
+ */
+function distributeProportionally(rows, discAmt, baseKey) {
+    const total = rows.reduce((sum, row) => (0, math_operations_1.Add)(sum, toNum(row[baseKey])), 0);
+    if (total === 0) {
+        return rows.map(() => 0);
+    }
+    const shares = [];
+    let allocated = 0;
+    rows.forEach((row, index) => {
+        if (index === rows.length - 1) {
+            // Last row: give the remainder to avoid floating-point drift
+            shares.push((0, math_operations_1.Subtract)(discAmt, allocated));
+        }
+        else {
+            const share = (0, math_operations_1.Multiply)((0, math_operations_1.Divide)(toNum(row[baseKey]), total), discAmt);
+            shares.push(share);
+            allocated = (0, math_operations_1.Add)(allocated, share);
+        }
+    });
+    return shares;
+}
+// ---------------------------------------------------------------------------
+// Public engine
+// ---------------------------------------------------------------------------
+class TransactionCalculationEngine {
+    // -------------------------------------------------------------------------
+    // Taxes helpers (Amt-based + Rate-based)
+    // -------------------------------------------------------------------------
+    /**
+     * Summarizes a taxes array.
+     *
+     * Supported row shapes (case-tolerant):
+     *  - `{ Amt: number }`  (preferred for totals)
+     *  - `{ Rate: number }` (preferred for reverse calc if Amt not present)
+     */
+    static getTaxesSummary(taxes) {
+        return {
+            taxAmount: sumTaxAmountFromTaxes(taxes),
+            taxRate: sumTaxRateFromTaxes(taxes),
+        };
+    }
+    static sumTaxAmountFromRows(rows) {
+        if (!Array.isArray(rows)) {
+            return 0;
+        }
+        return rows.reduce((sum, row) => {
+            return (0, math_operations_1.Add)(sum, toNum(row === null || row === void 0 ? void 0 : row.Amt));
+        }, 0);
+    }
+    static calculateTotalFromTaxRows(input) {
+        const baseAmount = toNum(input.baseAmount);
+        const taxAmount = TransactionCalculationEngine.sumTaxAmountFromRows(input.taxRows);
+        return input.options.includeTaxInTotal
+            ? (0, math_operations_1.Add)(baseAmount, taxAmount)
+            : baseAmount;
+    }
+    static calculateSubtotalFromTotalUsingTaxes(input) {
+        const total = toNum(input.total);
+        if (!input.includeTaxInTotal) {
+            return total;
+        }
+        const taxSummary = TransactionCalculationEngine.getTaxesSummary(input.taxRows);
+        if (taxSummary.taxRate) {
+            const divisor = (0, math_operations_1.Add)(1, (0, math_operations_1.Divide)(taxSummary.taxRate, 100));
+            return divisor === 0 ? total : (0, math_operations_1.Divide)(total, divisor);
+        }
+        return (0, math_operations_1.Subtract)(total, taxSummary.taxAmount);
+    }
+    static reverseCalculateAmountAndUnitPriceFromTotal(input) {
+        const qty = toNum(input.qty) || 1;
+        const subtotal = TransactionCalculationEngine.calculateSubtotalFromTotalUsingTaxes({
+            total: input.total,
+            taxRows: input.taxRows,
+            includeTaxInTotal: input.includeTaxInTotal,
+        });
+        const disc = toNum(input.disc);
+        const recDisc = toNum(input.recDisc);
+        const amount = input.noDisc
+            ? subtotal
+            : (0, math_operations_1.Add)(subtotal, (0, math_operations_1.Add)(disc, recDisc));
+        const unitPrice = (0, math_operations_1.Divide)(amount, qty);
+        return { amount, unitPrice };
+    }
+    // Shared reverse-calculation formula. Components only need to supply their own field mapping.
+    static calculatePriceFromTotal(input) {
+        const qty = toNum(input.qty) || 1;
+        const total = toNum(input.total);
+        const discount = toNum(input.discount);
+        const overallDiscount = toNum(input.overallDiscount);
+        const totalTaxRate = toNum(input.totalTaxRate);
+        const taxableBase = input.isIndependentTax
+            ? (0, math_operations_1.Divide)(total, (0, math_operations_1.Add)(1, (0, math_operations_1.Divide)(totalTaxRate, 100)))
+            : total;
+        return (0, math_operations_1.Divide)((0, math_operations_1.Add)((0, math_operations_1.Add)(taxableBase, discount), overallDiscount), qty);
+    }
+    /**
+     * Returns the sum of all component rates for a tax code id.
+     *
+     * Safe for missing inputs:
+     *  - empty TaxCodes
+     *  - TCode not found
+     *  - empty Components
+     */
+    static getGSTRateSumByTaxCode(TCode, TaxCodes) {
+        if (isNullOrEmpty(TCode) || !Array.isArray(TaxCodes)) {
+            return 0;
+        }
+        const taxCode = TaxCodes.find((code) => (code === null || code === void 0 ? void 0 : code._id) === TCode);
+        const components = Array.isArray(taxCode === null || taxCode === void 0 ? void 0 : taxCode.Components)
+            ? taxCode.Components
+            : [];
+        return components.reduce((sum, comp) => (0, math_operations_1.Add)(sum, toNum(comp === null || comp === void 0 ? void 0 : comp.Rate)), 0);
+    }
+    // -------------------------------------------------------------------------
+    // 1. calculateItemAmount
+    // -------------------------------------------------------------------------
+    /**
+     * Calculates the raw base amount for an item:
+     *   unAmt = qty * unpr
+     *
+     * Returns a shallow copy of the item with `unAmt` set.
+     */
+    static calculateItemAmount(item) {
+        const qty = toNum(item.qty);
+        const unpr = toNum(item.unpr);
+        return Object.assign(Object.assign({}, item), { unAmt: (0, math_operations_1.Multiply)(qty, unpr) });
+    }
+    // -------------------------------------------------------------------------
+    // 2. calculateItemDiscount
+    // -------------------------------------------------------------------------
+    /**
+     * Calculates the item-level (record-level) discount applied to a single item.
+     *
+     * Rules:
+     *  - If `NoDisc` is true  → recDisc = 0
+     *  - Else if `perc` exists → recDisc = qty * unpr * (perc / 100)
+     *  - Else                  → recDisc = disc (flat amount)
+     *
+     * Returns a shallow copy of the item with `recDisc` set.
+     */
+    static calculateItemDiscount(item) {
+        if (item.NoDisc) {
+            return Object.assign(Object.assign({}, item), { recDisc: 0 });
+        }
+        const qty = toNum(item.qty);
+        const unpr = toNum(item.unpr);
+        const perc = toNum(item.perc);
+        const disc = toNum(item.disc);
+        const recDisc = !isNullOrEmpty(item.perc) && perc !== 0
+            ? (0, math_operations_1.Multiply)((0, math_operations_1.Multiply)(qty, unpr), (0, math_operations_1.Divide)(perc, 100))
+            : disc;
+        return Object.assign(Object.assign({}, item), { recDisc });
+    }
+    // -------------------------------------------------------------------------
+    // 3. calculateItemForwardTotal
+    // -------------------------------------------------------------------------
+    /**
+     * Calculates subtotal, tax amount, and total for an item using forward logic
+     * (price/qty → total).
+     *
+     *   subtotal  = (qty * unpr) − recDisc
+     *   taxAmount = subtotal * (tax / 100)
+     *   total     = subtotal + taxAmount
+     *
+     * Returns a shallow copy of the item with `subtotal`, `taxAmount`, and
+     * `total` set.
+     */
+    static calculateItemForwardTotal(item) {
+        const qty = toNum(item.qty);
+        const unpr = toNum(item.unpr);
+        const recDisc = toNum(item.recDisc);
+        const tax = toNum(item.tax);
+        const subtotal = (0, math_operations_1.Subtract)((0, math_operations_1.Multiply)(qty, unpr), recDisc);
+        const taxAmount = (0, math_operations_1.Divide)((0, math_operations_1.Multiply)(subtotal, tax), 100);
+        const total = (0, math_operations_1.Add)(subtotal, taxAmount);
+        return Object.assign(Object.assign({}, item), { subtotal, taxAmount, total });
+    }
+    // -------------------------------------------------------------------------
+    // 3b. calculateItemForwardTotalUsingTaxes
+    // -------------------------------------------------------------------------
+    /**
+     * Calculates subtotal, taxAmount, and total for an item using a `Taxes` array.
+     *
+     * Rules:
+     *  - subtotal  = (qty * unpr) − recDisc
+     *  - taxAmount = Σ Taxes[].Amt  (if missing/0, falls back to Σ Taxes[].Rate %)
+     *  - total     = subtotal + taxAmount  (when includeTaxInTotal = true)
+     *
+     * Notes:
+     *  - If you want a "pre-tax total" line, pass includeTaxInTotal = false.
+     */
+    static calculateItemForwardTotalUsingTaxes(item, options) {
+        var _a;
+        const includeTaxInTotal = (options === null || options === void 0 ? void 0 : options.includeTaxInTotal) !== false;
+        const qty = toNum(item.qty);
+        const unpr = toNum(item.unpr);
+        const recDisc = toNum(item.recDisc);
+        const subtotal = (0, math_operations_1.Subtract)((0, math_operations_1.Multiply)(qty, unpr), recDisc);
+        const taxes = (_a = item === null || item === void 0 ? void 0 : item.Taxes) !== null && _a !== void 0 ? _a : item === null || item === void 0 ? void 0 : item.taxes;
+        const taxSummary = TransactionCalculationEngine.getTaxesSummary(taxes);
+        const taxAmount = taxSummary.taxAmount !== 0
+            ? taxSummary.taxAmount
+            : (0, math_operations_1.Divide)((0, math_operations_1.Multiply)(subtotal, taxSummary.taxRate), 100);
+        const total = (0, math_operations_1.Add)(subtotal, includeTaxInTotal ? taxAmount : 0);
+        return Object.assign(Object.assign({}, item), { subtotal, taxAmount, total });
+    }
+    // -------------------------------------------------------------------------
+    // 4. calculateReverseFromTotal
+    // -------------------------------------------------------------------------
+    /**
+     * Reverse-calculates `unpr` from a manually entered `total`.
+     *
+     * Steps:
+     *   subtotal  = total / (1 + tax / 100)   [strips tax]
+     *   baseAmt   = subtotal + recDisc         [adds back discount]
+     *   unpr      = baseAmt / qty              [per-unit price]
+     *
+     * Guards:
+     *  - If `qty` is 0 the calculation is skipped and the item is returned unchanged.
+     *  - If `tax` is 0 the divisor reduces to 1 (safe).
+     *
+     * Returns a shallow copy of the item with `unpr` (and derived `unAmt`) updated.
+     */
+    static calculateReverseFromTotal(item) {
+        const qty = toNum(item.qty);
+        const total = toNum(item.total);
+        const recDisc = toNum(item.recDisc);
+        const tax = toNum(item.tax);
+        if (qty === 0) {
+            // Cannot reverse without a quantity – return item unchanged
+            return Object.assign({}, item);
+        }
+        const divisor = (0, math_operations_1.Add)(1, (0, math_operations_1.Divide)(tax, 100));
+        const subtotal = (0, math_operations_1.Divide)(total, divisor === 0 ? 1 : divisor);
+        const baseAmt = (0, math_operations_1.Add)(subtotal, recDisc);
+        const unpr = (0, math_operations_1.Divide)(baseAmt, qty);
+        const unAmt = (0, math_operations_1.Multiply)(qty, unpr);
+        return Object.assign(Object.assign({}, item), { unpr, unAmt });
+    }
+    // -------------------------------------------------------------------------
+    // 4b. calculateReverseFromTotalUsingDiscPerc
+    // -------------------------------------------------------------------------
+    /**
+     * Reverse-calculates `unpr` from a manually entered `total`, supporting the
+     * same `disc`/`perc` semantics as `calculateItemDiscount`.
+     *
+     * This is intentionally tolerant of existing calling conventions:
+     *  - `item.extraDisc` can be provided to represent an additional discount
+     *    amount that should be added on top of the row discount (e.g. overall /
+     *    record-level discount allocation). It is ignored when `NoDisc` is true.
+     *  - When `tax` is 0, tax stripping becomes a no-op.
+     *
+     * Returns a shallow copy of the item with `unpr`, `unAmt`, and `recDisc` set.
+     */
+    static calculateReverseFromTotalUsingDiscPerc(item) {
+        const qty = toNum(item.qty);
+        const total = toNum(item.total);
+        const tax = toNum(item.tax);
+        const disc = toNum(item.disc);
+        const perc = toNum(item.perc);
+        const extraDisc = toNum(item.extraDisc);
+        if (qty === 0) {
+            return Object.assign({}, item);
+        }
+        const divisor = (0, math_operations_1.Add)(1, (0, math_operations_1.Divide)(tax, 100));
+        const subtotal = (0, math_operations_1.Divide)(total, divisor === 0 ? 1 : divisor);
+        if (item.NoDisc) {
+            const unpr = (0, math_operations_1.Divide)(subtotal, qty);
+            const unAmt = (0, math_operations_1.Multiply)(qty, unpr);
+            return Object.assign(Object.assign({}, item), { unpr, unAmt, recDisc: 0 });
+        }
+        // Percentage path: solve for unpr algebraically because recDisc depends on unpr
+        if (!isNullOrEmpty(item.perc) && perc !== 0) {
+            const discountRate = (0, math_operations_1.Divide)(perc, 100);
+            const priceFactor = (0, math_operations_1.Subtract)(1, discountRate);
+            if (priceFactor === 0) {
+                return Object.assign({}, item);
+            }
+            const unpr = (0, math_operations_1.Divide)((0, math_operations_1.Add)(subtotal, extraDisc), (0, math_operations_1.Multiply)(qty, priceFactor));
+            const unAmt = (0, math_operations_1.Multiply)(qty, unpr);
+            const rowDisc = (0, math_operations_1.Multiply)(unAmt, discountRate);
+            const recDisc = (0, math_operations_1.Add)(rowDisc, extraDisc);
+            return Object.assign(Object.assign({}, item), { unpr, unAmt, recDisc });
+        }
+        // Flat amount path
+        const recDisc = (0, math_operations_1.Add)(disc, extraDisc);
+        const unpr = (0, math_operations_1.Divide)((0, math_operations_1.Add)(subtotal, recDisc), qty);
+        const unAmt = (0, math_operations_1.Multiply)(qty, unpr);
+        return Object.assign(Object.assign({}, item), { unpr, unAmt, recDisc });
+    }
+    // -------------------------------------------------------------------------
+    // 4c. calculateReverseFromTotalUsingDiscPercAndTaxes
+    // -------------------------------------------------------------------------
+    /**
+     * Reverse-calculates `unpr` from a manually entered `total` using a `Taxes` array.
+     *
+     * When taxes contain `Amt` rows, the reverse "strips tax" by subtracting the
+     * summed tax amount. If tax `Amt` is 0/missing, it falls back to stripping by
+     * summed tax `Rate` (same as `calculateReverseFromTotalUsingDiscPerc`).
+     *
+     * Inputs:
+     *  - qty, total, disc, perc, extraDisc, NoDisc
+     *  - Taxes: array of `{ Amt?, Rate? }`
+     */
+    static calculateReverseFromTotalUsingDiscPercAndTaxes(item, options) {
+        var _a;
+        const includeTaxInTotal = (options === null || options === void 0 ? void 0 : options.includeTaxInTotal) !== false;
+        const qty = toNum(item.qty);
+        const total = toNum(item.total);
+        const disc = toNum(item.disc);
+        const perc = toNum(item.perc);
+        const extraDisc = toNum(item.extraDisc);
+        if (qty === 0) {
+            return Object.assign({}, item);
+        }
+        const taxSummary = TransactionCalculationEngine.getTaxesSummary((_a = item === null || item === void 0 ? void 0 : item.Taxes) !== null && _a !== void 0 ? _a : item === null || item === void 0 ? void 0 : item.taxes);
+        // If total doesn't include tax, treat it as "already stripped".
+        const subtotal = includeTaxInTotal
+            ? taxSummary.taxAmount !== 0
+                ? (0, math_operations_1.Subtract)(total, taxSummary.taxAmount)
+                : (() => {
+                    const divisor = (0, math_operations_1.Add)(1, (0, math_operations_1.Divide)(taxSummary.taxRate, 100));
+                    return (0, math_operations_1.Divide)(total, divisor === 0 ? 1 : divisor);
+                })()
+            : total;
+        if (item.NoDisc) {
+            const unpr = (0, math_operations_1.Divide)(subtotal, qty);
+            const unAmt = (0, math_operations_1.Multiply)(qty, unpr);
+            return Object.assign(Object.assign({}, item), { unpr, unAmt, recDisc: 0 });
+        }
+        // Percentage path: solve for unpr algebraically because row discount depends on unpr.
+        if (!isNullOrEmpty(item.perc) && perc !== 0) {
+            const discountRate = (0, math_operations_1.Divide)(perc, 100);
+            const priceFactor = (0, math_operations_1.Subtract)(1, discountRate);
+            if (priceFactor === 0) {
+                return Object.assign({}, item);
+            }
+            const unpr = (0, math_operations_1.Divide)((0, math_operations_1.Add)(subtotal, extraDisc), (0, math_operations_1.Multiply)(qty, priceFactor));
+            const unAmt = (0, math_operations_1.Multiply)(qty, unpr);
+            const rowDisc = (0, math_operations_1.Multiply)(unAmt, discountRate);
+            const recDisc = (0, math_operations_1.Add)(rowDisc, extraDisc);
+            return Object.assign(Object.assign({}, item), { unpr, unAmt, recDisc });
+        }
+        const recDisc = (0, math_operations_1.Add)(disc, extraDisc);
+        const unpr = (0, math_operations_1.Divide)((0, math_operations_1.Add)(subtotal, recDisc), qty);
+        const unAmt = (0, math_operations_1.Multiply)(qty, unpr);
+        return Object.assign(Object.assign({}, item), { unpr, unAmt, recDisc });
+    }
+    // -------------------------------------------------------------------------
+    // 5. applyPDiscountToItems
+    // -------------------------------------------------------------------------
+    /**
+     * Applies an item-only discount (`PDisc` / `PPerc`) to an array of items.
+     *
+     * Rules:
+     *  - Items with `NoDisc = true` are skipped.
+     *  - If `PPerc` is provided: each item's share = its netAmt * (PPerc / 100)
+     *  - Otherwise: `PDisc` is distributed proportionally by each item's `unAmt`.
+     *
+     * The `recDisc` on each item is **added to** any existing item-level discount
+     * so that both record-level and overall PDisc coexist correctly.
+     *
+     * Returns a new array of updated item objects.
+     */
+    static applyPDiscountToItems(items, PDisc, PPerc) {
+        if (!Array.isArray(items) || items.length === 0) {
+            return items !== null && items !== void 0 ? items : [];
+        }
+        const discountable = items.filter((i) => !i.NoDisc);
+        // Percentage path
+        if (!isNullOrEmpty(PPerc) && toNum(PPerc) !== 0) {
+            const pperc = toNum(PPerc);
+            return items.map((item) => {
+                if (item.NoDisc)
+                    return Object.assign({}, item);
+                const netAmt = (0, math_operations_1.Subtract)(toNum(item.unAmt), toNum(item.recDisc));
+                const share = (0, math_operations_1.Divide)((0, math_operations_1.Multiply)(netAmt, pperc), 100);
+                return Object.assign(Object.assign({}, item), { recDisc: (0, math_operations_1.Add)(toNum(item.recDisc), share) });
+            });
+        }
+        // Flat-amount proportional path
+        const pdisc = toNum(PDisc);
+        if (pdisc === 0 || discountable.length === 0) {
+            return items.map((i) => (Object.assign({}, i)));
+        }
+        const shares = distributeProportionally(discountable, pdisc, 'unAmt');
+        let shareIdx = 0;
+        return items.map((item) => {
+            var _a;
+            if (item.NoDisc)
+                return Object.assign({}, item);
+            const share = (_a = shares[shareIdx++]) !== null && _a !== void 0 ? _a : 0;
+            return Object.assign(Object.assign({}, item), { recDisc: (0, math_operations_1.Add)(toNum(item.recDisc), share) });
+        });
+    }
+    // -------------------------------------------------------------------------
+    // 6. applyLDiscountToOps
+    // -------------------------------------------------------------------------
+    /**
+     * Applies an ops-only discount (`LDisc` / `LPerc`) to an array of ops.
+     *
+     * Rules:
+     *  - If `LPerc` is provided: each op's share = its `amount` * (LPerc / 100)
+     *  - Otherwise: `LDisc` is distributed proportionally by each op's `amount`.
+     *
+     * Returns a new array of updated ops objects.
+     */
+    static applyLDiscountToOps(ops, LDisc, LPerc) {
+        if (!Array.isArray(ops) || ops.length === 0) {
+            return ops !== null && ops !== void 0 ? ops : [];
+        }
+        // Percentage path
+        if (!isNullOrEmpty(LPerc) && toNum(LPerc) !== 0) {
+            const lperc = toNum(LPerc);
+            return ops.map((op) => {
+                const share = (0, math_operations_1.Divide)((0, math_operations_1.Multiply)(toNum(op.amount), lperc), 100);
+                return Object.assign(Object.assign({}, op), { recDisc: (0, math_operations_1.Add)(toNum(op.recDisc), share) });
+            });
+        }
+        // Flat-amount proportional path
+        const ldisc = toNum(LDisc);
+        if (ldisc === 0) {
+            return ops.map((o) => (Object.assign({}, o)));
+        }
+        const shares = distributeProportionally(ops, ldisc, 'amount');
+        return ops.map((op, i) => {
+            var _a;
+            return (Object.assign(Object.assign({}, op), { recDisc: (0, math_operations_1.Add)(toNum(op.recDisc), (_a = shares[i]) !== null && _a !== void 0 ? _a : 0) }));
+        });
+    }
+    // -------------------------------------------------------------------------
+    // 7. applyCommonDiscount
+    // -------------------------------------------------------------------------
+    /**
+     * Applies a cross-line discount (`Disc` / `Prec`) proportionally across
+     * both items and ops.
+     *
+     * Rules:
+     *  - Items with `NoDisc = true` are excluded from the base but returned unchanged.
+     *  - If `Prec` is provided: share = row's base * (Prec / 100)
+     *  - Otherwise: `Disc` is distributed proportionally across the combined base
+     *    (items by `unAmt`, ops by `amount`).
+     *
+     * Returns `{ items, ops }` with updated `recDisc` values.
+     */
+    static applyCommonDiscount(items, ops, Disc, Prec) {
+        const safeItems = Array.isArray(items) ? items : [];
+        const safeOps = Array.isArray(ops) ? ops : [];
+        const discountableItems = safeItems.filter((i) => !i.NoDisc);
+        // Percentage path
+        if (!isNullOrEmpty(Prec) && toNum(Prec) !== 0) {
+            const prec = toNum(Prec);
+            const updatedItems = safeItems.map((item) => {
+                if (item.NoDisc)
+                    return Object.assign({}, item);
+                // Apply common % discount on the net base after any prior discounts
+                // (item-level discount + PDisc), so discounts stack sequentially.
+                const base = Math.max(0, (0, math_operations_1.Subtract)(toNum(item.unAmt), toNum(item.recDisc)));
+                const share = (0, math_operations_1.Divide)((0, math_operations_1.Multiply)(base, prec), 100);
+                console.log('Disc share', { id: item.id, base, share });
+                return Object.assign(Object.assign({}, item), { recDisc: (0, math_operations_1.Add)(toNum(item.recDisc), share) });
+            });
+            const updatedOps = safeOps.map((op) => {
+                // Apply common % discount on the net base after LDisc.
+                const base = Math.max(0, (0, math_operations_1.Subtract)(toNum(op.amount), toNum(op.recDisc)));
+                const share = (0, math_operations_1.Divide)((0, math_operations_1.Multiply)(base, prec), 100);
+                return Object.assign(Object.assign({}, op), { recDisc: (0, math_operations_1.Add)(toNum(op.recDisc), share) });
+            });
+            return { items: updatedItems, ops: updatedOps };
+        }
+        // Flat-amount proportional path
+        const disc = toNum(Disc);
+        if (disc === 0) {
+            return {
+                items: safeItems.map((i) => (Object.assign({}, i))),
+                ops: safeOps.map((o) => (Object.assign({}, o))),
+            };
+        }
+        // Build a unified list for proportional distribution (no-disc items excluded)
+        const rows = [
+            ...discountableItems.map((i) => ({
+                _key: 'item',
+                _ref: i,
+                base: toNum(i.unAmt),
+            })),
+            ...safeOps.map((o) => ({ _key: 'op', _ref: o, base: toNum(o.amount) })),
+        ];
+        const totalBase = rows.reduce((sum, r) => (0, math_operations_1.Add)(sum, r.base), 0);
+        if (totalBase === 0) {
+            return {
+                items: safeItems.map((i) => (Object.assign({}, i))),
+                ops: safeOps.map((o) => (Object.assign({}, o))),
+            };
+        }
+        // Assign shares
+        let allocated = 0;
+        rows.forEach((row, index) => {
+            let share;
+            if (index === rows.length - 1) {
+                share = (0, math_operations_1.Subtract)(disc, allocated);
+            }
+            else {
+                share = (0, math_operations_1.Multiply)((0, math_operations_1.Divide)(row.base, totalBase), disc);
+                allocated = (0, math_operations_1.Add)(allocated, share);
+            }
+            row._share = share;
+        });
+        // Build result maps
+        const itemShareMap = new Map();
+        const opShareMap = new Map();
+        rows.forEach((row) => {
+            if (row._key === 'item')
+                itemShareMap.set(row._ref, row._share);
+            else
+                opShareMap.set(row._ref, row._share);
+        });
+        const updatedItems = safeItems.map((item) => {
+            var _a;
+            if (item.NoDisc)
+                return Object.assign({}, item);
+            const share = (_a = itemShareMap.get(item)) !== null && _a !== void 0 ? _a : 0;
+            return Object.assign(Object.assign({}, item), { recDisc: (0, math_operations_1.Add)(toNum(item.recDisc), share) });
+        });
+        const updatedOps = safeOps.map((op) => {
+            var _a;
+            const share = (_a = opShareMap.get(op)) !== null && _a !== void 0 ? _a : 0;
+            return Object.assign(Object.assign({}, op), { recDisc: (0, math_operations_1.Add)(toNum(op.recDisc), share) });
+        });
+        return { items: updatedItems, ops: updatedOps };
+    }
+    // -------------------------------------------------------------------------
+    // 8. distributeRecordDiscount
+    // -------------------------------------------------------------------------
+    /**
+     * Orchestration method that applies all transaction-level discounts in the
+     * correct order:
+     *
+     *   1. applyPDiscountToItems  (PDisc / PPerc)
+     *   2. applyLDiscountToOps   (LDisc / LPerc)
+     *   3. applyCommonDiscount   (Disc  / Prec)
+     *
+     * The `recDisc` on each line starts fresh from its item-level discount
+     * (already computed by `calculateItemDiscount`) before overall discounts
+     * are stacked on top.
+     *
+     * Returns `{ items, ops }`.
+     */
+    static distributeRecordDiscount(items, ops, transaction) {
+        const { PDisc, PPerc, LDisc, LPerc, Disc, Prec } = transaction !== null && transaction !== void 0 ? transaction : {};
+        let updatedItems = Array.isArray(items)
+            ? items.map((i) => (Object.assign({}, i)))
+            : [];
+        let updatedOps = Array.isArray(ops)
+            ? ops.map((o) => (Object.assign({}, o)))
+            : [];
+        // Step 1 – items-only discount
+        updatedItems = TransactionCalculationEngine.applyPDiscountToItems(updatedItems, PDisc, PPerc);
+        // Step 2 – ops-only discount
+        updatedOps = TransactionCalculationEngine.applyLDiscountToOps(updatedOps, LDisc, LPerc);
+        // Step 3 – common discount across both
+        const result = TransactionCalculationEngine.applyCommonDiscount(updatedItems, updatedOps, Disc, Prec);
+        return { items: result.items, ops: result.ops };
+    }
+    // -------------------------------------------------------------------------
+    // 9. recalculateTransaction
+    // -------------------------------------------------------------------------
+    /**
+     * Master recalculation method.
+     *
+     * Call whenever any value in the transaction changes:
+     *   qty | unpr | disc | perc | tax | PDisc | PPerc | LDisc | LPerc | Disc | Prec
+     *   or when items / ops are added or removed.
+     *
+     * Processing pipeline:
+     *   For each item:
+     *     a. calculateItemAmount          → unAmt
+     *     b. calculateItemDiscount        → item-level recDisc
+     *   →  distributeRecordDiscount       → stacks overall discounts onto recDisc
+     *   For each item:
+     *     c. calculateItemForwardTotal    → subtotal, taxAmount, total
+     *   For each op:
+     *     d. recalculate op total         → amount − recDisc
+     *   →  computeTransactionTotals       → subTotal, taxTotal, grandTotal
+     *
+     * Returns a new transaction object (shallow-copied) with updated
+     * `Items`, `Ops`, and summary totals (`SubTotal`, `TaxTotal`, `Total`).
+     *
+     * The original transaction object is never mutated.
+     *
+     * ⚠️  When writing results back to Reactive Form controls always use
+     *     `{ emitEvent: false }` to prevent triggering another recalculation.
+     */
+    static recalculateTransaction(transaction) {
+        if (!transaction)
+            return transaction;
+        const rawItems = Array.isArray(transaction.Items)
+            ? transaction.Items
+            : [];
+        const rawOps = Array.isArray(transaction.Ops) ? transaction.Ops : [];
+        // ── Step A & B: item-level amounts and item-level discounts ──────────────
+        let items = rawItems
+            .map((item) => TransactionCalculationEngine.calculateItemAmount(item))
+            .map((item) => TransactionCalculationEngine.calculateItemDiscount(item));
+        // Ops: ensure `amount` exists before distribution (carry existing value)
+        let ops = rawOps.map((op) => (Object.assign({}, op)));
+        // ── Step C: distribute transaction-level discounts ────────────────────────
+        const distributed = TransactionCalculationEngine.distributeRecordDiscount(items, ops, transaction);
+        items = distributed.items;
+        ops = distributed.ops;
+        // ── Step D: forward totals per item ──────────────────────────────────────
+        items = items.map((item) => TransactionCalculationEngine.calculateItemForwardTotal(item));
+        // ── Step E: op totals (amount already known; subtract recDisc) ───────────
+        ops = ops.map((op) => (Object.assign(Object.assign({}, op), { total: (0, math_operations_1.Subtract)(toNum(op.amount), toNum(op.recDisc)) })));
+        // ── Step F: transaction-level summary ────────────────────────────────────
+        const totals = TransactionCalculationEngine.computeTransactionTotals(items, ops);
+        return Object.assign(Object.assign({}, transaction), { Items: items, Ops: ops, SubTotal: totals.subTotal, TaxTotal: totals.taxTotal, Total: totals.grandTotal });
+    }
+    // -------------------------------------------------------------------------
+    // computeTransactionTotals  (utility – exposed for standalone use)
+    // -------------------------------------------------------------------------
+    /**
+     * Computes summary totals from already-calculated items and ops.
+     *
+     *   subTotal   = Σ item.subtotal + Σ op.total
+     *   taxTotal   = Σ item.taxAmount
+     *   grandTotal = subTotal + taxTotal
+     *
+     * Returns `{ subTotal, taxTotal, grandTotal }`.
+     */
+    static computeTransactionTotals(items, ops) {
+        const safeItems = Array.isArray(items) ? items : [];
+        const safeOps = Array.isArray(ops) ? ops : [];
+        const itemSubTotal = safeItems.reduce((sum, i) => (0, math_operations_1.Add)(sum, toNum(i.subtotal)), 0);
+        const taxTotal = safeItems.reduce((sum, i) => (0, math_operations_1.Add)(sum, toNum(i.taxAmount)), 0);
+        const opsTotal = safeOps.reduce((sum, o) => (0, math_operations_1.Add)(sum, toNum(o.total)), 0);
+        const subTotal = (0, math_operations_1.Add)(itemSubTotal, opsTotal);
+        const grandTotal = (0, math_operations_1.Add)(subTotal, taxTotal);
+        return {
+            subTotal,
+            taxTotal,
+            grandTotal,
+        };
+    }
+}
+exports.TransactionCalculationEngine = TransactionCalculationEngine;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shareneus",
-  "version": "1.6.22",
+  "version": "1.6.23",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",