@peabody-soft/mbs-model-ts 1.3.0 → 1.5.0

package/dist/ShoppingList.d.ts

@@ -1,4 +1,5 @@
-import Tax from "./Tax";
+import { ReservedPackage as proto_ReservedPackage } from "./generated/ReservedPackage";
+import Tax, { TaxAmount } from "./Tax";
 export default class ShoppingList {
     private readonly _isFinal;
     private readonly _autoAddDeliveryCharge;
@@ -12,6 +13,7 @@ export default class ShoppingList {
     private readonly _existingItems;
     private readonly _deletedItems;
     static fromScaledValues(isFinal: boolean, autoAddDeliveryCharge: boolean, autoAddServiceCharge: boolean, inventoryLocationId: number, priceListId: bigint, scaledTotalAmountBeforeDiscount: bigint, scaledDiscount: bigint, existingItemCount: number, deletedItemCount: number, existingItems: ReadonlyArray<ShoppingListItem>, deletedItems: ReadonlyArray<ShoppingListItem>): ShoppingList;
+    static sumOfFinalPrices(items: ReadonlyArray<ShoppingListItem>): number;
     constructor(_isFinal: boolean, _autoAddDeliveryCharge: boolean, _autoAddServiceCharge: boolean, _inventoryLocationId: number, _priceListId: bigint, _totalAmountBeforeDiscount: number, _discount: number, _existingItemCount: number, _deletedItemCount: number, _existingItems: ReadonlyArray<ShoppingListItem>, _deletedItems: ReadonlyArray<ShoppingListItem>);
     get isFinal(): boolean;
     get autoAddDeliveryCharge(): boolean;
@@ -26,8 +28,19 @@ export default class ShoppingList {
     get itemCount(): number;
     get existingItems(): ReadonlyArray<ShoppingListItem>;
     get deletedItems(): ReadonlyArray<ShoppingListItem>;
+    get goodsItems(): ReadonlyArray<ShoppingListItem>;
+    get chargeItems(): ReadonlyArray<ShoppingListItem>;
+    get deliveryCharge(): ShoppingListItem | null;
+    get serviceCharge(): ShoppingListItem | null;
+    get removedItems(): ReadonlyArray<ShoppingListItem>;
+    changeOf(item: ShoppingListItem): ItemChange;
     get computedTotal(): number;
+    get computedGoodsTotal(): number;
     get computedTotalTax(): number;
+    get computedTaxes(): ReadonlyArray<TaxAmount>;
+    get computedTotalWithoutDiscounts(): number;
+    get savings(): number;
+    private get derived();
     static readonly EMPTY: ShoppingList;
 }
 export declare class ShoppingListItem {
@@ -47,18 +60,34 @@ export declare class ShoppingListItem {
     constructor(_packageId: bigint, _quantity: number, _unitPrice: number, _shoppingListOrder: number, _isOriginal: boolean, _isModified: boolean, _isStockKeepingRequired: boolean, _priceDiscount: number, _discount: number, _taxes: ReadonlyArray<Tax>, _expiryMinutes: number, _description: string | null);
     get packageId(): bigint;
     get isReservedPackage(): boolean;
+    get reservedPackage(): proto_ReservedPackage | null;
     get quantity(): number;
     get unitPrice(): number;
     get shoppingListOrder(): number;
     get isOriginal(): boolean;
     get isModified(): boolean;
+    get change(): ItemChange;
     get isStockKeepingRequired(): boolean;
     get priceDiscount(): number;
     get discount(): number;
     get taxes(): ReadonlyArray<Tax>;
     get expiryMinutes(): number;
     get description(): string | null;
+    get regularUnitPrice(): number;
+    get unitPriceWithTaxes(): number;
+    get regularUnitPriceWithTaxes(): number;
     get amount(): number;
+    get taxAmounts(): ReadonlyArray<number>;
     get totalTax(): number;
     get finalPrice(): number;
+    get finalPriceWithoutDiscounts(): number;
+    get isDiscounted(): boolean;
+    get isFree(): boolean;
 }
+export declare enum ItemChange {
+    NONE = 0,
+    ADDED = 1,
+    MODIFIED = 2,
+    REMOVED = 3
+}
+export declare function validatePricing(item: ShoppingListItem): void;

package/dist/ShoppingList.js

@@ -1,14 +1,34 @@
-import { MERABILLS_ONLINE_PRICE_LIST_ID, amountFromScaledValue, quantityFromScaledValue, } from "./Constants";
+import { Constants as proto_Constants } from "./generated/Constants";
+import { ReservedPackage as proto_ReservedPackage } from "./generated/ReservedPackage";
+import { MAX_SCALED_AMOUNT, MERABILLS_ONLINE_PRICE_LIST_ID, amountFromScaledValue, amountToScaledValue, quantityFromScaledValue, quantityToScaledValue, } from "./Constants";
+import { InvalidArgumentException } from "./Exceptions";
 import Ids from "./Ids";
+import { TaxAmount } from "./Tax";
+import TaxHelper from "./TaxHelper";
 // A list of packages being bought: a shopping cart, or what an order contains.
-// Wire totals are authoritative; computed ones (below) use different rounding than Java
-// PriceCalculation, so a UI shows totalAmount, not computedTotal.
+//
+// Every unit price on a list is WITHOUT taxes, and its taxes are worked out on top (see
+// ShoppingListItem). What a customer is shown is the other thing: the same prices WITH the taxes,
+// which is what the catalog gave them, so each item offers both. Everything that adds up - the
+// line totals, the list's total, a discount of a line or of the list - already has the taxes in
+// it. The taxes inside a total are available by type (computedTaxes).
+//
+// Wire totals are authoritative: totalAmount is the number to display. The computed ones (below)
+// reproduce Java's arithmetic to the unit for the items that are here, so they agree with the wire
+// whenever the items were sent - but a list can arrive without them, and then only the wire total
+// covers the whole list.
 class ShoppingList {
     // Only ProtoMap calls this: it is the one place that sees a total still multiplied by
     // Constants.AMOUNT_FACTOR.
     static fromScaledValues(isFinal, autoAddDeliveryCharge, autoAddServiceCharge, inventoryLocationId, priceListId, scaledTotalAmountBeforeDiscount, scaledDiscount, existingItemCount, deletedItemCount, existingItems, deletedItems) {
         return new ShoppingList(isFinal, autoAddDeliveryCharge, autoAddServiceCharge, inventoryLocationId, priceListId, amountFromScaledValue(scaledTotalAmountBeforeDiscount), amountFromScaledValue(scaledDiscount), existingItemCount, deletedItemCount, existingItems, deletedItems);
     }
+    // What these items come to, taxes included and each item's own discount taken off: the sum of
+    // their finalPrice, which is what a list of them has as totalAmountBeforeDiscount. Added up in
+    // scaled values and unscaled once, so no rounding creeps in from adding unscaled numbers.
+    static sumOfFinalPrices(items) {
+        return amountFromScaledValue(sumOf(items, (pricing) => pricing.finalPrice));
+    }
     constructor(_isFinal, _autoAddDeliveryCharge, _autoAddServiceCharge, _inventoryLocationId, _priceListId, _totalAmountBeforeDiscount, _discount, _existingItemCount, _deletedItemCount, _existingItems, _deletedItems) {
         this._isFinal = _isFinal;
         this._autoAddDeliveryCharge = _autoAddDeliveryCharge;
@@ -45,17 +65,22 @@ class ShoppingList {
     get priceListId() {
         return this._priceListId;
     }
+    // The sum of the final prices of the existing items, which include their taxes
     get totalAmountBeforeDiscount() {
         return this._totalAmountBeforeDiscount;
     }
-    // The discount on the whole list, as opposed to a discount on one line of it
+    // The discount on the whole list, as opposed to a discount on one line of it. It comes off a
+    // total that already has its taxes in it.
     get discount() {
         return this._discount;
     }
-    // What the customer owes. Derived rather than sent, but derived from the authoritative totals
-    // above, so this is the number to display.
+    // What the customer owes, taxes included. Derived rather than sent, but derived from the
+    // authoritative totals above, so this is the number to display. Never less than zero, which is
+    // Java ShoppingList.getTotalAmount: a discount greater than the total leaves nothing to pay, not
+    // a refund. Worked out in scaled values, so it is not a floating point difference.
     get totalAmount() {
-        return this._totalAmountBeforeDiscount - this._discount;
+        const total = amountToScaledValue(this._totalAmountBeforeDiscount) - amountToScaledValue(this._discount);
+        return total > 0n ? amountFromScaledValue(total) : 0;
     }
     // Read from the wire and not from the length of the array below, because the protocol sends the
     // count even when it does not send the items themselves
@@ -76,26 +101,147 @@ class ShoppingList {
     get deletedItems() {
         return this._deletedItems;
     }
-    // Sum of finalPrice over existingItems. Not authoritative (rounded here, not by the server), and
-    // only covers the whole list when existingItems.length equals existingItemCount.
+    // The existing items that are packages bought from the catalog, in the order of the list - which
+    // is shoppingListOrder and not the order they were sent in, the server sending them by package id.
+    // The charge lines are not here (chargeItems), and neither are the items taken out since the
+    // list was made final (removedItems).
+    get goodsItems() {
+        return this.derived.goods;
+    }
+    // The existing items that are charge lines - the delivery charge and the service charge - in the
+    // order of the list. The other two reserved ids, for a discount and a total, are summary lines a
+    // list does not carry as items (the discount is discount, the total is totalAmount).
+    get chargeItems() {
+        return this.derived.charges;
+    }
+    // The delivery charge, which is an item like any other and priced like one, or null when this
+    // list has none
+    get deliveryCharge() {
+        return (this._existingItems.find((item) => item.reservedPackage === proto_ReservedPackage.DELIVERY_CHARGE_PACKAGE) ?? null);
+    }
+    // The service charge, in the same way
+    get serviceCharge() {
+        return (this._existingItems.find((item) => item.reservedPackage === proto_ReservedPackage.SERVICE_CHARGE_PACKAGE) ?? null);
+    }
+    // The items the business took out of the list after the customer made it final, or replaced with
+    // a changed one, as the customer ordered them - deletedItems in the order of the list. A deleted
+    // charge line is among them, and tells itself apart by reservedPackage.
+    get removedItems() {
+        return this.derived.removed;
+    }
+    // What the business has done to one line of this list since the customer made it final, which is
+    // what ShoppingListItem.change says of it - except for a list the storefront wrote before it set
+    // isOriginal. CartEditor did not, up to 1.4.0: every line of such an order is flagged as made
+    // after the list was final, which on the merchant app's reading is a line the merchant added. But
+    // no change the business can make leaves a final list with no line of the customer's in it and
+    // nothing removed (adding a line leaves the others original; taking one out leaves it in
+    // deletedItems; changing one leaves the old line there too), so a final list with nothing
+    // original, nothing modified and nothing deleted is read as untouched. Show a list's marks with
+    // this and not with ShoppingListItem.change.
+    changeOf(item) {
+        const change = item.change;
+        if (change !== ItemChange.ADDED)
+            return change;
+        return this.derived.isUntouchedLegacyOrder ? ItemChange.NONE : ItemChange.ADDED;
+    }
+    // Sum of finalPrice over existingItems, taxes included. Not authoritative (the wire total is),
+    // and only covers the whole list when existingItems.length equals existingItemCount.
     get computedTotal() {
-        let result = 0;
-        for (const item of this._existingItems)
-            result += item.finalPrice;
-        return result;
+        return ShoppingList.sumOfFinalPrices(this._existingItems);
+    }
+    // The same for the goods alone: what the packages come to, without the charges on top of them.
+    // This is what the free delivery threshold is measured against.
+    get computedGoodsTotal() {
+        return ShoppingList.sumOfFinalPrices(this.goodsItems);
     }
-    // The sum of the taxes of the items that are here, with the same caveat as computedTotal
+    // The taxes inside computedTotal: the sum of the taxes of the items that are here, with the same
+    // caveat as computedTotal
     get computedTotalTax() {
-        let result = 0;
-        for (const item of this._existingItems)
-            result += item.totalTax;
-        return result;
+        return amountFromScaledValue(sumOf(this._existingItems, (pricing) => pricing.totalTax));
+    }
+    // The taxes inside computedTotal, one entry per TYPE of tax, in the order of the types, added up
+    // over every item. A type none of the items has is not here. An amount can be zero - a type that
+    // applies to nothing but free items, which Java ShoppingList.getTotalTaxesByTaxCode leaves out
+    // altogether (JavaVectorsTest pins that) - and a bill shows no line for it, so it reads the same.
+    // The taxes are not changed by the discount of an item or of the list: those come off a price that
+    // has its taxes in it.
+    //
+    // Worked out once, like what derived holds, but apart from it: this prices the items, which the
+    // lines of a list do not need, and one that cannot be priced is no reason for a list not to list them.
+    get computedTaxes() {
+        const existing = TAXES.get(this);
+        if (existing !== undefined)
+            return existing;
+        const totals = new Map();
+        for (const item of this._existingItems) {
+            const taxAmounts = pricingOf(item).taxes;
+            item.taxes.forEach((tax, index) => {
+                totals.set(tax.type, (totals.get(tax.type) ?? 0n) + (taxAmounts[index] ?? 0n));
+            });
+        }
+        const created = Object.freeze([...totals.entries()]
+            .sort(([left], [right]) => left - right)
+            .map(([type, amount]) => new TaxAmount(type, amountFromScaledValue(amount))));
+        TAXES.set(this, created);
+        return created;
+    }
+    // What the existing items come to at their regular prices, with their taxes and with none of
+    // their own discounts taken off: the total as it would have been had nothing been on offer.
+    // Compared with totalAmount it gives what the customer saved. Same caveat as computedTotal.
+    get computedTotalWithoutDiscounts() {
+        return amountFromScaledValue(sumOf(this._existingItems, (pricing) => pricing.finalPriceWithoutDiscounts));
+    }
+    // What the offers on the items, the discounts on them and the discount on the list took off,
+    // taxes included, which is what a bill shows as savings - and a delivery charge that was waived,
+    // being an item with a price discount like any other, as the merchant app's total row has it. So
+    // a basket can save more once delivery is in the list than it did without. Zero when nothing was
+    // taken off, and never negative. Same caveat as computedTotal: it needs the items.
+    get savings() {
+        const saved = sumOf(this._existingItems, (pricing) => pricing.finalPriceWithoutDiscounts) -
+            amountToScaledValue(this.totalAmount);
+        return saved > 0n ? amountFromScaledValue(saved) : 0;
+    }
+    // Worked out once for this list, which never changes, so that what a UI reads is the same array
+    // every time - a dependency that holds still - and a list is not sorted at every render
+    get derived() {
+        const existing = DERIVED.get(this);
+        if (existing !== undefined)
+            return existing;
+        const created = {
+            goods: Object.freeze(sortedByOrder(this._existingItems.filter((item) => !item.isReservedPackage))),
+            charges: Object.freeze(sortedByOrder(this._existingItems.filter((item) => item.reservedPackage === proto_ReservedPackage.DELIVERY_CHARGE_PACKAGE ||
+                item.reservedPackage === proto_ReservedPackage.SERVICE_CHARGE_PACKAGE))),
+            removed: Object.freeze(sortedByOrder(this._deletedItems)),
+            isUntouchedLegacyOrder: this._isFinal &&
+                this._existingItems.length > 0 &&
+                this._deletedItems.length === 0 &&
+                this._deletedItemCount === 0 &&
+                this._existingItems.every((item) => !item.isOriginal && !item.isModified),
+        };
+        DERIVED.set(this, created);
+        return created;
     }
 }
 // An empty cart, for a customer who has not put anything in one yet
 ShoppingList.EMPTY = new ShoppingList(false, false, false, 0, MERABILLS_ONLINE_PRICE_LIST_ID, 0, 0, 0, 0, Object.freeze([]), Object.freeze([]));
 export default ShoppingList;
 // One line of a shopping list: the package being bought, how much of it, and at what price.
+//
+// THE PRICE IS STORED WITHOUT TAXES. unitPrice and priceDiscount are the prices before taxes, and
+// taxes are worked out on top of them - exactly as Java ShoppingListItem does and as
+// ShoppingListItem.proto says. The prices a customer sees (a Price in the catalog, the unit price
+// in a cart) INCLUDE taxes, so a price has its taxes taken out on its way into an item
+// (CartEditor does this, as Java ShoppingListItem.setDetailsFromTaxInclusivePrices does), and the
+// *WithTaxes members below put them back for display. Show those, never unitPrice: unitPrice is
+// what is stored, not what anyone is charged for a unit.
+//
+// The arithmetic is Java's to the unit, and rounds in the same places: the tax base (the unit price
+// multiplied by the quantity) is rounded to a whole amount, then each tax on it is rounded on its
+// own, half up. See TaxHelper. So are its limits: Java refuses an item for an amount of
+// Transaction.MAX_AMOUNT or more (validateAmount), and so does this - by throwing an
+// InvalidArgumentException when the item is priced, which is when something first reads a price
+// off it - for each of the taxes, the final price and the other prices it works out (see
+// validatePricing).
 export class ShoppingListItem {
     // Only ProtoMap calls this: it is the one place that sees a quantity multiplied by
     // Constants.QUANTITY_FACTOR and prices multiplied by Constants.AMOUNT_FACTOR.
@@ -126,10 +272,17 @@ export class ShoppingListItem {
     get isReservedPackage() {
         return Ids.isReservedPackageId(this._packageId);
     }
+    // Which of the four that is, and null for a catalog package
+    get reservedPackage() {
+        return this.isReservedPackage
+            ? Number(Ids.getLowPart(this._packageId))
+            : null;
+    }
     get quantity() {
         return this._quantity;
     }
-    // What one unit costs, which is the offer price when the package is on offer
+    // What one unit costs WITHOUT taxes, which is the offer price when the package is on offer. This
+    // is what is stored, not what a customer is charged: see unitPriceWithTaxes.
     get unitPrice() {
         return this._unitPrice;
     }
@@ -137,19 +290,34 @@ export class ShoppingListItem {
     get shoppingListOrder() {
         return this._shoppingListOrder;
     }
-    // True when this line was created before the list was made final
+    // True when this line was created before the list was made final. Everything a customer puts in
+    // a cart is, which is what separates it from what the business adds or changes afterwards.
     get isOriginal() {
         return this._isOriginal;
     }
-    // True when this line has been deleted or replaced since the list was made final
+    // True when this line has been deleted or replaced since the list was made final. An original
+    // line that is also modified has been deleted (and is in ShoppingList.deletedItems); one that is
+    // not original but is modified has replaced an original one; one that is neither has been added
+    // by the business.
     get isModified() {
         return this._isModified;
     }
+    // What the business has done to this line since the customer made the list final, read off
+    // isOriginal and isModified the way the merchant app does: a "+" beside a line it added, an "x"
+    // beside one it changed, and the old line listed apart as removed. This is the line's own flags
+    // and nothing more; to show a list use ShoppingList.changeOf, which also knows an order written
+    // before 1.5.0 flagged its lines wrongly.
+    get change() {
+        if (this._isOriginal)
+            return this._isModified ? ItemChange.REMOVED : ItemChange.NONE;
+        return this._isModified ? ItemChange.MODIFIED : ItemChange.ADDED;
+    }
     get isStockKeepingRequired() {
         return this._isStockKeepingRequired;
     }
     // What the offer takes off the unit price - the regular price of the package less its offer
-    // price - and not a discount on this line
+    // price, both WITHOUT taxes - and not a discount on this line. So the regular price of one unit,
+    // without taxes, is unitPrice + priceDiscount.
     get priceDiscount() {
         return this._priceDiscount;
     }
@@ -157,6 +325,7 @@ export class ShoppingListItem {
     get discount() {
         return this._discount;
     }
+    // The taxes on this line, which are included in everything this line costs a customer
     get taxes() {
         return this._taxes;
     }
@@ -167,22 +336,163 @@ export class ShoppingListItem {
     get description() {
         return this._description;
     }
-    // What this line costs before tax and before its discount
+    // The regular price of one unit WITHOUT taxes: unitPrice + priceDiscount
+    get regularUnitPrice() {
+        return amountFromScaledValue(pricingOf(this).regularUnitPrice);
+    }
+    // What one unit costs a customer: unitPrice with the taxes on it, the offer price when the
+    // package is on offer. This is the price a customer saw when they added it, and the one to show
+    // wherever the item is shown. Each tax is rounded, so a price with taxes is not always one that
+    // can be reached; when it is not, this is the nearest that can, which differs from what the
+    // catalog said by a thousandth or so (Java ShoppingListItem.setDetailsFromTaxInclusivePrices).
+    get unitPriceWithTaxes() {
+        return amountFromScaledValue(pricingOf(this).unitPriceWithTaxes);
+    }
+    // The same for the regular price of one unit, which is what is struck through when this line is
+    // on offer (priceDiscount greater than zero)
+    get regularUnitPriceWithTaxes() {
+        return amountFromScaledValue(pricingOf(this).regularUnitPriceWithTaxes);
+    }
+    // What this line costs before its taxes and before its discount - the tax base: the unit price
+    // multiplied by the quantity, rounded to a whole amount as Java does
     get amount() {
-        return this._unitPrice * this._quantity;
+        return amountFromScaledValue(pricingOf(this).taxBase);
+    }
+    // Each tax on this line, in the order of taxes: that tax's rate on amount, rounded half up. All
+    // zero when amount is, since a tax only applies to something that costs. Included in finalPrice.
+    get taxAmounts() {
+        return pricingOf(this).unscaledTaxes;
     }
-    // Tax on this line at the rates it was bought with. Computed here since the protocol sends
-    // rates, not amounts, and left unrounded (unlike the server's authoritative total).
+    // The taxes on this line added up. Included in finalPrice.
     get totalTax() {
-        const amount = this.amount;
-        let result = 0;
-        for (const tax of this._taxes)
-            result += (amount * tax.rate) / 100;
-        return result;
-    }
-    // What this line adds to the list: what it costs, plus the tax on it, less its discount. This is
-    // the definition ShoppingListItem.proto gives.
+        return amountFromScaledValue(pricingOf(this).totalTax);
+    }
+    // What this line adds to the list: what it costs, plus the tax on it, less its discount, and not
+    // less than zero. This is the definition ShoppingListItem.proto gives, and it includes taxes.
     get finalPrice() {
-        return this.amount + this.totalTax - this._discount;
+        return amountFromScaledValue(pricingOf(this).finalPrice);
+    }
+    // What this line would add at the regular price of the package, taxes included, with none of its
+    // own discount taken off: the price a customer would have paid had nothing been on offer. Strike
+    // it through beside finalPrice when it is greater (Java calculateFinalPriceWithoutDiscounts).
+    get finalPriceWithoutDiscounts() {
+        return amountFromScaledValue(pricingOf(this).finalPriceWithoutDiscounts);
+    }
+    // True when this line costs less than it would at the regular price with none of its discount:
+    // finalPriceWithoutDiscounts is then worth striking through beside finalPrice
+    get isDiscounted() {
+        const pricing = pricingOf(this);
+        return pricing.finalPriceWithoutDiscounts > pricing.finalPrice;
+    }
+    // True when this line costs nothing though it would have cost something: a delivery charge that
+    // has been waived, a package given away. A bill reads FREE, with finalPriceWithoutDiscounts
+    // struck through.
+    get isFree() {
+        const pricing = pricingOf(this);
+        return pricing.finalPrice === 0n && pricing.finalPriceWithoutDiscounts > 0n;
     }
 }
+// What the business has done to a line of an order since the customer made it final. The merchant
+// app marks the second and third with a "+" and an "x" and explains them in a legend, and lists the
+// fourth under "Removed by merchant".
+export var ItemChange;
+(function (ItemChange) {
+    // As the customer ordered it. Every line of a list that is not final yet is this.
+    ItemChange[ItemChange["NONE"] = 0] = "NONE";
+    // Added by the business after the order was placed
+    ItemChange[ItemChange["ADDED"] = 1] = "ADDED";
+    // A line the business changed (its price, its quantity): this is the new one, and the line as it
+    // was is in ShoppingList.deletedItems
+    ItemChange[ItemChange["MODIFIED"] = 2] = "MODIFIED";
+    // A line as the customer ordered it that the business has since deleted or replaced. Only in
+    // ShoppingList.deletedItems.
+    ItemChange[ItemChange["REMOVED"] = 3] = "REMOVED";
+})(ItemChange || (ItemChange = {}));
+// Kept beside the item rather than in it: an item is a value, and two equal ones should compare
+// equal whether or not either has been priced yet.
+const PRICINGS = new WeakMap();
+const DERIVED = new WeakMap();
+// The taxes of a list by type, which only a list whose items can be priced has
+const TAXES = new WeakMap();
+function pricingOf(item) {
+    const existing = PRICINGS.get(item);
+    if (existing !== undefined)
+        return existing;
+    const rates = TaxHelper.scaledRatesOf(item.taxes);
+    const unitPrice = amountToScaledValue(item.unitPrice);
+    const regularUnitPrice = unitPrice + amountToScaledValue(item.priceDiscount);
+    // Java recalculate: taxes only apply to a tax base greater than zero
+    const taxBase = scaledProduct(unitPrice, item.quantity);
+    const taxes = taxBase > 0n ? TaxHelper.calculateTaxes(taxBase, rates) : rates.map(() => 0n);
+    const totalTax = taxes.reduce((total, tax) => total + tax, 0n);
+    // The discount comes off a price that has its taxes in it, and a price is never less than zero
+    const discounted = taxBase + totalTax - amountToScaledValue(item.discount);
+    const created = {
+        regularUnitPrice: regularUnitPrice,
+        unitPriceWithTaxes: TaxHelper.addTaxes(unitPrice, rates),
+        regularUnitPriceWithTaxes: TaxHelper.addTaxes(regularUnitPrice, rates),
+        taxBase: taxBase,
+        taxes: taxes,
+        unscaledTaxes: Object.freeze(taxes.map(amountFromScaledValue)),
+        totalTax: totalTax,
+        finalPrice: discounted > 0n ? discounted : 0n,
+        finalPriceWithoutDiscounts: TaxHelper.addTaxes(scaledProduct(regularUnitPrice, item.quantity), rates),
+    };
+    // Before it is kept, so that an item that cannot be priced is refused every time it is asked
+    validateAmounts(created);
+    PRICINGS.set(item, created);
+    return created;
+}
+// Throws an InvalidArgumentException unless every amount the item works out is one the protocol can
+// carry. CartEditor calls it before it keeps a line; everything else finds out when it first reads
+// a price off the item.
+export function validatePricing(item) {
+    pricingOf(item);
+}
+// Java Transaction.validateAmount, which refuses an amount of MAX_AMOUNT or more, applied where Java
+// applies it to an item: each of its taxes and its final price when it works them out
+// (recalculate), and the results of calculateFinalPriceWithoutDiscounts, calculateUnitPriceWithTaxes
+// and calculateUnitRegularPriceWithTaxes. They are checked together, once, where the item is priced,
+// so that however it was made - a line of a cart being edited, or one that came from the wire - it
+// answers as Java does and no number that is not an amount of the protocol is ever handed out.
+//
+// They are not independent of each other. finalPriceWithoutDiscounts is what the item costs at its
+// regular price, which is never less than its offer price, and each tax and the final price (a
+// discount comes off that alone) are parts of it; likewise the regular unit price with taxes is
+// never less than the unit price with taxes. So no tax and no final price is over the limit unless
+// that cost is, which the vectors of test/JavaVectors.ts show item by item.
+function validateAmounts(pricing) {
+    const amounts = [
+        ...pricing.taxes.map((tax) => ["tax", tax]),
+        ["final price", pricing.finalPrice],
+        ["final price without discounts", pricing.finalPriceWithoutDiscounts],
+        ["unit price with taxes", pricing.unitPriceWithTaxes],
+        ["regular unit price with taxes", pricing.regularUnitPriceWithTaxes],
+    ];
+    for (const [name, amount] of amounts)
+        if (amount >= MAX_SCALED_AMOUNT)
+            throw new InvalidArgumentException(`The ${name} of an item, ${amountFromScaledValue(amount)}, is more than the ${amountFromScaledValue(MAX_SCALED_AMOUNT - 1n)} the protocol can carry`);
+}
+// A scaled amount multiplied by a quantity, rounded to a whole amount, to the letter of Java:
+// Math.round(((double) amount) * NumberHelper.intToFloat(scaledQuantity, QUANTITY_FACTOR)). The
+// quantity is a FLOAT there, so it is one here - fround - and a quantity such as 0.7 is not quite
+// 0.7 in either, which matters only where the product lands exactly on a half.
+function scaledProduct(scaledAmount, quantity) {
+    const scaledQuantity = quantityToScaledValue(quantity);
+    const floatQuantity = Math.fround(Math.fround(scaledQuantity) / proto_Constants.QUANTITY_FACTOR);
+    const product = Math.round(Number(scaledAmount) * floatQuantity);
+    return Number.isFinite(product) ? BigInt(product) : 0n;
+}
+// A copy in the order of the list. Java sorts the existing items by shoppingListOrder before it
+// shows a list (ShoppingListAdapter), and an order arrives with its items in the order of their
+// package ids. The removed items are in package id order in the merchant app, which has no better
+// order for them; this library puts them in the order they had, which is the customer's.
+function sortedByOrder(items) {
+    return [...items].sort((left, right) => left.shoppingListOrder - right.shoppingListOrder);
+}
+function sumOf(items, select) {
+    let result = 0n;
+    for (const item of items)
+        result += select(pricingOf(item));
+    return result;
+}

package/dist/SyncCache.d.ts

@@ -3,13 +3,18 @@ import { Message as proto_Message } from "./generated/Message";
 import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
 import AuthTokens from "./AuthTokens";
 import Database from "./Database";
+import SyncState from "./SyncState";
 export default class SyncCache {
     private readonly _database;
     constructor(_database: Database);
     readBusiness(containerName: string): Promise<proto_BusinessSyncOutResponse | null>;
+    readBusinessCursors(containerName: string): Promise<SyncState>;
     writeBusiness(containerName: string, response: proto_BusinessSyncOutResponse): Promise<number>;
+    storeBusiness(containerName: string, response: proto_BusinessSyncOutResponse): Promise<number>;
     readProfile(containerName: string): Promise<proto_ProfileSyncOutResponse | null>;
+    readProfileCursors(containerName: string): Promise<SyncState>;
     writeProfile(containerName: string, response: proto_ProfileSyncOutResponse): Promise<number>;
+    storeProfile(containerName: string, response: proto_ProfileSyncOutResponse): Promise<number>;
     readAuthTokens(containerName: string): Promise<AuthTokens | null>;
     writeAuthTokens(containerName: string, authTokens: AuthTokens): Promise<void>;
     readOrders(containerName: string): Promise<ReadonlyArray<proto_Message>>;
@@ -17,11 +22,15 @@ export default class SyncCache {
     writeOrder(containerName: string, order: proto_Message): Promise<number>;
     readPartyPreferences(containerName: string): Promise<proto_Message | null>;
     writePartyPreferences(containerName: string, partyPreferences: proto_Message): Promise<number>;
+    deleteBusiness(containerName: string): Promise<void>;
     deletePartyPreferences(containerName: string): Promise<number>;
     writeMessages(containerName: string, messages: ReadonlyArray<proto_Message>): Promise<number>;
     private readAll;
+    private writeOwnMessage;
     private writeBlobs;
     private write;
+    private writeRead;
+    private readCursors;
     private getContainer;
     private readonly _containers;
 }