@peabody-soft/mbs-model-ts 1.0.0

package/dist/Order.d.ts

@@ -0,0 +1,31 @@
+import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
+import { OrderStatus as proto_OrderStatus } from "./generated/OrderStatus";
+import { TaskStatus as proto_TaskStatus } from "./generated/TaskStatus";
+import Address from "./Address";
+import { EntityHeader } from "./Entity";
+import Message from "./Message";
+import ShoppingList from "./ShoppingList";
+export default class Order extends Message {
+    private readonly _status;
+    private readonly _fulfillmentMode;
+    private readonly _shoppingList;
+    private readonly _shoppingListTotal;
+    private readonly _shoppingListCount;
+    private readonly _deliveryAddressId;
+    private readonly _deliveryAddress;
+    private readonly _note;
+    private readonly _paymentReceived;
+    static fromScaledValues(header: EntityHeader, senderId: bigint, taskStatus: proto_TaskStatus, senderName: string | null, senderPhone: string | null, status: proto_OrderStatus, fulfillmentMode: proto_FulfillmentMode, shoppingList: ShoppingList, scaledShoppingListTotal: bigint, shoppingListCount: number, deliveryAddressId: bigint, deliveryAddress: Address | null, creationDate: bigint, note: string | null, scaledPaymentReceived: bigint | undefined): Order;
+    constructor(header: EntityHeader, senderId: bigint, taskStatus: proto_TaskStatus, senderName: string | null, senderPhone: string | null, _status: proto_OrderStatus, _fulfillmentMode: proto_FulfillmentMode, _shoppingList: ShoppingList, _shoppingListTotal: number, _shoppingListCount: number, _deliveryAddressId: bigint, _deliveryAddress: Address | null, creationDate: bigint, _note: string | null, _paymentReceived: number | null);
+    get status(): proto_OrderStatus;
+    get fulfillmentMode(): proto_FulfillmentMode;
+    get shoppingList(): ShoppingList;
+    get shoppingListTotal(): number;
+    get shoppingListCount(): number;
+    get deliveryAddressId(): bigint;
+    get deliveryAddress(): Address | null;
+    get creationDate(): Date;
+    get note(): string | null;
+    get paymentReceived(): number | null;
+    private readonly _creationDate;
+}

package/dist/Order.js

@@ -0,0 +1,70 @@
+import { MessageType as proto_MessageType } from "./generated/MessageType";
+import { amountFromScaledValue } from "./Constants";
+import Message from "./Message";
+// An order a customer has placed: a message carrying a sales order payload.
+// deliveryAddressId is an id into the customer's address list, not an address; deliveryAddress is
+// a full address sent directly instead, and takes precedence over deliveryAddressId when both are
+// present. paymentReceived is set only by an operator of the business, never by this library.
+export default class Order extends Message {
+    // Only ProtoMap calls this: it is the one place that sees a total still multiplied by
+    // Constants.AMOUNT_FACTOR.
+    static fromScaledValues(header, senderId, taskStatus, senderName, senderPhone, status, fulfillmentMode, shoppingList, scaledShoppingListTotal, shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived) {
+        return new Order(header, senderId, taskStatus, senderName, senderPhone, status, fulfillmentMode, shoppingList, amountFromScaledValue(scaledShoppingListTotal), shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived === undefined ? null : amountFromScaledValue(scaledPaymentReceived));
+    }
+    constructor(header, senderId, taskStatus, senderName, senderPhone, _status, _fulfillmentMode, _shoppingList, _shoppingListTotal, _shoppingListCount, _deliveryAddressId, _deliveryAddress, creationDate, _note, _paymentReceived) {
+        super(header, senderId, proto_MessageType.SALES_ORDER, taskStatus, senderName, senderPhone);
+        this._status = _status;
+        this._fulfillmentMode = _fulfillmentMode;
+        this._shoppingList = _shoppingList;
+        this._shoppingListTotal = _shoppingListTotal;
+        this._shoppingListCount = _shoppingListCount;
+        this._deliveryAddressId = _deliveryAddressId;
+        this._deliveryAddress = _deliveryAddress;
+        this._note = _note;
+        this._paymentReceived = _paymentReceived;
+        this._creationDate = Number(creationDate);
+    }
+    // How far the business has got with fulfilling this order, as opposed to taskStatus, which is
+    // how far it has got with reading the message
+    get status() {
+        return this._status;
+    }
+    get fulfillmentMode() {
+        return this._fulfillmentMode;
+    }
+    // What was ordered. A fulfilled order can have had its list cleared, in which case the totals
+    // below are all that is left of it.
+    get shoppingList() {
+        return this._shoppingList;
+    }
+    // The authoritative total to display; survives the shopping list being cleared, unlike a total
+    // read off the list itself.
+    get shoppingListTotal() {
+        return this._shoppingListTotal;
+    }
+    get shoppingListCount() {
+        return this._shoppingListCount;
+    }
+    // Names an address in the address list of the customer, and Constants.ENTITY_ID_NULL when the
+    // order has no delivery address - which is normal for one to be picked up
+    get deliveryAddressId() {
+        return this._deliveryAddressId;
+    }
+    // A full address sent directly rather than by id, and null when none was. Takes precedence over
+    // deliveryAddressId for display when it is not null - see the comment on this class.
+    get deliveryAddress() {
+        return this._deliveryAddress;
+    }
+    // When the customer placed this order, which is not the same as when the entity was created
+    get creationDate() {
+        return new Date(this._creationDate);
+    }
+    get note() {
+        return this._note;
+    }
+    // What the business has recorded as received against this order so far, and null when it has
+    // recorded nothing - only a business operator sets this, never this library.
+    get paymentReceived() {
+        return this._paymentReceived;
+    }
+}

package/dist/Package.d.ts

@@ -0,0 +1,25 @@
+import { EntityHeader } from "./Entity";
+import Item from "./Item";
+import { Dimensions, Weight } from "./Measures";
+import PackageIdentifier from "./PackageIdentifier";
+import Photo from "./Photo";
+import Price from "./Price";
+export default class Package extends Item {
+    private readonly _isSoldLoose;
+    private readonly _itemCode;
+    private readonly _identifiers;
+    private readonly _dimensions;
+    private readonly _weight;
+    private readonly _photos;
+    private readonly _price;
+    constructor(header: EntityHeader, name: string, description: string | null, productId: bigint, isDisabled: boolean, _isSoldLoose: boolean, _itemCode: bigint, _identifiers: ReadonlyArray<PackageIdentifier>, _dimensions: Dimensions | null, _weight: Weight | null, _photos: ReadonlyArray<Photo>, _price: Price | null);
+    get productId(): bigint;
+    get isSoldLoose(): boolean;
+    get itemCode(): bigint;
+    get identifiers(): ReadonlyArray<PackageIdentifier>;
+    get dimensions(): Dimensions | null;
+    get weight(): Weight | null;
+    get photos(): ReadonlyArray<Photo>;
+    get price(): Price | null;
+    get isBuyable(): boolean;
+}

package/dist/Package.js

@@ -0,0 +1,52 @@
+import Item from "./Item";
+// A package, or variant, of a product - a 500 gram bottle of mango pickle, for example - and the
+// thing a customer actually buys. Built complete, with photos and price already resolved, so everything here is readonly.
+export default class Package extends Item {
+    constructor(header, name, description, productId, isDisabled, _isSoldLoose, _itemCode, _identifiers, _dimensions, _weight, _photos, _price) {
+        super(header, name, description, productId, isDisabled);
+        this._isSoldLoose = _isSoldLoose;
+        this._itemCode = _itemCode;
+        this._identifiers = _identifiers;
+        this._dimensions = _dimensions;
+        this._weight = _weight;
+        this._photos = _photos;
+        this._price = _price;
+    }
+    // The product this package is a variant of, which is the parent id every item has
+    get productId() {
+        return this.parentItemId;
+    }
+    // True when this package can be bought in a quantity a customer chooses, such as 4.2 litres of
+    // oil, rather than in whole units
+    get isSoldLoose() {
+        return this._isSoldLoose;
+    }
+    // GTIN, barcode and the like. Zero when the package has none.
+    get itemCode() {
+        return this._itemCode;
+    }
+    get identifiers() {
+        return this._identifiers;
+    }
+    get dimensions() {
+        return this._dimensions;
+    }
+    get weight() {
+        return this._weight;
+    }
+    get photos() {
+        return this._photos;
+    }
+    // What this package costs; null when the business has not priced it, in which case it cannot be
+    // bought.
+    get price() {
+        return this._price;
+    }
+    // True when this package is enabled and has a price that is itself enabled. isDisabled is
+    // checked directly rather than trusted to have been filtered out: a product-level filter does
+    // not, by itself, guarantee that every package - or every price - of an otherwise visible
+    // product is itself enabled.
+    get isBuyable() {
+        return !this.isDisabled && this._price !== null && !this._price.isDisabled;
+    }
+}

package/dist/PackageIdentifier.d.ts

@@ -0,0 +1,8 @@
+import { PackageIdentifierType as proto_PackageIdentifierType } from "./generated/PackageIdentifierType";
+export default class PackageIdentifier {
+    private readonly _type;
+    private readonly _value;
+    constructor(_type: proto_PackageIdentifierType, _value: string);
+    get type(): proto_PackageIdentifierType;
+    get value(): string;
+}

package/dist/PackageIdentifier.js

@@ -0,0 +1,14 @@
+// An identifier of a package - a GTIN, for example - and the kind of identifier it is. Java keys
+// these by string id, not ordinal, so map through PackageIdentifierType.proto's comments, never the enum ordinal.
+export default class PackageIdentifier {
+    constructor(_type, _value) {
+        this._type = _type;
+        this._value = _value;
+    }
+    get type() {
+        return this._type;
+    }
+    get value() {
+        return this._value;
+    }
+}

package/dist/PaymentMethodDetail.d.ts

@@ -0,0 +1,8 @@
+import { PaymentMethod as proto_PaymentMethod } from "./generated/PaymentMethod";
+export default class PaymentMethodDetail {
+    private readonly _method;
+    private readonly _data;
+    constructor(_method: proto_PaymentMethod, _data: string | null);
+    get method(): proto_PaymentMethod;
+    get data(): string | null;
+}

package/dist/PaymentMethodDetail.js

@@ -0,0 +1,17 @@
+// A payment method a business accepts, and what a customer needs in order to use it - the UPI id
+// of the business, for example.
+//
+// The data is null rather than empty when the business has given none, which is normal for a
+// method that needs nothing, such as cash.
+export default class PaymentMethodDetail {
+    constructor(_method, _data) {
+        this._method = _method;
+        this._data = _data;
+    }
+    get method() {
+        return this._method;
+    }
+    get data() {
+        return this._data;
+    }
+}

package/dist/Photo.d.ts

@@ -0,0 +1,11 @@
+import { AttachmentType as proto_AttachmentType } from "./generated/AttachmentType";
+import Attachment from "./Attachment";
+import AttachmentBaseUrl from "./AttachmentBaseUrl";
+export default class Photo {
+    private readonly _attachment;
+    private readonly _attachmentBaseUrl;
+    constructor(_attachment: Attachment, _attachmentBaseUrl: AttachmentBaseUrl | null);
+    get attachmentType(): proto_AttachmentType;
+    get url(): URL | null;
+    private _url;
+}

package/dist/Photo.js

@@ -0,0 +1,29 @@
+// A photo of a business, product or package: which one it belongs to, and where to fetch it from.
+// All that's exposed of an Attachment - nothing else on it is useful to a UI.
+export default class Photo {
+    // The base url is the one in effect when this photo was built, not looked up at read time - a
+    // photo is rebuilt by the next sync rather than edited in place, so there is nothing to keep in
+    // sync with a later renewal.
+    constructor(_attachment, _attachmentBaseUrl) {
+        this._attachment = _attachment;
+        this._attachmentBaseUrl = _attachmentBaseUrl;
+        this._url = null;
+    }
+    get attachmentType() {
+        return this._attachment.attachmentType;
+    }
+    // Where to fetch this photo from, or null if there's nothing to fetch (deleted attachment, or the
+    // owning business's base url hadn't arrived when this photo was built). May be expired; cached
+    // once built.
+    get url() {
+        if (this._url !== null)
+            return this._url;
+        const storageFileName = this._attachment.storageFileName;
+        if (storageFileName === null)
+            return null; // Deleted, so there is no file
+        if (this._attachmentBaseUrl === null)
+            return null; // No base url had arrived when this was built
+        this._url = this._attachmentBaseUrl.createFileUrl(storageFileName);
+        return this._url;
+    }
+}

package/dist/Price.d.ts

@@ -0,0 +1,17 @@
+import { EntityHeader } from "./Entity";
+import Item from "./Item";
+export default class Price extends Item {
+    private readonly _packageId;
+    private readonly _regularPrice;
+    private readonly _offerPrice;
+    static fromScaledValues(header: EntityHeader, name: string, description: string | null, priceListId: bigint, isDisabled: boolean, packageId: bigint, scaledRegularPrice: bigint, scaledOfferPrice: bigint): Price;
+    constructor(header: EntityHeader, name: string, description: string | null, priceListId: bigint, isDisabled: boolean, _packageId: bigint, _regularPrice: number, _offerPrice: number);
+    get packageId(): bigint;
+    get priceListId(): bigint;
+    get regularPrice(): number;
+    get offerPrice(): number;
+    get finalPrice(): number;
+    get isOnOffer(): boolean;
+    get discount(): number;
+    get discountPercent(): number;
+}

package/dist/Price.js

@@ -0,0 +1,52 @@
+import { amountFromScaledValue } from "./Constants";
+import Item from "./Item";
+// What one package costs: the regular price and the offer price. Exposed unscaled as numbers; they
+// travel multiplied by Constants.AMOUNT_FACTOR and stay well below 2^53, so nothing is lost.
+export default class Price extends Item {
+    // Only ProtoMap calls this: it is the one place that sees prices still multiplied by
+    // Constants.AMOUNT_FACTOR.
+    static fromScaledValues(header, name, description, priceListId, isDisabled, packageId, scaledRegularPrice, scaledOfferPrice) {
+        return new Price(header, name, description, priceListId, isDisabled, packageId, amountFromScaledValue(scaledRegularPrice), amountFromScaledValue(scaledOfferPrice));
+    }
+    constructor(header, name, description, priceListId, isDisabled, _packageId, _regularPrice, _offerPrice) {
+        super(header, name, description, priceListId, isDisabled);
+        this._packageId = _packageId;
+        this._regularPrice = _regularPrice;
+        this._offerPrice = _offerPrice;
+    }
+    // The package this price applies to. Nothing nests on the wire, so this is how the catalog finds
+    // the price of a package.
+    get packageId() {
+        return this._packageId;
+    }
+    // The list this price belongs to, which is the parent id every item has
+    get priceListId() {
+        return this.parentItemId;
+    }
+    get regularPrice() {
+        return this._regularPrice;
+    }
+    // Zero when this package is not on offer. Never greater than the regular price.
+    get offerPrice() {
+        return this._offerPrice;
+    }
+    // What a customer actually pays: the offer price when there is one, else the regular price.
+    // Computed here (not sent), matching the "on offer" definition from Price.proto.
+    get finalPrice() {
+        return this.isOnOffer ? this._offerPrice : this._regularPrice;
+    }
+    get isOnOffer() {
+        return this._offerPrice > 0 && this._offerPrice < this._regularPrice;
+    }
+    // What the offer takes off the regular price, and zero when there is no offer
+    get discount() {
+        return this._regularPrice - this.finalPrice;
+    }
+    // Discount as an exact, unrounded percentage of the regular price - rounding is left to the UI.
+    // Zero when the regular price is zero.
+    get discountPercent() {
+        if (this._regularPrice <= 0)
+            return 0;
+        return (this.discount / this._regularPrice) * 100;
+    }
+}

package/dist/PriceList.d.ts

@@ -0,0 +1,3 @@
+import Item from "./Item";
+export default class PriceList extends Item {
+}

package/dist/PriceList.js

@@ -0,0 +1,5 @@
+import Item from "./Item";
+// A named list of prices. A storefront sells from exactly one, so no package ever has two prices
+// to choose between; it's carried (not just a bare id) because a client naming a cart needs it.
+export default class PriceList extends Item {
+}

package/dist/Product.d.ts

@@ -0,0 +1,33 @@
+import { ProductType as proto_ProductType } from "./generated/ProductType";
+import Address from "./Address";
+import { EntityHeader } from "./Entity";
+import Item from "./Item";
+import Package from "./Package";
+import Photo from "./Photo";
+import Price from "./Price";
+import Tax from "./Tax";
+export default class Product extends Item {
+    private readonly _productType;
+    private readonly _brand;
+    private readonly _isManufacturedByBusiness;
+    private readonly _manufacturer;
+    private readonly _manufacturerAddress;
+    private readonly _taxes;
+    private readonly _features;
+    private readonly _photos;
+    private readonly _packages;
+    constructor(header: EntityHeader, name: string, description: string | null, productCategoryId: bigint, isDisabled: boolean, _productType: proto_ProductType, _brand: string | null, _isManufacturedByBusiness: boolean | null, _manufacturer: string | null, _manufacturerAddress: Address | null, _taxes: ReadonlyArray<Tax>, _features: ReadonlyArray<string>, _photos: ReadonlyArray<Photo>, _packages: ReadonlyArray<Package>);
+    get productCategoryId(): bigint;
+    get productType(): proto_ProductType;
+    get brand(): string | null;
+    get isManufacturedByBusiness(): boolean | null;
+    get manufacturer(): string | null;
+    get manufacturerAddress(): Address | null;
+    get taxes(): ReadonlyArray<Tax>;
+    get features(): ReadonlyArray<string>;
+    get photos(): ReadonlyArray<Photo>;
+    get packages(): ReadonlyArray<Package>;
+    get lowestPrice(): Price | null;
+    get isOnOffer(): boolean;
+    get isBuyable(): boolean;
+}

package/dist/Product.js

@@ -0,0 +1,84 @@
+import Item from "./Item";
+// A product in the catalog: goods, a service, a raw material or a fixed asset. Built complete
+// (photos/packages resolved first) so everything here is readonly except category (via parentItemId).
+export default class Product extends Item {
+    constructor(header, name, description, productCategoryId, isDisabled, _productType, _brand, _isManufacturedByBusiness, _manufacturer, _manufacturerAddress, _taxes, _features, _photos, _packages) {
+        super(header, name, description, productCategoryId, isDisabled);
+        this._productType = _productType;
+        this._brand = _brand;
+        this._isManufacturedByBusiness = _isManufacturedByBusiness;
+        this._manufacturer = _manufacturer;
+        this._manufacturerAddress = _manufacturerAddress;
+        this._taxes = _taxes;
+        this._features = _features;
+        this._photos = _photos;
+        this._packages = _packages;
+    }
+    // The category this product is in, or Constants.ENTITY_ID_NULL when it is in none
+    get productCategoryId() {
+        return this.parentItemId;
+    }
+    get productType() {
+        return this._productType;
+    }
+    get brand() {
+        return this._brand;
+    }
+    // Null when the business hasn't said either way - the three states are why this isn't a plain
+    // boolean.
+    get isManufacturedByBusiness() {
+        return this._isManufacturedByBusiness;
+    }
+    get manufacturer() {
+        return this._manufacturer;
+    }
+    get manufacturerAddress() {
+        return this._manufacturerAddress;
+    }
+    get taxes() {
+        return this._taxes;
+    }
+    // One line bullet points about this product
+    get features() {
+        return this._features;
+    }
+    get photos() {
+        return this._photos;
+    }
+    // Every variant of this product, in the order they arrived - ordering them for display is a UI
+    // decision, see Catalog.comparePackages. A product with no packages cannot be bought.
+    get packages() {
+        return this._packages;
+    }
+    // The cheapest final price across variants (what a listing shows as "from"), or null if none has
+    // a price. Compares final price, not regular, since that's what a customer would actually pay.
+    get lowestPrice() {
+        let result = null;
+        for (const pkg of this._packages) {
+            const price = pkg.price;
+            if (price === null)
+                continue; // This variant cannot be bought
+            if (result === null || price.finalPrice < result.finalPrice)
+                result = price;
+        }
+        return result;
+    }
+    // True when any variant of this product is on offer, which is what a listing puts a badge on
+    get isOnOffer() {
+        for (const pkg of this._packages)
+            if (pkg.price?.isOnOffer === true)
+                return true;
+        return false;
+    }
+    // True when this product itself is enabled and at least one variant is buyable. The server
+    // still filters out draft and non-public products before they ever arrive, but isDisabled can
+    // change after an item exists, so it is checked here rather than trusted to have been filtered.
+    get isBuyable() {
+        if (this.isDisabled)
+            return false;
+        for (const pkg of this._packages)
+            if (pkg.isBuyable)
+                return true;
+        return false;
+    }
+}

package/dist/ProductCategory.d.ts

@@ -0,0 +1,10 @@
+import Item from "./Item";
+import Product from "./Product";
+export default class ProductCategory extends Item {
+    get products(): ReadonlyArray<Product>;
+    private set products(value);
+    private _products;
+}
+export interface UpdatableProductCategory {
+    set products(value: ReadonlyArray<Product>);
+}

package/dist/ProductCategory.js

@@ -0,0 +1,18 @@
+import Item from "./Item";
+// A category that groups products, real or the dummy one a Catalog builds to stand in for a
+// product with no category of its own. Products are set once by the Catalog that builds this, not
+// passed to the constructor - the full set isn't known until every product has been read. A
+// Catalog never builds one of these with an empty products array - see Catalog for why.
+export default class ProductCategory extends Item {
+    constructor() {
+        super(...arguments);
+        this._products = Object.freeze([]);
+    }
+    // Every buyable product whose productCategoryId names this category, in the order they arrived
+    get products() {
+        return this._products;
+    }
+    set products(value) {
+        this._products = value;
+    }
+}

package/dist/Profile.d.ts

@@ -0,0 +1,20 @@
+import BusinessLink from "./BusinessLink";
+import BusinessProfile from "./BusinessProfile";
+import UserProfile from "./UserProfile";
+export default class Profile {
+    private readonly _profileId;
+    private readonly _user;
+    constructor(_profileId: string, _user: UserProfile | null, businessLinks: ReadonlyArray<BusinessLink>, businesses: ReadonlyArray<BusinessProfile>);
+    get profileId(): string;
+    get user(): UserProfile | null;
+    get businessLinks(): ReadonlyArray<BusinessLink>;
+    get businesses(): ReadonlyArray<BusinessProfile>;
+    getBusiness(businessEntityId: bigint): BusinessProfile | null;
+    getBusinessLink(businessEntityId: bigint): BusinessLink | null;
+    getBusinessLinkFor(businessId: string): BusinessLink | null;
+    toString(): string;
+    private readonly _businessLinks;
+    private readonly _businesses;
+    private readonly _businessMap;
+    private readonly _businessLinkMap;
+}

package/dist/Profile.js

@@ -0,0 +1,55 @@
+// Everything one profile container holds: the customer, the businesses they may reach, and the
+// link to each. Rebuilt by the sync layer from a profile container; not itself on the wire.
+export default class Profile {
+    constructor(_profileId, _user, businessLinks, businesses) {
+        this._profileId = _profileId;
+        this._user = _user;
+        this._businessMap = new Map();
+        this._businessLinkMap = new Map();
+        // A business is listed only when its link is still held; a revoked link is removed by the
+        // sync but the business it named is not, so filtering here hides it without discarding it.
+        const linkedBusinessIds = new Set();
+        for (const businessLink of businessLinks)
+            linkedBusinessIds.add(businessLink.businessId);
+        this._businessLinks = Object.freeze([...businessLinks]);
+        this._businesses = Object.freeze(businesses.filter((business) => linkedBusinessIds.has(business.id)));
+        for (const business of this._businesses)
+            this._businessMap.set(business.id, business);
+        for (const businessLink of this._businessLinks)
+            this._businessLinkMap.set(businessLink.businessId, businessLink);
+    }
+    // The id of the profile container this was built from, and what Model.signIn was given
+    get profileId() {
+        return this._profileId;
+    }
+    // Null until a profile sync in has brought one, and after a tombstone for it
+    get user() {
+        return this._user;
+    }
+    // One per business this customer may reach, each carrying the token for it
+    get businessLinks() {
+        return this._businessLinks;
+    }
+    // The businesses those links name, in no particular order - a UI orders these for display
+    get businesses() {
+        return this._businesses;
+    }
+    getBusiness(businessEntityId) {
+        return this._businessMap.get(businessEntityId) ?? null;
+    }
+    // BusinessLink.businessId is an entity id, matching Business.entity.id and not the url friendly
+    // businessId - this join spares a caller from having to remember which one it is holding
+    getBusinessLink(businessEntityId) {
+        return this._businessLinkMap.get(businessEntityId) ?? null;
+    }
+    // The same, by the url friendly business id a storefront is reached by
+    getBusinessLinkFor(businessId) {
+        for (const business of this._businesses)
+            if (business.businessId === businessId)
+                return this.getBusinessLink(business.id);
+        return null;
+    }
+    toString() {
+        return `Profile(profileId=${this._profileId}, user=${this._user?.formattedName ?? "none"}, businesses=${this._businesses.length})`;
+    }
+}