@peabody-soft/mbs-model-ts 1.0.0

package/dist/Enums.d.ts

@@ -0,0 +1,16 @@
+export { AddressType } from "./generated/AddressType";
+export { AttachmentType } from "./generated/AttachmentType";
+export { AuthenticationMethod } from "./generated/AuthenticationMethod";
+export { BusinessIdentifierType } from "./generated/BusinessIdentifierType";
+export { DimensionUnit } from "./generated/DimensionUnit";
+export { FulfillmentMode } from "./generated/FulfillmentMode";
+export { MessageType } from "./generated/MessageType";
+export { OrderStatus } from "./generated/OrderStatus";
+export { PackageIdentifierType } from "./generated/PackageIdentifierType";
+export { PaymentMethod } from "./generated/PaymentMethod";
+export { ProductType } from "./generated/ProductType";
+export { ReservedPackage } from "./generated/ReservedPackage";
+export { Role } from "./generated/Role";
+export { TaskStatus } from "./generated/TaskStatus";
+export { TaxType } from "./generated/TaxType";
+export { WeightUnit } from "./generated/WeightUnit";

package/dist/Enums.js

@@ -0,0 +1,18 @@
+// Every enum of the protocol, re-exported under its own name so their Java-defined numeric ids
+// have only one place to be wrong, and this file records which enums are part of the library's surface.
+export { AddressType } from "./generated/AddressType";
+export { AttachmentType } from "./generated/AttachmentType";
+export { AuthenticationMethod } from "./generated/AuthenticationMethod";
+export { BusinessIdentifierType } from "./generated/BusinessIdentifierType";
+export { DimensionUnit } from "./generated/DimensionUnit";
+export { FulfillmentMode } from "./generated/FulfillmentMode";
+export { MessageType } from "./generated/MessageType";
+export { OrderStatus } from "./generated/OrderStatus";
+export { PackageIdentifierType } from "./generated/PackageIdentifierType";
+export { PaymentMethod } from "./generated/PaymentMethod";
+export { ProductType } from "./generated/ProductType";
+export { ReservedPackage } from "./generated/ReservedPackage";
+export { Role } from "./generated/Role";
+export { TaskStatus } from "./generated/TaskStatus";
+export { TaxType } from "./generated/TaxType";
+export { WeightUnit } from "./generated/WeightUnit";

package/dist/Exceptions.d.ts

@@ -0,0 +1,4 @@
+export declare class InvalidArgumentException extends Error {
+}
+export declare class IllegalOperationException extends Error {
+}

package/dist/Exceptions.js

@@ -0,0 +1,8 @@
+// The two failures this library raises; both are programming errors, not conditions a UI recovers
+// from (a sync failure surfaces as a rejected promise instead).
+// A caller passed something this library cannot work with
+export class InvalidArgumentException extends Error {
+}
+// A caller did something in an order this library does not allow
+export class IllegalOperationException extends Error {
+}

package/dist/GeneralSettings.d.ts

@@ -0,0 +1,46 @@
+import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
+import { AddressList } from "./Address";
+import BusinessIdentifier from "./BusinessIdentifier";
+import LatLong from "./LatLong";
+import PaymentMethodDetail from "./PaymentMethodDetail";
+import Tax from "./Tax";
+import WorkingDays from "./WorkingDays";
+export default class GeneralSettings {
+    private readonly _paymentMethodDetails;
+    private readonly _customerServicePhone;
+    private readonly _isWhatsAppSupported;
+    private readonly _isSmsSupported;
+    private readonly _businessAddresses;
+    private readonly _businessIdentifiers;
+    private readonly _fulfillmentModes;
+    private readonly _deliveryCharge;
+    private readonly _deliveryChargeTaxes;
+    private readonly _freeDeliveryTotal;
+    private readonly _deliveryRadiusKilometres;
+    private readonly _storeTagline;
+    private readonly _workingDays;
+    private readonly _primaryStoreLocation;
+    private readonly _googleBusinessCategoryId;
+    private readonly _googleBusinessCategoryName;
+    private readonly _onlineStoreThemeId;
+    static fromScaledValues(paymentMethodDetails: ReadonlyArray<PaymentMethodDetail>, customerServicePhone: string | null, isWhatsAppSupported: boolean, isSmsSupported: boolean, businessAddresses: AddressList, businessIdentifiers: ReadonlyArray<BusinessIdentifier>, fulfillmentModes: ReadonlyArray<proto_FulfillmentMode>, scaledDeliveryCharge: bigint, deliveryChargeTaxes: ReadonlyArray<Tax>, scaledFreeDeliveryTotal: bigint, deliveryRadiusKilometres: number, storeTagline: string | null, workingDays: WorkingDays, primaryStoreLocation: LatLong | null, googleBusinessCategoryId: string | null, googleBusinessCategoryName: string | null, onlineStoreThemeId: string | null): GeneralSettings;
+    constructor(_paymentMethodDetails: ReadonlyArray<PaymentMethodDetail>, _customerServicePhone: string | null, _isWhatsAppSupported: boolean, _isSmsSupported: boolean, _businessAddresses: AddressList, _businessIdentifiers: ReadonlyArray<BusinessIdentifier>, _fulfillmentModes: ReadonlyArray<proto_FulfillmentMode>, _deliveryCharge: number, _deliveryChargeTaxes: ReadonlyArray<Tax>, _freeDeliveryTotal: number, _deliveryRadiusKilometres: number, _storeTagline: string | null, _workingDays: WorkingDays, _primaryStoreLocation: LatLong | null, _googleBusinessCategoryId: string | null, _googleBusinessCategoryName: string | null, _onlineStoreThemeId: string | null);
+    get paymentMethodDetails(): ReadonlyArray<PaymentMethodDetail>;
+    get customerServicePhone(): string | null;
+    get isWhatsAppSupported(): boolean;
+    get isSmsSupported(): boolean;
+    get businessAddresses(): AddressList;
+    get businessIdentifiers(): ReadonlyArray<BusinessIdentifier>;
+    get fulfillmentModes(): ReadonlyArray<proto_FulfillmentMode>;
+    get deliveryCharge(): number;
+    get deliveryChargeTaxes(): ReadonlyArray<Tax>;
+    get freeDeliveryTotal(): number;
+    get deliveryRadiusKilometres(): number;
+    get storeTagline(): string | null;
+    get workingDays(): WorkingDays;
+    get primaryStoreLocation(): LatLong | null;
+    get googleBusinessCategoryId(): string | null;
+    get googleBusinessCategoryName(): string | null;
+    get onlineStoreThemeId(): string | null;
+    static readonly EMPTY: GeneralSettings;
+}

package/dist/GeneralSettings.js

@@ -0,0 +1,99 @@
+import { AddressList } from "./Address";
+import { amountFromScaledValue } from "./Constants";
+import WorkingDays from "./WorkingDays";
+// The publicly visible settings of a business: tagline, contact info, location, fulfillment,
+// payment and delivery options, and how its online store is presented.
+// Not an entity - it's the value unwrapped from the one public Configuration a storefront is sent; merchant-only fields are excluded.
+class GeneralSettings {
+    // Only ProtoMap calls this: it is the one place that sees amounts still multiplied by
+    // Constants.AMOUNT_FACTOR.
+    static fromScaledValues(paymentMethodDetails, customerServicePhone, isWhatsAppSupported, isSmsSupported, businessAddresses, businessIdentifiers, fulfillmentModes, scaledDeliveryCharge, deliveryChargeTaxes, scaledFreeDeliveryTotal, deliveryRadiusKilometres, storeTagline, workingDays, primaryStoreLocation, googleBusinessCategoryId, googleBusinessCategoryName, onlineStoreThemeId) {
+        return new GeneralSettings(paymentMethodDetails, customerServicePhone, isWhatsAppSupported, isSmsSupported, businessAddresses, businessIdentifiers, fulfillmentModes, amountFromScaledValue(scaledDeliveryCharge), deliveryChargeTaxes, amountFromScaledValue(scaledFreeDeliveryTotal), deliveryRadiusKilometres, storeTagline, workingDays, primaryStoreLocation, googleBusinessCategoryId, googleBusinessCategoryName, onlineStoreThemeId);
+    }
+    constructor(_paymentMethodDetails, _customerServicePhone, _isWhatsAppSupported, _isSmsSupported, _businessAddresses, _businessIdentifiers, _fulfillmentModes, _deliveryCharge, _deliveryChargeTaxes, _freeDeliveryTotal, _deliveryRadiusKilometres, _storeTagline, _workingDays, _primaryStoreLocation, _googleBusinessCategoryId, _googleBusinessCategoryName, _onlineStoreThemeId) {
+        this._paymentMethodDetails = _paymentMethodDetails;
+        this._customerServicePhone = _customerServicePhone;
+        this._isWhatsAppSupported = _isWhatsAppSupported;
+        this._isSmsSupported = _isSmsSupported;
+        this._businessAddresses = _businessAddresses;
+        this._businessIdentifiers = _businessIdentifiers;
+        this._fulfillmentModes = _fulfillmentModes;
+        this._deliveryCharge = _deliveryCharge;
+        this._deliveryChargeTaxes = _deliveryChargeTaxes;
+        this._freeDeliveryTotal = _freeDeliveryTotal;
+        this._deliveryRadiusKilometres = _deliveryRadiusKilometres;
+        this._storeTagline = _storeTagline;
+        this._workingDays = _workingDays;
+        this._primaryStoreLocation = _primaryStoreLocation;
+        this._googleBusinessCategoryId = _googleBusinessCategoryId;
+        this._googleBusinessCategoryName = _googleBusinessCategoryName;
+        this._onlineStoreThemeId = _onlineStoreThemeId;
+    }
+    get paymentMethodDetails() {
+        return this._paymentMethodDetails;
+    }
+    // E.164 formatted, and null when the business has published no number
+    get customerServicePhone() {
+        return this._customerServicePhone;
+    }
+    get isWhatsAppSupported() {
+        return this._isWhatsAppSupported;
+    }
+    get isSmsSupported() {
+        return this._isSmsSupported;
+    }
+    get businessAddresses() {
+        return this._businessAddresses;
+    }
+    get businessIdentifiers() {
+        return this._businessIdentifiers;
+    }
+    // The modes this business offers, as a list rather than Java's bit mask. Empty means none published, not none offered.
+    get fulfillmentModes() {
+        return this._fulfillmentModes;
+    }
+    get deliveryCharge() {
+        return this._deliveryCharge;
+    }
+    // The taxes on the delivery charge, which are the business's own and not a product's - at most
+    // Constants.MAX_TAXES of them. Empty means the charge is untaxed.
+    get deliveryChargeTaxes() {
+        return this._deliveryChargeTaxes;
+    }
+    // Order total at or above which delivery is free. Zero means never free, not always free.
+    get freeDeliveryTotal() {
+        return this._freeDeliveryTotal;
+    }
+    // Constants.NO_RESTRICTIONS_DELIVERY_DISTANCE (zero) means there is no limit
+    get deliveryRadiusKilometres() {
+        return this._deliveryRadiusKilometres;
+    }
+    get storeTagline() {
+        return this._storeTagline;
+    }
+    // Absent working days default to WorkingDays.ALL_DAYS (Java's default), never left null here.
+    get workingDays() {
+        return this._workingDays;
+    }
+    // Where this business is: the coordinates of the first of businessAddresses. Null when the
+    // business has not published them.
+    get primaryStoreLocation() {
+        return this._primaryStoreLocation;
+    }
+    // What kind of business this is, as its Google Business Profile category - "Bakery", say. The
+    // name is the one to show; the id is the stable one to match on.
+    get googleBusinessCategoryId() {
+        return this._googleBusinessCategoryId;
+    }
+    get googleBusinessCategoryName() {
+        return this._googleBusinessCategoryName;
+    }
+    // Which of a storefront's own themes this business picked. The themes are the storefront's, so
+    // what an id means is its business and not this library's; null when none was picked.
+    get onlineStoreThemeId() {
+        return this._onlineStoreThemeId;
+    }
+}
+// A business with no published public settings, used instead of null so every field is already the protocol's empty value.
+GeneralSettings.EMPTY = new GeneralSettings(Object.freeze([]), null, false, false, AddressList.EMPTY, Object.freeze([]), Object.freeze([]), 0, Object.freeze([]), 0, 0, null, WorkingDays.ALL_DAYS, null, null, null, null);
+export default GeneralSettings;

package/dist/HttpStatusCodes.d.ts

@@ -0,0 +1,2 @@
+export declare function isError(httpStatusCode: number): boolean;
+export declare function throwOnError(httpStatusCode: number, message?: string): void;

package/dist/HttpStatusCodes.js

@@ -0,0 +1,34 @@
+import { BadRequestException, ConflictException, InternalServerException, MethodNotAllowedException, NotFoundException, ServiceException, ServiceUnavailableException, UnauthorizedException, UpgradeRequiredException, } from "./ServiceExceptions";
+// Which failure a status code stands for, and nothing else - the classes themselves are in
+// ServiceExceptions.ts. Split the same way Java splits HttpStatusCodes from its exception package,
+// so that the one table saying "401 means this" has a single home in each client.
+// Everything from 300 up, this being Java's HttpURLConnection.HTTP_MULT_CHOICE. A redirect counts as
+// a failure because this client asks for one route and follows nothing, so being sent elsewhere
+// means the call did not happen.
+export function isError(httpStatusCode) {
+    return httpStatusCode >= LOWEST_ERROR_STATUS_CODE;
+}
+// Raises the failure a status code stands for, and does nothing at all for one that is not an error.
+// A code with no class of its own is still a ServiceException carrying the code, so a server that
+// starts answering something new cannot slip past as a success.
+export function throwOnError(httpStatusCode, message) {
+    if (!isError(httpStatusCode))
+        return;
+    const create = EXCEPTIONS.get(httpStatusCode);
+    if (create === undefined)
+        throw new ServiceException(httpStatusCode, message);
+    throw create(message);
+}
+const LOWEST_ERROR_STATUS_CODE = 300;
+// Java builds this by reflection over a map of classes; here each entry constructs its own, because
+// a constructor reached through a type is what keeps this checked at compile time.
+const EXCEPTIONS = new Map([
+    [BadRequestException.STATUS_CODE, (message) => new BadRequestException(message)],
+    [UnauthorizedException.STATUS_CODE, (message) => new UnauthorizedException(message)],
+    [NotFoundException.STATUS_CODE, (message) => new NotFoundException(message)],
+    [MethodNotAllowedException.STATUS_CODE, (message) => new MethodNotAllowedException(message)],
+    [ConflictException.STATUS_CODE, (message) => new ConflictException(message)],
+    [UpgradeRequiredException.STATUS_CODE, (message) => new UpgradeRequiredException(message)],
+    [InternalServerException.STATUS_CODE, (message) => new InternalServerException(message)],
+    [ServiceUnavailableException.STATUS_CODE, (message) => new ServiceUnavailableException(message)],
+]);

package/dist/Ids.d.ts

@@ -0,0 +1,17 @@
+export default class Ids {
+    static getEntityTypeId(id: bigint): number;
+    static getLowPart(id: bigint): bigint;
+    static buildId(entityTypeId: number, lowPart: bigint): bigint;
+    static getPartyPreferencesMessageId(businessLinkId: bigint): bigint;
+    static getNewId(entityTypeId: number): bigint;
+    static isReservedPackageId(packageId: bigint): boolean;
+    static toStorageHexString(id: bigint): string;
+    static toOrderNumberString(orderId: bigint): string;
+    static readonly ENTITY_TYPE_BIT_SHIFT: bigint;
+    static readonly ID_MASK: bigint;
+    static readonly GENERAL_SETTINGS_CONFIGURATION_ID: bigint;
+    static readonly ATTACHMENT_BASE_URL_BLOB_ID: bigint;
+    static readonly AUTH_TOKENS_BLOB_ID: bigint;
+    private static readonly UNSIGNED_64_BIT_MASK;
+    private static readonly UNSIGNED_32_BIT_MASK;
+}

package/dist/Ids.js

@@ -0,0 +1,78 @@
+import { Constants as proto_Constants } from "./generated/Constants";
+import { ReservedPackage as proto_ReservedPackage } from "./generated/ReservedPackage";
+// Everything this library knows about entity id layout. Ids are built/read only here, since a 64-bit shift written in number arithmetic silently loses the entity type.
+// Some ids below are not entity ids but local-store blob ids; they're negative, which can never collide with a real id (whose sign bit is always clear).
+class Ids {
+    // The most significant byte of an id: one of the *_ENTITY_TYPE_ID values of Constants.
+    static getEntityTypeId(id) {
+        return Number((id >> Ids.ENTITY_TYPE_BIT_SHIFT) & 0xffn);
+    }
+    // Everything below the entity type: partition id plus id within the partition.
+    static getLowPart(id) {
+        return id & Ids.ID_MASK;
+    }
+    static buildId(entityTypeId, lowPart) {
+        return (BigInt(entityTypeId) << Ids.ENTITY_TYPE_BIT_SHIFT) | (lowPart & Ids.ID_MASK);
+    }
+    // Where the cart of one membership lives: the business link id with the entity type swapped for
+    // the message one, which is Java Message.getPartyPreferencesMessageId. Derived rather than
+    // assigned so that a client always knows the id of its own cart without having been told it - a
+    // sync in answers with an update number and no id, so a cart the server named could not be stored
+    // here at all. One link therefore has one cart, and creating it twice is impossible by
+    // construction rather than by a check.
+    static getPartyPreferencesMessageId(businessLinkId) {
+        return Ids.buildId(proto_Constants.MESSAGE_ENTITY_TYPE_ID, Ids.getLowPart(businessLinkId));
+    }
+    // A fresh id for an entity this client is creating, to the rules of Java
+    // Entity.getRandomLongForId: random, and never in 0-255, which every entity type reserves. Only
+    // the low part is drawn, since buildId masks the rest off anyway, and it is drawn from the
+    // cryptographic generator rather than Math.random - an id is guessable otherwise, and a message id
+    // is a thing a caller could be handed.
+    static getNewId(entityTypeId) {
+        for (;;) {
+            const bytes = new Uint8Array(8);
+            crypto.getRandomValues(bytes);
+            let lowPart = 0n;
+            for (const byte of bytes)
+                lowPart = (lowPart << 8n) | BigInt(byte);
+            lowPart &= Ids.ID_MASK;
+            if (lowPart > BigInt(proto_Constants.ENTITY_ID_UNASSIGNED))
+                return Ids.buildId(entityTypeId, lowPart);
+        }
+    }
+    // The charge/summary lines of a shopping list carry one of these instead of a real catalog package id.
+    static isReservedPackageId(packageId) {
+        return (Ids.getEntityTypeId(packageId) === proto_Constants.PACKAGE_ENTITY_TYPE_ID &&
+            Ids.getLowPart(packageId) <= BigInt(proto_ReservedPackage.SERVICE_CHARGE_PACKAGE));
+    }
+    // 16 upper-case hex digits, zero-padded, no 0x prefix - the attachment blob file name format (case sensitive).
+    // Masked to 64 bits first so a negative bigint prints as Java's unsigned twos complement instead of with a minus sign.
+    static toStorageHexString(id) {
+        return (id & Ids.UNSIGNED_64_BIT_MASK).toString(16).toUpperCase().padStart(16, "0");
+    }
+    // The number an order is shown under: the least significant 32 bits of the id of the message
+    // carrying it, as upper-case hex, not zero-padded. That is Java MessageBuilder.formatId, and it
+    // has to match character for character - the merchant app shows the same order under the same
+    // number, and a customer quoting one over the phone is the whole point of having it. An order
+    // number is therefore derived and not a field of the protocol.
+    // Java narrows with a cast to signed int and formats with %X, which prints the unsigned 32-bit
+    // twos complement; masking here answers the same string without the sign getting in the way.
+    // The merchant app prefixes the word "Order"; whether to do that is a UI's decision, not this one.
+    static toOrderNumberString(orderId) {
+        return (orderId & Ids.UNSIGNED_32_BIT_MASK).toString(16).toUpperCase();
+    }
+}
+Ids.ENTITY_TYPE_BIT_SHIFT = BigInt(proto_Constants.ENTITY_TYPE_BIT_SHIFT);
+// Everything an id holds below its entity type; not in Constants.proto since 64 bits don't fit an enum value.
+Ids.ID_MASK = (1n << BigInt(proto_Constants.ENTITY_TYPE_BIT_SHIFT)) - 1n;
+// The configuration holding a business's public settings - the only one sent to a storefront (Java Configuration.MIN_PUBLIC_CONFIGURATION_ID).
+Ids.GENERAL_SETTINGS_CONFIGURATION_ID = 0x0d10000000000000n;
+// A price list id is built by Constants.buildPriceListId rather than named here: which built-in
+// lists exist is a fact of the protocol, and only their low parts are constants of it.
+// Where a business container keeps that business's attachment base url; its eTag is that url's expiry.
+Ids.ATTACHMENT_BASE_URL_BLOB_ID = -1n;
+// Where a container keeps the credentials that sign its calls - see AuthTokens. Written with a null eTag, since a reissued token is not a later version of an earlier one: the latest simply wins.
+Ids.AUTH_TOKENS_BLOB_ID = -2n;
+Ids.UNSIGNED_64_BIT_MASK = (1n << 64n) - 1n;
+Ids.UNSIGNED_32_BIT_MASK = (1n << 32n) - 1n;
+export default Ids;

package/dist/Item.d.ts

@@ -0,0 +1,12 @@
+import Entity, { EntityHeader } from "./Entity";
+export default abstract class Item extends Entity {
+    private readonly _name;
+    private readonly _description;
+    private readonly _parentItemId;
+    private readonly _isDisabled;
+    constructor(header: EntityHeader, _name: string, _description: string | null, _parentItemId: bigint, _isDisabled: boolean);
+    get name(): string;
+    get description(): string | null;
+    get parentItemId(): bigint;
+    get isDisabled(): boolean;
+}

package/dist/Item.js

@@ -0,0 +1,30 @@
+import Entity from "./Entity";
+// Something a business buys or sells, or a category or a price thereof - mirrors the protocol's Item, embedded in each of the five real types.
+// parentItemId is the wire parent (e.g. a product's category), distinct from Entity.parent, the sync layer's containment parent (e.g. the business).
+export default class Item extends Entity {
+    // Public rather than protected since ProductCategory/PriceList add nothing of their own; the class stays abstract, so still uninstantiable directly.
+    constructor(header, _name, _description, _parentItemId, _isDisabled) {
+        super(header);
+        this._name = _name;
+        this._description = _description;
+        this._parentItemId = _parentItemId;
+        this._isDisabled = _isDisabled;
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    // Constants.ENTITY_ID_NULL when this item has no parent (e.g. an uncategorized product, or a price list).
+    get parentItemId() {
+        return this._parentItemId;
+    }
+    // True when the business has disabled this item. Unlike isPublic and Product.isDraft, this can
+    // change after an item exists, so it is sent rather than filtered out once and for all - a
+    // product-level filter (Catalog.getCustomerVisibleProducts) does not, by itself, guarantee that
+    // every package of an otherwise visible product is itself enabled.
+    get isDisabled() {
+        return this._isDisabled;
+    }
+}

package/dist/LatLong.d.ts

@@ -0,0 +1,7 @@
+export default class LatLong {
+    private readonly _latitude;
+    private readonly _longitude;
+    constructor(_latitude: number, _longitude: number);
+    get latitude(): number;
+    get longitude(): number;
+}

package/dist/LatLong.js

@@ -0,0 +1,17 @@
+// A point on Earth. Not an entity - a value on GeneralSettings, where it is the business's own
+// location. Degrees, and nothing here converts or formats them: whether that becomes a map pin, a
+// distance or a link is a UI's decision.
+export default class LatLong {
+    constructor(_latitude, _longitude) {
+        this._latitude = _latitude;
+        this._longitude = _longitude;
+    }
+    // Between Constants.MIN_LATITUDE and Constants.MAX_LATITUDE
+    get latitude() {
+        return this._latitude;
+    }
+    // Between Constants.MIN_LONGITUDE and Constants.MAX_LONGITUDE
+    get longitude() {
+        return this._longitude;
+    }
+}

package/dist/LiveData.d.ts

@@ -0,0 +1,30 @@
+export default class LiveData<TValue> implements Observable<TValue>, UpdatableLiveData<TValue> {
+    constructor(value: TValue);
+    get value(): TValue;
+    private set value(value);
+    get holder(): StateHolder<TValue>;
+    get observerCount(): number;
+    observe(observer: Observer<TValue>, notifyImmediately?: boolean): () => void;
+    unobserve(observer: Observer<TValue>): void;
+    private notifyObservers;
+    private static readonly NOT_NOTIFIED;
+    private readonly _observers;
+    private _holder;
+    private _version;
+    private _isNotifying;
+    private _isNotificationStale;
+}
+export declare class StateHolder<TValue> {
+    readonly value: TValue;
+    constructor(value: TValue);
+}
+export type Observer<TValue> = (holder: StateHolder<TValue>) => void;
+export interface Observable<TValue> {
+    get value(): TValue;
+    get holder(): StateHolder<TValue>;
+    observe(observer: Observer<TValue>, notifyImmediately?: boolean): () => void;
+    unobserve(observer: Observer<TValue>): void;
+}
+export interface UpdatableLiveData<TValue> {
+    set value(value: TValue);
+}

package/dist/LiveData.js

@@ -0,0 +1,76 @@
+// A value that notifies its observers whenever it is set - the Android LiveData of this library, what every storefront UI binds to.
+// Deliberately skips LifecycleOwner and onActive/onInactive (no web equivalent / no need), and differs from mbl-model's Observations:
+// observe() returns its own unobserve function, holder gives a stable snapshot for React, observers are a Map for O(1) removal, and a value set mid-notification restarts rather than interleaves.
+class LiveData {
+    constructor(value) {
+        this._observers = new Map();
+        this._version = 0;
+        this._isNotifying = false;
+        this._isNotificationStale = false;
+        this._holder = new StateHolder(value);
+    }
+    get value() {
+        return this._holder.value;
+    }
+    // Private - only the sync layer (via an UpdatableLiveData cast) can set the value; a UI can only read/observe.
+    set value(value) {
+        // Always replaces the holder and notifies, even with the same reference - the interior may have changed and this class can't tell.
+        ++this._version;
+        this._holder = new StateHolder(value);
+        this.notifyObservers();
+    }
+    // The current value, wrapped so its identity changes exactly once per notification; use this instead of value for reference-equality snapshot comparisons.
+    get holder() {
+        return this._holder;
+    }
+    get observerCount() {
+        return this._observers.size;
+    }
+    // Returns the function that stops this observer observing. Observing twice with the same function only observes once.
+    observe(observer, notifyImmediately = false) {
+        if (!this._observers.has(observer)) {
+            // NOT_NOTIFIED means the immediate notification below has something to deliver; otherwise a new observer only hears future changes (not sticky, unlike Android LiveData).
+            this._observers.set(observer, notifyImmediately ? LiveData.NOT_NOTIFIED : this._version);
+        }
+        if (notifyImmediately)
+            this.notifyObservers();
+        return () => this.unobserve(observer);
+    }
+    unobserve(observer) {
+        this._observers.delete(observer);
+    }
+    notifyObservers() {
+        if (this._isNotifying) {
+            // An observer set a value while being notified; mark stale so the running notification restarts with the newer value instead of nesting.
+            this._isNotificationStale = true;
+            return;
+        }
+        this._isNotifying = true;
+        try {
+            do {
+                this._isNotificationStale = false;
+                // Safe to mutate the Map during iteration: an entry added during the loop is reached, one removed is skipped.
+                for (const observer of this._observers.keys()) {
+                    if (this._isNotificationStale)
+                        break; // Start again with the newer value
+                    if (this._observers.get(observer) === this._version)
+                        continue; // Already told
+                    this._observers.set(observer, this._version);
+                    observer(this._holder);
+                }
+            } while (this._isNotificationStale);
+        }
+        finally {
+            this._isNotifying = false;
+        }
+    }
+}
+// Lower than the version of any value, so that an observer marked with it is always notified
+LiveData.NOT_NOTIFIED = -1;
+export default LiveData;
+// Wraps a value so every notification carries a new object, since React ignores a setState call whose argument is the object it already holds.
+export class StateHolder {
+    constructor(value) {
+        this.value = value;
+    }
+}

package/dist/Measures.d.ts

@@ -0,0 +1,20 @@
+import { DimensionUnit as proto_DimensionUnit } from "./generated/DimensionUnit";
+import { WeightUnit as proto_WeightUnit } from "./generated/WeightUnit";
+export declare class Dimensions {
+    private readonly _unit;
+    private readonly _length;
+    private readonly _width;
+    private readonly _height;
+    constructor(_unit: proto_DimensionUnit, _length: number, _width: number, _height: number);
+    get unit(): proto_DimensionUnit;
+    get length(): number;
+    get width(): number;
+    get height(): number;
+}
+export declare class Weight {
+    private readonly _unit;
+    private readonly _value;
+    constructor(_unit: proto_WeightUnit, _value: number);
+    get unit(): proto_WeightUnit;
+    get value(): number;
+}

package/dist/Measures.js

@@ -0,0 +1,34 @@
+// How big a package is, and how much it weighs - grouped together since a UI showing one usually shows both. Neither is an entity; both are values on the Package row.
+// Units are the generated proto enums, so a value displays in whatever unit the merchant entered it in; nothing here converts between units.
+export class Dimensions {
+    constructor(_unit, _length, _width, _height) {
+        this._unit = _unit;
+        this._length = _length;
+        this._width = _width;
+        this._height = _height;
+    }
+    get unit() {
+        return this._unit;
+    }
+    get length() {
+        return this._length;
+    }
+    get width() {
+        return this._width;
+    }
+    get height() {
+        return this._height;
+    }
+}
+export class Weight {
+    constructor(_unit, _value) {
+        this._unit = _unit;
+        this._value = _value;
+    }
+    get unit() {
+        return this._unit;
+    }
+    get value() {
+        return this._value;
+    }
+}

package/dist/Message.d.ts

@@ -0,0 +1,16 @@
+import { MessageType as proto_MessageType } from "./generated/MessageType";
+import { TaskStatus as proto_TaskStatus } from "./generated/TaskStatus";
+import Entity, { EntityHeader } from "./Entity";
+export default abstract class Message extends Entity {
+    private readonly _senderId;
+    private readonly _messageType;
+    private readonly _taskStatus;
+    private readonly _senderName;
+    private readonly _senderPhone;
+    protected constructor(header: EntityHeader, _senderId: bigint, _messageType: proto_MessageType, _taskStatus: proto_TaskStatus, _senderName: string | null, _senderPhone: string | null);
+    get senderId(): bigint;
+    get messageType(): proto_MessageType;
+    get taskStatus(): proto_TaskStatus;
+    get senderName(): string | null;
+    get senderPhone(): string | null;
+}

package/dist/Message.js

@@ -0,0 +1,32 @@
+import Entity from "./Entity";
+// Something a customer sent to a business: an order (sales order) or a shopping cart (party preferences) - the two payloads this library understands.
+// A business entity despite being customer-authored, since Java authorizes the message table via Right.MESSAGES_MODIFY against the business.
+export default class Message extends Entity {
+    constructor(header, _senderId, _messageType, _taskStatus, _senderName, _senderPhone) {
+        super(header);
+        this._senderId = _senderId;
+        this._messageType = _messageType;
+        this._taskStatus = _taskStatus;
+        this._senderName = _senderName;
+        this._senderPhone = _senderPhone;
+    }
+    // The customer's User id; a business sync out doesn't carry it, so it's resolvable only against a profile sync out.
+    // senderName/senderPhone below are the fallback a UI shows meanwhile, and all an anonymous client ever has.
+    get senderId() {
+        return this._senderId;
+    }
+    get messageType() {
+        return this._messageType;
+    }
+    // How far the business has got with this message. Named after its enum, not the wire field "status", to avoid clashing with Order.status.
+    get taskStatus() {
+        return this._taskStatus;
+    }
+    get senderName() {
+        return this._senderName;
+    }
+    // E.164 formatted
+    get senderPhone() {
+        return this._senderPhone;
+    }
+}

package/dist/MockDatabase.d.ts

@@ -0,0 +1,19 @@
+import Database, { Container, StoredBlob } from "./Database";
+export default class MockDatabase implements Database {
+    getContainer(name: string): Promise<Container>;
+    getContainerNames(): Promise<ReadonlyArray<string>>;
+    deleteContainer(name: string): Promise<void>;
+    getContainerIfPresent(name: string): MockContainer | null;
+    private readonly _containers;
+}
+export declare class MockContainer implements Container {
+    read(id: bigint): Promise<StoredBlob | null>;
+    readAll(): Promise<ReadonlyArray<StoredBlob>>;
+    write(blobs: ReadonlyArray<StoredBlob>, deletes: ReadonlyArray<bigint>): Promise<number>;
+    private static isNewer;
+    get size(): number;
+    has(id: bigint): boolean;
+    failNextWrite: boolean;
+    writeCount: number;
+    private readonly _blobs;
+}