@peabody-soft/mbs-model-ts 1.0.0

package/dist/Routes.d.ts

@@ -0,0 +1,7 @@
+export default class Routes {
+    static readonly BUSINESS_SYNC_OUT: string;
+    static readonly BUSINESS_SYNC_IN: string;
+    static readonly PROFILE_SYNC_OUT: string;
+    static readonly CREATE_USER: string;
+    static readonly UPDATE_USER: string;
+}

package/dist/Routes.js

@@ -0,0 +1,12 @@
+// The last path segment of each call this library makes, appended to the base url a ServiceProxy is
+// built with. Named after the server method the segment reaches, in the kebab case Java Routes.java
+// uses, and prefixed to keep the storefront methods clear of the merchant ones that share the host.
+// No route takes an id: every one of these calls says everything it needs to in its request message.
+class Routes {
+}
+Routes.BUSINESS_SYNC_OUT = "shop-business-sync-out";
+Routes.BUSINESS_SYNC_IN = "shop-business-sync-in";
+Routes.PROFILE_SYNC_OUT = "shop-profile-sync-out";
+Routes.CREATE_USER = "shop-create-user";
+Routes.UPDATE_USER = "shop-update-user";
+export default Routes;

package/dist/Service.d.ts

@@ -0,0 +1,16 @@
+import { AuthTokens as proto_AuthTokens } from "./generated/AuthTokens";
+import { BusinessSyncInRequest as proto_BusinessSyncInRequest } from "./generated/BusinessSyncInRequest";
+import { BusinessSyncInResponse as proto_BusinessSyncInResponse } from "./generated/BusinessSyncInResponse";
+import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./generated/BusinessSyncOutRequest";
+import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
+import { CreateUserRequest as proto_CreateUserRequest } from "./generated/CreateUserRequest";
+import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
+import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
+import { User as proto_User } from "./generated/User";
+export default interface Service {
+    businessSyncOut(request: proto_BusinessSyncOutRequest, authTokens: proto_AuthTokens | null): Promise<proto_BusinessSyncOutResponse>;
+    businessSyncIn(request: proto_BusinessSyncInRequest, authTokens: proto_AuthTokens): Promise<proto_BusinessSyncInResponse>;
+    profileSyncOut(request: proto_ProfileSyncOutRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    createUser(request: proto_CreateUserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    updateUser(user: proto_User, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+}

package/dist/Service.js

@@ -0,0 +1 @@
+export {};

package/dist/ServiceExceptions.d.ts

@@ -0,0 +1,40 @@
+export declare class ServiceException extends Error {
+    readonly httpStatusCode: number;
+    constructor(httpStatusCode: number, message?: string);
+}
+export declare class BadRequestException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class UnauthorizedException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class NotFoundException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class MethodNotAllowedException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class ConflictException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class UpgradeRequiredException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class InternalServerException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class ServiceUnavailableException extends ServiceException {
+    constructor(message?: string);
+    static readonly STATUS_CODE: number;
+}
+export declare class NetworkConnectionException extends Error {
+    readonly reason?: unknown;
+    constructor(message?: string, reason?: unknown);
+}

package/dist/ServiceExceptions.js

@@ -0,0 +1,84 @@
+// What a Service call fails with. Unlike the two in Exceptions.ts these are not programming errors:
+// a caller is expected to catch them and decide what to do - sign in again, retry, or show the shop
+// it already has cached. They mirror Java com.merabills.repository.client.exception so that the two
+// clients of this server describe the same failure the same way.
+// Each carries the status code rather than being told apart by a string, and the derived classes
+// exist so a caller can catch the one case it can actually handle without testing a number.
+// A call reached the server and the server refused it. Thrown directly for a status code none of the
+// classes below names, so an unrecognised failure is still a ServiceException and not something else.
+export class ServiceException extends Error {
+    constructor(httpStatusCode, message) {
+        super(message);
+        this.httpStatusCode = httpStatusCode;
+        // Otherwise every one of these reports itself as a bare "Error" when logged
+        this.name = new.target.name;
+    }
+}
+// HTTP 400 - the request was not one the server could act on
+export class BadRequestException extends ServiceException {
+    constructor(message) {
+        super(BadRequestException.STATUS_CODE, message);
+    }
+}
+BadRequestException.STATUS_CODE = 400;
+// HTTP 401 - the credentials were missing, expired or not the caller's to present
+export class UnauthorizedException extends ServiceException {
+    constructor(message) {
+        super(UnauthorizedException.STATUS_CODE, message);
+    }
+}
+UnauthorizedException.STATUS_CODE = 401;
+// HTTP 404 - no such business, user or route
+export class NotFoundException extends ServiceException {
+    constructor(message) {
+        super(NotFoundException.STATUS_CODE, message);
+    }
+}
+NotFoundException.STATUS_CODE = 404;
+// HTTP 405 - the route exists but not for this method
+export class MethodNotAllowedException extends ServiceException {
+    constructor(message) {
+        super(MethodNotAllowedException.STATUS_CODE, message);
+    }
+}
+MethodNotAllowedException.STATUS_CODE = 405;
+// HTTP 409 - the change collided with one the server already had
+export class ConflictException extends ServiceException {
+    constructor(message) {
+        super(ConflictException.STATUS_CODE, message);
+    }
+}
+ConflictException.STATUS_CODE = 409;
+// HTTP 426 - this client is too old for the server to answer
+export class UpgradeRequiredException extends ServiceException {
+    constructor(message) {
+        super(UpgradeRequiredException.STATUS_CODE, message);
+    }
+}
+UpgradeRequiredException.STATUS_CODE = 426;
+// HTTP 500 - the server failed while answering. Worth retrying, unlike the 4xx cases above.
+export class InternalServerException extends ServiceException {
+    constructor(message) {
+        super(InternalServerException.STATUS_CODE, message);
+    }
+}
+InternalServerException.STATUS_CODE = 500;
+// HTTP 503 - the server is up but cannot answer yet
+export class ServiceUnavailableException extends ServiceException {
+    constructor(message) {
+        super(ServiceUnavailableException.STATUS_CODE, message);
+    }
+}
+ServiceUnavailableException.STATUS_CODE = 503;
+// The call never got an answer at all - offline, DNS, TLS, a refused connection or one cut short.
+// Not a ServiceException, because there is no status code and the server may well have acted on the
+// request: a caller that retries has to be prepared for the first attempt to have succeeded.
+export class NetworkConnectionException extends Error {
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+        this.name = new.target.name;
+    }
+}
+// Which status code each of these stands for is HttpStatusCodes.ts, the way Java keeps the classes
+// in its exception package and the mapping in HttpStatusCodes.

package/dist/ServiceProxy.d.ts

@@ -0,0 +1,25 @@
+import { AuthTokens as proto_AuthTokens } from "./generated/AuthTokens";
+import { BusinessSyncInRequest as proto_BusinessSyncInRequest } from "./generated/BusinessSyncInRequest";
+import { BusinessSyncInResponse as proto_BusinessSyncInResponse } from "./generated/BusinessSyncInResponse";
+import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./generated/BusinessSyncOutRequest";
+import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
+import { CreateUserRequest as proto_CreateUserRequest } from "./generated/CreateUserRequest";
+import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
+import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
+import { User as proto_User } from "./generated/User";
+import Service from "./Service";
+export type FetchFunction = (url: string, init: RequestInit) => Promise<Response>;
+export default class ServiceProxy implements Service {
+    constructor(serviceBaseUrl: string, fetchFunction?: FetchFunction | null);
+    businessSyncOut(request: proto_BusinessSyncOutRequest, authTokens: proto_AuthTokens | null): Promise<proto_BusinessSyncOutResponse>;
+    businessSyncIn(request: proto_BusinessSyncInRequest, authTokens: proto_AuthTokens): Promise<proto_BusinessSyncInResponse>;
+    profileSyncOut(request: proto_ProfileSyncOutRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    createUser(request: proto_CreateUserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    updateUser(user: proto_User, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    private post;
+    private send;
+    private getFetchFunction;
+    private static readErrorMessage;
+    private readonly _serviceBaseUrl;
+    private readonly _fetchFunction;
+}

package/dist/ServiceProxy.js

@@ -0,0 +1,117 @@
+import { BusinessSyncInRequest as proto_BusinessSyncInRequest } from "./generated/BusinessSyncInRequest";
+import { BusinessSyncInResponse as proto_BusinessSyncInResponse } from "./generated/BusinessSyncInResponse";
+import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./generated/BusinessSyncOutRequest";
+import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
+import { CreateUserRequest as proto_CreateUserRequest } from "./generated/CreateUserRequest";
+import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
+import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
+import { User as proto_User } from "./generated/User";
+import { IllegalOperationException } from "./Exceptions";
+import { isError, throwOnError } from "./HttpStatusCodes";
+import { buildAuthTokensBytes } from "./ProtoMap";
+import Routes from "./Routes";
+import { NetworkConnectionException } from "./ServiceExceptions";
+// A Service that reaches a real MeraBills server. Every call is one POST to the route named after
+// it, carrying its request message encoded, and answering with the response message encoded - so
+// this class translates nothing and reads no field of either.
+// One call is one page: a sync out is paged, and the loop belongs to whoever is caching what comes
+// back, so that each page is written as it arrives - see Model.businessSyncIn.
+export default class ServiceProxy {
+    // The base url is everything before the route, with or without a trailing slash and with or
+    // without a path of its own - both are joined onto rather than replaced, so a server reached
+    // under a prefix works without the caller having to know how a route is built.
+    constructor(serviceBaseUrl, fetchFunction = null) {
+        this._serviceBaseUrl = serviceBaseUrl.replace(TRAILING_SLASHES, "");
+        this._fetchFunction = fetchFunction;
+    }
+    async businessSyncOut(request, authTokens) {
+        return this.post(Routes.BUSINESS_SYNC_OUT, proto_BusinessSyncOutRequest, request, proto_BusinessSyncOutResponse, authTokens);
+    }
+    async businessSyncIn(request, authTokens) {
+        return this.post(Routes.BUSINESS_SYNC_IN, proto_BusinessSyncInRequest, request, proto_BusinessSyncInResponse, authTokens);
+    }
+    async profileSyncOut(request, authTokens) {
+        return this.post(Routes.PROFILE_SYNC_OUT, proto_ProfileSyncOutRequest, request, proto_ProfileSyncOutResponse, authTokens);
+    }
+    async createUser(request, authTokens) {
+        return this.post(Routes.CREATE_USER, proto_CreateUserRequest, request, proto_ProfileSyncOutResponse, authTokens);
+    }
+    // The User is the whole request, there being no wrapper message for one
+    async updateUser(user, authTokens) {
+        return this.post(Routes.UPDATE_USER, proto_User, user, proto_ProfileSyncOutResponse, authTokens);
+    }
+    // One call: encode, send, turn a refusal into the exception it stands for, decode. The message
+    // types are passed in rather than named per call so that every route is sent and read identically.
+    async post(route, requestType, request, responseType, authTokens) {
+        const response = await this.send(route, requestType.toBinary(request), authTokens);
+        // The body of a failure is not a response message, so it has to be dealt with before decoding
+        if (isError(response.status))
+            throwOnError(response.status, await ServiceProxy.readErrorMessage(route, response));
+        return responseType.fromBinary(new Uint8Array(await response.arrayBuffer()));
+    }
+    async send(route, body, authTokens) {
+        const headers = { [CONTENT_TYPE_HEADER]: CONTENT_TYPE_PROTOBUF };
+        // An anonymous visitor is given no header at all rather than an empty one - the protocol has no
+        // anonymous form of the message, so the absence is what says nobody is claiming to be calling.
+        if (authTokens !== null)
+            headers[AUTHORIZATION_HEADER] = toBase64(buildAuthTokensBytes(authTokens));
+        try {
+            return await this.getFetchFunction()(`${this._serviceBaseUrl}/${route}`, {
+                method: POST,
+                headers: headers,
+                body: body,
+            });
+        }
+        catch (reason) {
+            // fetch rejects only when no answer arrived at all; a server that refused the call answers
+            // with a status code and resolves. So the request may still have been acted on, and a caller
+            // that retries has to be prepared for the first attempt to have succeeded.
+            throw new NetworkConnectionException(`The call to ${route} could not be completed`, reason);
+        }
+    }
+    // Resolved per call rather than at construction, so a platform that installs fetch after this
+    // object is built still works and an absent one fails where it is actually needed.
+    getFetchFunction() {
+        const supplied = this._fetchFunction;
+        if (supplied !== null)
+            return supplied;
+        const platform = globalThis.fetch;
+        if (platform === undefined)
+            throw new IllegalOperationException("This platform has no fetch, so a ServiceProxy cannot reach a server");
+        // Bound, because fetch called detached from globalThis is refused by browsers
+        return platform.bind(globalThis);
+    }
+    // What the response says went wrong, if anything. This protocol has no error message of its own
+    // yet, so the body of a failure can be anything at all - a stack trace, an HTML page - and only
+    // the start of one is worth carrying; a body that cannot be read says nothing the status code
+    // does not already.
+    static async readErrorMessage(route, response) {
+        let body;
+        try {
+            body = (await response.text()).trim();
+        }
+        catch {
+            body = "";
+        }
+        if (body.length > MAX_ERROR_MESSAGE_LENGTH)
+            body = `${body.slice(0, MAX_ERROR_MESSAGE_LENGTH)}...`;
+        return body.length === 0 ? route : `${route}: ${body}`;
+    }
+}
+// A header carries text, so the encoded credentials travel as base64. No scheme prefix: the server
+// reads the whole value as one encoded AuthTokens, exactly as the Java client sends the whole value
+// as one serialized AuthTokens.
+function toBase64(bytes) {
+    // Built a character at a time rather than by spreading the array into String.fromCharCode, which
+    // passes it as an argument list and overflows the stack once it is long enough
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+const AUTHORIZATION_HEADER = "authorization";
+const CONTENT_TYPE_HEADER = "content-type";
+const CONTENT_TYPE_PROTOBUF = "application/octet-stream";
+const POST = "POST";
+const MAX_ERROR_MESSAGE_LENGTH = 512;
+const TRAILING_SLASHES = /\/+$/;

package/dist/ShoppingList.d.ts

@@ -0,0 +1,64 @@
+import Tax from "./Tax";
+export default class ShoppingList {
+    private readonly _isFinal;
+    private readonly _autoAddDeliveryCharge;
+    private readonly _autoAddServiceCharge;
+    private readonly _inventoryLocationId;
+    private readonly _priceListId;
+    private readonly _totalAmountBeforeDiscount;
+    private readonly _discount;
+    private readonly _existingItemCount;
+    private readonly _deletedItemCount;
+    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;
+    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;
+    get autoAddServiceCharge(): boolean;
+    get inventoryLocationId(): number;
+    get priceListId(): bigint;
+    get totalAmountBeforeDiscount(): number;
+    get discount(): number;
+    get totalAmount(): number;
+    get existingItemCount(): number;
+    get deletedItemCount(): number;
+    get itemCount(): number;
+    get existingItems(): ReadonlyArray<ShoppingListItem>;
+    get deletedItems(): ReadonlyArray<ShoppingListItem>;
+    get computedTotal(): number;
+    get computedTotalTax(): number;
+    static readonly EMPTY: ShoppingList;
+}
+export declare class ShoppingListItem {
+    private readonly _packageId;
+    private readonly _quantity;
+    private readonly _unitPrice;
+    private readonly _shoppingListOrder;
+    private readonly _isOriginal;
+    private readonly _isModified;
+    private readonly _isStockKeepingRequired;
+    private readonly _priceDiscount;
+    private readonly _discount;
+    private readonly _taxes;
+    private readonly _expiryMinutes;
+    private readonly _description;
+    static fromScaledValues(packageId: bigint, scaledQuantity: number, scaledUnitPrice: bigint, shoppingListOrder: number, isOriginal: boolean, isModified: boolean, isStockKeepingRequired: boolean, scaledPriceDiscount: bigint, scaledDiscount: bigint, taxes: ReadonlyArray<Tax>, expiryMinutes: number, description: string | null): 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 quantity(): number;
+    get unitPrice(): number;
+    get shoppingListOrder(): number;
+    get isOriginal(): boolean;
+    get isModified(): boolean;
+    get isStockKeepingRequired(): boolean;
+    get priceDiscount(): number;
+    get discount(): number;
+    get taxes(): ReadonlyArray<Tax>;
+    get expiryMinutes(): number;
+    get description(): string | null;
+    get amount(): number;
+    get totalTax(): number;
+    get finalPrice(): number;
+}

package/dist/ShoppingList.js

@@ -0,0 +1,188 @@
+import { MERABILLS_ONLINE_PRICE_LIST_ID, amountFromScaledValue, quantityFromScaledValue, } from "./Constants";
+import Ids from "./Ids";
+// 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.
+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);
+    }
+    constructor(_isFinal, _autoAddDeliveryCharge, _autoAddServiceCharge, _inventoryLocationId, _priceListId, _totalAmountBeforeDiscount, _discount, _existingItemCount, _deletedItemCount, _existingItems, _deletedItems) {
+        this._isFinal = _isFinal;
+        this._autoAddDeliveryCharge = _autoAddDeliveryCharge;
+        this._autoAddServiceCharge = _autoAddServiceCharge;
+        this._inventoryLocationId = _inventoryLocationId;
+        this._priceListId = _priceListId;
+        this._totalAmountBeforeDiscount = _totalAmountBeforeDiscount;
+        this._discount = _discount;
+        this._existingItemCount = _existingItemCount;
+        this._deletedItemCount = _deletedItemCount;
+        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.
+    get isFinal() {
+        return this._isFinal;
+    }
+    // True when the delivery charge is a line of its own, carrying the reserved package id
+    // ReservedPackage.DELIVERY_CHARGE_PACKAGE, rather than being added to the total
+    get autoAddDeliveryCharge() {
+        return this._autoAddDeliveryCharge;
+    }
+    // The same, for ReservedPackage.SERVICE_CHARGE_PACKAGE
+    get autoAddServiceCharge() {
+        return this._autoAddServiceCharge;
+    }
+    // Zero is the default location
+    get inventoryLocationId() {
+        return this._inventoryLocationId;
+    }
+    // The price list these prices came from, which is the one a storefront sells from: a cart with
+    // none uses Constants.MERABILLS_ONLINE_PRICE_LIST_ID, the list Catalog.priceList holds.
+    get priceListId() {
+        return this._priceListId;
+    }
+    get totalAmountBeforeDiscount() {
+        return this._totalAmountBeforeDiscount;
+    }
+    // The discount on the whole list, as opposed to a discount on one line of 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.
+    get totalAmount() {
+        return this._totalAmountBeforeDiscount - this._discount;
+    }
+    // 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
+    get existingItemCount() {
+        return this._existingItemCount;
+    }
+    get deletedItemCount() {
+        return this._deletedItemCount;
+    }
+    get itemCount() {
+        return this._existingItemCount + this._deletedItemCount;
+    }
+    get existingItems() {
+        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.
+    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.
+    get computedTotal() {
+        let result = 0;
+        for (const item of this._existingItems)
+            result += item.finalPrice;
+        return result;
+    }
+    // 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;
+    }
+}
+// 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.
+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.
+    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);
+    }
+    constructor(_packageId, _quantity, _unitPrice, _shoppingListOrder, _isOriginal, _isModified, _isStockKeepingRequired, _priceDiscount, _discount, _taxes, _expiryMinutes, _description) {
+        this._packageId = _packageId;
+        this._quantity = _quantity;
+        this._unitPrice = _unitPrice;
+        this._shoppingListOrder = _shoppingListOrder;
+        this._isOriginal = _isOriginal;
+        this._isModified = _isModified;
+        this._isStockKeepingRequired = _isStockKeepingRequired;
+        this._priceDiscount = _priceDiscount;
+        this._discount = _discount;
+        this._taxes = _taxes;
+        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.
+    get packageId() {
+        return this._packageId;
+    }
+    // True when this line is a charge/summary (delivery, service charge, discount, or total) rather
+    // than a catalog package. A UI must label such lines itself.
+    get isReservedPackage() {
+        return Ids.isReservedPackageId(this._packageId);
+    }
+    get quantity() {
+        return this._quantity;
+    }
+    // What one unit costs, which is the offer price when the package is on offer
+    get unitPrice() {
+        return this._unitPrice;
+    }
+    // Where this line sits in the list, from zero
+    get shoppingListOrder() {
+        return this._shoppingListOrder;
+    }
+    // True when this line was created before the list was made final
+    get isOriginal() {
+        return this._isOriginal;
+    }
+    // True when this line has been deleted or replaced since the list was made final
+    get isModified() {
+        return this._isModified;
+    }
+    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
+    get priceDiscount() {
+        return this._priceDiscount;
+    }
+    // The discount on this whole line, taxes included
+    get discount() {
+        return this._discount;
+    }
+    get taxes() {
+        return this._taxes;
+    }
+    // Minutes after purchase when this item expires, and zero when it does not
+    get expiryMinutes() {
+        return this._expiryMinutes;
+    }
+    get description() {
+        return this._description;
+    }
+    // What this line costs before tax and before its discount
+    get amount() {
+        return this._unitPrice * this._quantity;
+    }
+    // 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).
+    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.
+    get finalPrice() {
+        return this.amount + this.totalTax - this._discount;
+    }
+}

package/dist/SyncCache.d.ts

@@ -0,0 +1,28 @@
+import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
+import { Message as proto_Message } from "./generated/Message";
+import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
+import AuthTokens from "./AuthTokens";
+import Database from "./Database";
+export default class SyncCache {
+    private readonly _database;
+    constructor(_database: Database);
+    readBusiness(containerName: string): Promise<proto_BusinessSyncOutResponse | null>;
+    writeBusiness(containerName: string, response: proto_BusinessSyncOutResponse): Promise<number>;
+    readProfile(containerName: string): Promise<proto_ProfileSyncOutResponse | null>;
+    writeProfile(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>>;
+    readMessageUpdateNumber(containerName: string): Promise<bigint>;
+    writeOrder(containerName: string, order: proto_Message): Promise<number>;
+    readCart(containerName: string): Promise<proto_Message | null>;
+    writeCart(containerName: string, cart: proto_Message): Promise<number>;
+    deleteCart(containerName: string): Promise<number>;
+    writeMessages(containerName: string, messages: ReadonlyArray<proto_Message>): Promise<number>;
+    private readAll;
+    private writeBlobs;
+    private write;
+    private getContainer;
+    private readonly _containers;
+}
+export declare const NO_DELETES: ReadonlyArray<bigint>;