@peabody-soft/mbs-model-ts 1.4.0 → 1.6.0

package/dist/ShoppingList.js

@@ -1,14 +1,31 @@
-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, with the taxes worked out on top (see
+// ShoppingListItem). Each item also offers the price WITH taxes that a customer is shown.
+// Everything that adds up (line totals, the list's total, a discount) already has its 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 reproduce
+// Java's arithmetic to the unit for the items that are here, so they match the wire whenever the
+// items were sent. A list can arrive without its items, and then only the wire total covers it.
 class ShoppingList {
-    // Only ProtoMap calls this: it is the one place that sees a total still multiplied by
-    // Constants.AMOUNT_FACTOR.
+    // For ProtoMap, which sees totals 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 a list of them has as totalAmountBeforeDiscount. Added in scaled values
+    // and unscaled once, so adding unscaled numbers adds no rounding error.
+    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;
@@ -22,8 +39,8 @@ class ShoppingList {
         this._existingItems = _existingItems;
         this._deletedItems = _deletedItems;
     }
-    // True once the customer is done editing, after which the business may edit it instead. Only a
-    // final list can have deleted items, and this is never unset.
+    // True once the customer is done editing, after which the business may edit it. Only a final
+    // list can have deleted items. It is never unset.
     get isFinal() {
         return this._isFinal;
     }
@@ -45,20 +62,25 @@ 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, not on one line. 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 from the authoritative totals above, so it is
+    // the number to display. Never less than zero, as in Java ShoppingList.getTotalAmount: a discount
+    // greater than the total leaves nothing to pay. Worked out in scaled values, so there is no
+    // floating point error.
     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
+    // Read from the wire because the protocol sends the count even when it sends no items, so the
+    // array length below can differ
     get existingItemCount() {
         return this._existingItemCount;
     }
@@ -72,33 +94,143 @@ class ShoppingList {
         return this._existingItems;
     }
     // The items that were in this list when it was made final and have since been deleted or
-    // replaced. Always empty until then.
+    // replaced. Empty until the list is final.
     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
+    // (shoppingListOrder). The server sends them by package id, so that differs from the order
+    // received. The charge lines are in chargeItems, and the items taken out since the list was made
+    // final are in 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. They are discount and totalAmount.
+    get chargeItems() {
+        return this.derived.charges;
+    }
+    // The delivery charge, an item priced like any other, 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. It is deletedItems in the order of the list. A
+    // deleted charge line is among them, and is told 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. It is
+    // ShoppingListItem.change, except for a legacy order, written by a storefront that did not set
+    // isOriginal (CartEditor, up to 1.4.0). Every line of such an order reads as added by the
+    // business. A final list with no original, modified or deleted line is taken to be one, since no
+    // change the business can make leaves that (adding a line keeps the others original, taking one
+    // out leaves it in deletedItems, changing one leaves the old line there too).
+    // Show a list's marks with this, not 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, for a type
+    // that applies only to free items. Java ShoppingList.getTotalTaxesByTaxCode leaves such a type
+    // out (JavaVectorsTest pins that), and a bill shows no line for it.
+    // A discount does not change the taxes: it comes off a price that already has them in it.
+    // Worked out once, like derived but kept apart: this prices the items, and an item that cannot be
+    // priced must not stop the list's lines being listed.
+    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 none of their own
+    // discounts taken off: the total 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, shown on a bill as savings. A waived delivery charge counts too, being an item
+    // with a price discount like any other, as in the merchant app's total row. So a basket can save
+    // more once delivery is in the list. Zero when nothing was taken off, 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, since the list never changes, so a UI reads the same array every time (a
+    // stable dependency) and the 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 before taxes, which are worked
+// out on top, as in Java ShoppingListItem and ShoppingListItem.proto. A customer sees prices WITH
+// taxes, so CartEditor takes them out on the way in and the *WithTaxes members put them back. Show
+// those, never unitPrice, which is not what a customer is charged for a unit.
+//
+// The arithmetic is Java's to the unit and rounds in the same places: the tax base (unit price
+// times quantity) to a whole amount, then each tax on its own, half up (see TaxHelper). An amount
+// of Transaction.MAX_AMOUNT or more throws an InvalidArgumentException when something first reads
+// a price off the item, as in Java (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.
+    // For ProtoMap, which sees a quantity multiplied by Constants.QUANTITY_FACTOR and prices
+    // multiplied by Constants.AMOUNT_FACTOR.
     static fromScaledValues(packageId, scaledQuantity, scaledUnitPrice, shoppingListOrder, isOriginal, isModified, isStockKeepingRequired, scaledPriceDiscount, scaledDiscount, taxes, expiryMinutes, description) {
         return new ShoppingListItem(packageId, quantityFromScaledValue(scaledQuantity), amountFromScaledValue(scaledUnitPrice), shoppingListOrder, isOriginal, isModified, isStockKeepingRequired, amountFromScaledValue(scaledPriceDiscount), amountFromScaledValue(scaledDiscount), taxes, expiryMinutes, description);
     }
@@ -116,8 +248,8 @@ export class ShoppingListItem {
         this._expiryMinutes = _expiryMinutes;
         this._description = _description;
     }
-    // The package being bought. Four ids are reserved for charge and summary lines rather than
-    // catalog packages and will not be found in the catalog - see isReservedPackage below.
+    // The package being bought. Four ids are reserved for charge and summary lines and are not in the
+    // catalog. See isReservedPackage.
     get packageId() {
         return this._packageId;
     }
@@ -126,10 +258,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, the offer price when the package is on offer. This is what is
+    // stored. For what a customer is charged see unitPriceWithTaxes.
     get unitPrice() {
         return this._unitPrice;
     }
@@ -137,19 +276,33 @@ 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 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. Original and
+    // modified: deleted (and in ShoppingList.deletedItems). Not original but modified: replaced an
+    // original one. Neither: 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 as 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 reads the line's own flags only.
+    // To show a list use ShoppingList.changeOf, which also knows that 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
+    // What the offer takes off the unit price: the package's regular price less its offer price, both
+    // WITHOUT taxes. It is not a discount on this line (see discount). The regular price of one unit
+    // without taxes is unitPrice + priceDiscount.
     get priceDiscount() {
         return this._priceDiscount;
     }
@@ -157,6 +310,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 +321,160 @@ 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. It is the price the customer saw when adding it, and the one to show
+    // wherever the item is shown. Each tax is rounded, so not every price with taxes can be reached.
+    // When it cannot, this is the nearest that can, which differs from the catalog's by a thousandth
+    // or so (Java ShoppingListItem.setDetailsFromTaxInclusivePrices).
+    get unitPriceWithTaxes() {
+        return amountFromScaledValue(pricingOf(this).unitPriceWithTaxes);
+    }
+    // The same for the regular price of one unit, 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 discount, the tax base: the unit price times 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: its cost plus the tax on it, less its discount, and not less
+    // than zero. This is the definition in ShoppingListItem.proto, 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 package's regular price, taxes included, with none of its own
+    // discount taken off: what 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 at the regular price with none of its discount, so
+    // finalPriceWithoutDiscounts is 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 so it stays a plain value: two equal items compare equal whether or not
+// either has been priced.
+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 keeping a line. Anything else finds out when it first reads a
+// price off the item.
+export function validatePricing(item) {
+    pricingOf(item);
+}
+// Java Transaction.validateAmount refuses an amount of MAX_AMOUNT or more. This applies it to the
+// amounts Java checks on an item: each tax and the final price (recalculate), and the results of
+// calculateFinalPriceWithoutDiscounts, calculateUnitPriceWithTaxes and
+// calculateUnitRegularPriceWithTaxes. They are checked together, once, where the item is priced, so
+// an item answers as Java does however it was made (a cart line or the wire) and hands out no
+// number the protocol cannot carry.
+// The amounts are not independent. finalPriceWithoutDiscounts is the cost at the regular price,
+// never less than the offer price, and each tax and the final price are parts of it. So none of
+// them is over the limit unless that cost is (test/JavaVectors.ts shows this 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 times a quantity, rounded to a whole amount as Java does:
+// Math.round(((double) amount) * NumberHelper.intToFloat(scaledQuantity, QUANTITY_FACTOR)). The
+// quantity is a FLOAT there, so it is one here (fround), and a quantity like 0.7 is not quite 0.7
+// in either. That matters only where the product lands 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
+// showing a list (ShoppingListAdapter), and an order arrives with its items in package id order.
+// The merchant app shows the removed items in package id order, having no better one. This library
+// uses 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,25 +3,37 @@ 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>;
+    readDeletedBusiness(containerName: string): Promise<proto_BusinessSyncOutResponse | null>;
     readProfile(containerName: string): Promise<proto_ProfileSyncOutResponse | null>;
+    readDeletedProfile(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>>;
+    readDeletedOrders(containerName: string): Promise<ReadonlyArray<proto_Message>>;
     readMessageUpdateNumber(containerName: string): Promise<bigint>;
     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;
 }