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

package/dist/Product.js

@@ -2,7 +2,7 @@ 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) {
+    constructor(header, name, description, productCategoryId, isDisabled, _productType, _brand, _isManufacturedByBusiness, _manufacturer, _manufacturerAddress, _taxes, _features, _isForOfflineSaleOnly, _photos, packages) {
         super(header, name, description, productCategoryId, isDisabled);
         this._productType = _productType;
         this._brand = _brand;
@@ -11,8 +11,11 @@ export default class Product extends Item {
         this._manufacturerAddress = _manufacturerAddress;
         this._taxes = _taxes;
         this._features = _features;
+        this._isForOfflineSaleOnly = _isForOfflineSaleOnly;
         this._photos = _photos;
-        this._packages = _packages;
+        // A package that cannot be bought is of no use to anyone who has this product, so it is not
+        // kept - whoever builds a product, and whatever they hand it
+        this._packages = Object.freeze(packages.filter((pkg) => pkg.isBuyable));
     }
     // The category this product is in, or Constants.ENTITY_ID_NULL when it is in none
     get productCategoryId() {
@@ -24,8 +27,8 @@ export default class Product extends Item {
     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.
+    // False only when the business says it does not make this product itself: what is sent is false,
+    // or nothing, which Product.proto says is true.
     get isManufacturedByBusiness() {
         return this._isManufacturedByBusiness;
     }
@@ -35,6 +38,8 @@ export default class Product extends Item {
     get manufacturerAddress() {
         return this._manufacturerAddress;
     }
+    // The taxes INCLUDED in the price of every package of this product (Price) - not added to it.
+    // A UI shows a price as it is, and shows these only as what a bill's total includes.
     get taxes() {
         return this._taxes;
     }
@@ -42,22 +47,32 @@ export default class Product extends Item {
     get features() {
         return this._features;
     }
+    // True when the business sells this product only offline: the server sends such a product like any
+    // other, flagged, and it is for this model to not offer it to a customer - see isBuyable. A catalog
+    // never holds one, so only a product that is built by hand, not one that is read from a catalog,
+    // can be seen to say so.
+    get isForOfflineSaleOnly() {
+        return this._isForOfflineSaleOnly;
+    }
     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.
+    // Every buyable variant of this product, in the order they arrived - ordering them for display
+    // is a UI decision, see Catalog.comparePackages. A variant that cannot be bought is not here, and
+    // a product with none 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.
+    // The cheapest final price across variants (what a listing shows as "from"), or null if there
+    // are no variants. Compares final price, not regular, since that's what a customer would
+    // actually pay. Every variant is taxed at this product's rates, so prices with taxes in them
+    // order the variants as prices without would.
     get lowestPrice() {
         let result = null;
         for (const pkg of this._packages) {
             const price = pkg.price;
             if (price === null)
-                continue; // This variant cannot be bought
+                continue; // Not so of a buyable variant, though the type does not say
             if (result === null || price.finalPrice < result.finalPrice)
                 result = price;
         }
@@ -70,15 +85,12 @@ export default class Product extends Item {
                 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.
+    // True when this product itself is enabled, is not one that the business sells only offline, and
+    // it has at least one buyable variant, which is to say any variant, since it keeps no other. The
+    // server still filters out draft and non-public products before they ever arrive, but isDisabled
+    // can change after an item exists, and the server does not filter out what is sold only offline
+    // (it sends the flag), so both are 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;
+        return !this.isDisabled && !this._isForOfflineSaleOnly && this._packages.length > 0;
     }
 }

package/dist/Profile.d.ts

@@ -18,3 +18,4 @@ export default class Profile {
     private readonly _businessMap;
     private readonly _businessLinkMap;
 }
+export declare function canonicalizeBusinessId(businessId: string): string;

package/dist/Profile.js

@@ -15,8 +15,16 @@ export default class Profile {
         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);
+        // One link per business is reached through, and it is the one that names this customer. A profile can hold more
+        // than one link to a business - one that is not this customer's is not what a customer writes to a business with, nor
+        // what a link token of theirs signs - so a link that does not name this customer does not take the place of one that
+        // does, whichever comes last. Where none names them (no user is held yet), the last is kept.
+        const isOwn = (link) => this._user !== null && link.linkedEntityId === this._user.id;
+        for (const businessLink of this._businessLinks) {
+            const held = this._businessLinkMap.get(businessLink.businessId);
+            if (held === undefined || isOwn(businessLink) || !isOwn(held))
+                this._businessLinkMap.set(businessLink.businessId, businessLink);
+        }
     }
     // The id of the profile container this was built from, and what Model.signIn was given
     get profileId() {
@@ -42,10 +50,13 @@ export default class Profile {
     getBusinessLink(businessEntityId) {
         return this._businessLinkMap.get(businessEntityId) ?? null;
     }
-    // The same, by the url friendly business id a storefront is reached by
+    // The same, by the url friendly business id a storefront is reached by - however it is written in the url, which
+    // the server finds a business by whatever its case, and which the one here is not to fail: a customer who has joined
+    // it is not to be taken for one who has not, and asked to join it again
     getBusinessLinkFor(businessId) {
+        const wanted = canonicalizeBusinessId(businessId);
         for (const business of this._businesses)
-            if (business.businessId === businessId)
+            if (canonicalizeBusinessId(business.businessId) === wanted)
                 return this.getBusinessLink(business.id);
         return null;
     }
@@ -53,3 +64,79 @@ export default class Profile {
         return `Profile(profileId=${this._profileId}, user=${this._user?.formattedName ?? "none"}, businesses=${this._businesses.length})`;
     }
 }
+// A business id as the server makes it canonical (Java Business.canonicalizeBusinessId) to find one by it: with its spaces
+// normalized the way Java StringHelper.normalizeSpace does, and in lower case. A url is typed, and linked to, in any case, and a
+// business is the same business in all of them.
+// The spaces are not only those at either end, because a business id can hold some: Java makes one out of the display name when
+// none is given ("Warm Loaf_1a2b3c4d"), and takes whatever is typed, so a url that has two spaces where the id has one is still
+// that business. normalizeSpace is followed step for step, so as to give what Java gives for every string, quirks included: it
+// leaves a string alone that has no whitespace at either end and none twice in a row, and a non-breaking space is not whitespace
+// to it, so one between two words stays as it was, and is made a plain space only when something else of the string is normalized.
+// What Java then refuses, an id that is not between four and sixty-four characters long, is not refused here, since this is only
+// the comparison: the server answers a read of one with a NotFoundException, as it does for a business that does not exist.
+export function canonicalizeBusinessId(businessId) {
+    return normalizeSpace(businessId).toLowerCase();
+}
+// Java StringHelper.normalizeSpace, which answers null where this answers an empty string: a string of nothing but whitespace
+function normalizeSpace(input) {
+    if (!needsNormalization(input))
+        return input;
+    let result = "";
+    let whitespaceCount = 0;
+    let isAtStart = true;
+    for (let index = 0; index < input.length; ++index) {
+        const unit = input.charCodeAt(index);
+        if (isWhitespace(unit)) {
+            if (whitespaceCount === 0 && !isAtStart)
+                result += " ";
+            ++whitespaceCount;
+        }
+        else {
+            isAtStart = false;
+            result += unit === NO_BREAK_SPACE ? " " : input.charAt(index);
+            whitespaceCount = 0;
+        }
+    }
+    if (isAtStart)
+        return "";
+    // Java String.trim, which takes every character up to a space off either end, and not the trim of a script, which takes the
+    // spaces of Unicode. The space that stands for whitespace at the end goes with it: Java drops that one first, to the same end
+    let first = 0;
+    let last = result.length;
+    while (first < last && result.charCodeAt(first) <= SPACE)
+        ++first;
+    while (last > first && result.charCodeAt(last - 1) <= SPACE)
+        --last;
+    return result.slice(first, last);
+}
+// Java StringHelper.needsNormalization: whitespace at either end, or two together between
+function needsNormalization(input) {
+    if (input.length === 0)
+        return false;
+    if (isWhitespace(input.charCodeAt(0)) || isWhitespace(input.charCodeAt(input.length - 1)))
+        return true;
+    let wasWhitespace = false;
+    for (let index = 1; index < input.length - 1; ++index) {
+        const isNowWhitespace = isWhitespace(input.charCodeAt(index));
+        if (isNowWhitespace && wasWhitespace)
+            return true;
+        wasWhitespace = isNowWhitespace;
+    }
+    return false;
+}
+// Java Character.isWhitespace: the spaces of Unicode that do not hold a place (so not the no-break ones, U+00A0, U+2007 and
+// U+202F) and the controls that are spaces. Not what a regular expression's \s is, which has the no-break spaces and the
+// byte order mark, and has not the four separators U+001C to U+001F
+function isWhitespace(unit) {
+    if (unit === SPACE)
+        return true;
+    if (unit >= 0x09 && unit <= 0x0d)
+        return true; // Tab, line feed, vertical tab, form feed and carriage return
+    if (unit >= 0x1c && unit <= 0x1f)
+        return true; // The four separators
+    if (unit >= 0x2000 && unit <= 0x200a)
+        return unit !== 0x2007;
+    return unit === 0x1680 || unit === 0x2028 || unit === 0x2029 || unit === 0x205f || unit === 0x3000;
+}
+const SPACE = 0x20;
+const NO_BREAK_SPACE = 0xa0;

package/dist/ProtoMap.d.ts

@@ -34,25 +34,32 @@ export declare function getProfileResponseEntities(response: proto_ProfileSyncOu
 export declare function businessResponseToCacheWrite(response: proto_BusinessSyncOutResponse): CacheWrite;
 export declare function profileResponseToCacheWrite(response: proto_ProfileSyncOutResponse): CacheWrite;
 export declare function getBusinessResponseAttachmentBaseUrlExpiry(response: proto_BusinessSyncOutResponse | null): bigint;
-export declare function orderToBlob(order: proto_Message): StoredBlob;
+export declare function orderToBlob(order: proto_Message, heldETag: bigint | null): StoredBlob;
 export declare function isPartyPreferencesMessage(message: proto_Message): boolean;
 export declare function getMessageUpdatedAt(message: proto_Message): bigint;
-export declare function partyPreferencesToBlob(partyPreferences: proto_Message): StoredBlob;
+export declare function getMessageId(message: proto_Message): bigint;
+export declare function partyPreferencesToBlob(partyPreferences: proto_Message, heldETag: bigint | null): StoredBlob;
 export declare function businessResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_BusinessSyncOutResponse | null;
 export declare function profileResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_ProfileSyncOutResponse | null;
 export declare function orderMessagesFromBlobs(blobs: ReadonlyArray<StoredBlob>): ReadonlyArray<proto_Message>;
 export declare function partyPreferencesMessageFromMessages(messages: ReadonlyArray<proto_Message>): proto_Message | null;
 export declare function partyPreferencesMessageFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_Message | null;
-export declare function buildBusinessSyncOutRequest(businessId: string, syncInState: SyncState, attachmentBaseUrlExpiry: bigint): proto_BusinessSyncOutRequest;
-export declare function buildBusinessSyncOutRequestFromCache(businessId: string, cached: proto_BusinessSyncOutResponse | null): proto_BusinessSyncOutRequest;
+export declare function buildBusinessSyncOutRequest(business: string | bigint, syncInState: SyncState, attachmentBaseUrlExpiry: bigint): proto_BusinessSyncOutRequest;
+export declare function cursorsToBlobs(cursors: SyncState, movedKeys: ReadonlySet<number>): Array<StoredBlob>;
+export declare function cursorsFromBlobs(keys: ReadonlyArray<number>, blobs: ReadonlyArray<StoredBlob | null>): SyncState;
+export declare function raiseBusinessCursors(cursors: SyncState, response: proto_BusinessSyncOutResponse): ReadonlySet<number>;
 export declare function buildBusinessSyncInRequest(messageUpdateNumber: bigint, messages: ReadonlyArray<proto_Message>): proto_BusinessSyncInRequest;
 export declare function getSyncInResponseMessages(response: proto_BusinessSyncInResponse): ReadonlyArray<proto_Message>;
 export declare function buildProfileSyncOutRequest(syncInState: SyncState, joinBusinessId?: bigint): proto_ProfileSyncOutRequest;
-export declare function buildProfileSyncOutRequestFromCache(cached: proto_ProfileSyncOutResponse | null, joinBusinessId?: bigint): proto_ProfileSyncOutRequest;
+export declare function raiseProfileCursors(cursors: SyncState, response: proto_ProfileSyncOutResponse): ReadonlySet<number>;
 export declare function buildUser(userProfile: UserProfile): proto_User;
 export declare function buildUpdateUser(userProfile: UserProfile): proto_User;
 export declare function hasJoinedBusinessLink(joinBusinessId: bigint, response: proto_ProfileSyncOutResponse): boolean;
 export declare function hasJoinedBusiness(joinBusinessId: bigint, response: proto_ProfileSyncOutResponse): boolean;
+export declare function getBusinessResponseCountryCode(response: proto_BusinessSyncOutResponse | null): number | undefined;
+export declare function getBusinessResponseBusinessEntityId(response: proto_BusinessSyncOutResponse | null): bigint | null;
+export declare function getBusinessResponseBusinessId(response: proto_BusinessSyncOutResponse | null): string | null;
+export declare function isBusinessResponseOnlineShoppingOn(response: proto_BusinessSyncOutResponse | null): boolean;
 export declare function buildAuthTokens(authTokens: AuthTokens): proto_AuthTokens;
 export declare function authTokensFromProto(authTokens: proto_AuthTokens): AuthTokens;
 export declare function buildAuthTokensBytes(authTokens: proto_AuthTokens): Uint8Array;
@@ -65,10 +72,10 @@ export declare function nextBusinessSyncOutRequest(request: proto_BusinessSyncOu
 export declare function nextProfileSyncOutRequest(request: proto_ProfileSyncOutRequest, response: proto_ProfileSyncOutResponse): proto_ProfileSyncOutRequest | null;
 export declare function buildBusiness(response: proto_BusinessSyncOutResponse): Business | null;
 export declare function buildProfile(profileId: string, response: proto_ProfileSyncOutResponse): Profile | null;
-export declare function buildOrder(message: proto_Message): Order | null;
-export declare function buildShoppingList(message: proto_Message): ShoppingList;
+export declare function buildOrder(message: proto_Message, countryCode: number): Order | null;
+export declare function buildShoppingList(message: proto_Message, countryCode: number): ShoppingList;
 export declare function buildPartyPreferencesMessage(messageId: bigint, existing: proto_Message | null, senderId: bigint, shoppingList: ShoppingList | null, fulfillmentMode: proto_FulfillmentMode | null, now: bigint): proto_Message;
 export declare function buildOrderMessage(orderId: bigint, senderId: bigint, shoppingList: ShoppingList, fulfillmentMode: proto_FulfillmentMode, deliveryAddressId: bigint, deliveryAddress: Address | null, note: string | null, creationDate: bigint): proto_Message;
 export declare function messagesToCacheWrite(messages: ReadonlyArray<proto_Message>): CacheWrite;
-export declare function highestCachedMessageUpdateNumber(blobs: ReadonlyArray<StoredBlob>): bigint;
 export declare function hasShoppingListChanged(stored: proto_Message | null, shoppingList: ShoppingList): boolean;
+export declare function entityETag(updateNumber: bigint, updatedAt: bigint): bigint;