@peabody-soft/mbs-model-ts 1.7.0 → 1.7.1

package/dist/Order.js

@@ -3,11 +3,9 @@ import { amountFromScaledValue } from "./Constants";
 import Message from "./Message";
 // An order a customer has placed: a message carrying a sales order payload.
 // The business completes an order (fulfilling or cancelling it) by deleting its message, so
-// isDeleted is true of a completed order. That message is still the whole order: status and what
-// the customer ordered are there to show, as for an open one. status says how far the business
-// got with it.
-// deliveryAddressId is an id into the customer's address list. deliveryAddress is a full address
-// sent directly, and takes precedence over deliveryAddressId when both are present.
+// isDeleted is true of a completed order. The deleted message still holds the whole order, with
+// its status and what the customer ordered, as an open order does. status records how far the
+// business got with it.
 export default class Order extends Message {
     // For ProtoMap, which 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) {
@@ -34,22 +32,22 @@ export default class Order extends Message {
     get fulfillmentMode() {
         return this._fulfillmentMode;
     }
-    // What was ordered. An order completed before the business kept the list with it (an older
-    // merchant app moved the list into a record of the sale, which a customer never sees) holds
-    // ShoppingList.EMPTY, which has no lines. The totals below are then all that is left.
+    // What was ordered. An older merchant app moved the list of a completed order into a record of
+    // the sale, which a customer never sees. Such an order holds ShoppingList.EMPTY, which has no
+    // lines, and only the totals below remain.
     get shoppingList() {
         return this._shoppingList;
     }
-    // The authoritative total to display. Unlike a total read off the list, it survives the order
-    // having no list.
+    // The authoritative total to display. Unlike a total computed from the list, it is still
+    // available when the order has no list.
     get shoppingListTotal() {
         return this._shoppingListTotal;
     }
     get shoppingListCount() {
         return this._shoppingListCount;
     }
-    // Names an address in the customer's address list. Constants.ENTITY_ID_NULL when the order has no
-    // delivery address, as is normal for a pickup.
+    // The id of an address in the customer's address list, or Constants.ENTITY_ID_NULL when the order
+    // names none, as is normal for a pickup.
     get deliveryAddressId() {
         return this._deliveryAddressId;
     }

package/dist/PackageIdentifier.js

@@ -1,5 +1,5 @@
-// An identifier of a package, such as a GTIN, and its kind. Java keys kinds by string id, so map
-// through the comments in PackageIdentifierType.proto, never the enum ordinal.
+// An identifier of a package, such as a GTIN, and its kind. Java keys kinds by string id. Map a
+// kind using the comments in PackageIdentifierType.proto, not the enum ordinal.
 export default class PackageIdentifier {
     constructor(_type, _value) {
         this._type = _type;

package/dist/Price.js

@@ -1,11 +1,12 @@
 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.
+// What one package costs: the regular price and the offer price. Both are exposed as unscaled
+// numbers. On the wire they are multiplied by Constants.AMOUNT_FACTOR and stay well below 2^53,
+// so unscaling loses nothing.
 //
-// BOTH INCLUDE TAXES: the taxes of the package's product (Product.taxes) are in the price, not
-// added to it, so this is what a customer pays and what a catalog shows. A shopping list stores a
-// price without them, so a cart takes the taxes out (CartEditor).
+// BOTH INCLUDE TAXES: the taxes of the package's product (Product.taxes) are part of each price,
+// not added to it, so a price is what a customer pays and what a catalog shows. A shopping list
+// stores a price without taxes, so a cart takes them out (CartEditor).
 export default class Price extends Item {
     // For ProtoMap, which sees prices still multiplied by Constants.AMOUNT_FACTOR.
     static fromScaledValues(header, name, description, priceListId, isDisabled, packageId, scaledRegularPrice, scaledOfferPrice) {

package/dist/PriceList.js

@@ -1,5 +1,5 @@
 import Item from "./Item";
 // A named list of prices. A storefront sells from one, so no package has two prices to choose
-// between. Carried as an object, not a bare id, because a client naming a cart needs it.
+// between. Catalog.priceList holds it, and CartEditor names its id on the carts it builds.
 export default class PriceList extends Item {
 }

package/dist/Product.js

@@ -13,7 +13,7 @@ export default class Product extends Item {
         this._features = _features;
         this._isForOfflineSaleOnly = _isForOfflineSaleOnly;
         this._photos = _photos;
-        // A package that cannot be bought is not kept, whoever builds the product and whatever they pass in
+        // A package that cannot be bought is dropped, whatever the caller passes in
         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
@@ -38,11 +38,12 @@ export default class Product extends Item {
         return this._manufacturerAddress;
     }
     // The taxes included in the price of every package of this product (see Price), not added to it.
-    // A UI shows a price as is, and shows these only as part of what a bill's total includes.
+    // A UI shows a price as is, and shows these taxes only as the portion of a bill's total that
+    // they make up.
     get taxes() {
         return this._taxes;
     }
-    // One line bullet points about this product
+    // Bullet points about this product, one line each
     get features() {
         return this._features;
     }
@@ -62,19 +63,20 @@ export default class Product extends Item {
     }
     // The cheapest final price across variants (what a listing shows as "from"), or null if there
     // are no variants. Compares final price, since that is what a customer pays. Every variant is
-    // taxed at this product's rates, so prices with taxes order the variants as prices without would.
+    // taxed at this product's rates, so comparing prices with taxes gives the same order as
+    // comparing them without.
     get lowestPrice() {
         let result = null;
         for (const pkg of this._packages) {
             const price = pkg.price;
             if (price === null)
-                continue; // Not so of a buyable variant, though the type does not say
+                continue; // A buyable variant always has a price, but the type allows null
             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
+    // True when any variant of this product is on offer. A listing shows a badge for this.
     get isOnOffer() {
         for (const pkg of this._packages)
             if (pkg.price?.isOnOffer === true)

package/dist/Profile.js

@@ -26,7 +26,7 @@ export default class Profile {
                 this._businessLinkMap.set(businessLink.businessId, businessLink);
         }
     }
-    // The id of the profile container this was built from, and what Model.signIn was given
+    // The subject id that Model.signIn was given, which the profile container's name is built from
     get profileId() {
         return this._profileId;
     }
@@ -51,8 +51,8 @@ export default class Profile {
         return this._businessLinkMap.get(businessEntityId) ?? null;
     }
     // The same, by the url friendly business id a storefront is reached by, however it is written in
-    // the url. The server finds a business whatever the case, so this must too, or a customer who
-    // has joined would be asked to join again.
+    // the url. The server finds a business whatever the case, so this must too. Otherwise a customer
+    // who has joined would be treated as not a member and asked to join again.
     getBusinessLinkFor(businessId) {
         const wanted = canonicalizeBusinessId(businessId);
         for (const business of this._businesses)
@@ -68,15 +68,16 @@ export default class Profile {
 // spaces normalized as Java StringHelper.normalizeSpace does, then lower case. So a url typed in any
 // case or spacing names one business. Inner spaces count, as an id can hold some (Java builds one
 // from the display name, "Warm Loaf_1a2b3c4d", or takes what is typed).
-// normalizeSpace is followed step for step, quirks included: a string with no whitespace at either
-// end and none twice in a row is left alone, and a non-breaking space is not whitespace to it, so
-// one between words stays unless something else in the string is normalized.
-// Java refuses an id not four to sixty-four characters long. This is only a comparison and does
-// not. The server answers a read of such an id with NotFoundException, as for a missing business.
+// This follows normalizeSpace step for step, quirks included. A string with no whitespace at either
+// end and none twice in a row is returned unchanged. A non-breaking space does not count as
+// whitespace, but it becomes a plain space if the string is normalized for another reason.
+// Java rejects an id that is not four to sixty-four characters long. This function only normalizes
+// for comparison and does not check the length. The server answers a read of such an id with
+// NotFoundException, as for a missing business.
 export function canonicalizeBusinessId(businessId) {
     return normalizeSpace(businessId).toLowerCase();
 }
-// Java StringHelper.normalizeSpace. Where Java answers null (a string of only whitespace), this answers an empty string.
+// Java StringHelper.normalizeSpace. Where Java returns null (a string of only whitespace), this returns an empty string.
 function normalizeSpace(input) {
     if (!needsNormalization(input))
         return input;
@@ -98,8 +99,8 @@ function normalizeSpace(input) {
     }
     if (isAtStart)
         return "";
-    // Java String.trim removes every character up to a space from either end, unlike a script's trim, which removes
-    // Unicode spaces. The space standing for trailing whitespace goes with it (Java drops that one first, same result)
+    // Java String.trim removes every character up to a space from either end, unlike JavaScript's trim, which removes
+    // Unicode whitespace. The trailing space added for trailing whitespace is trimmed too (Java drops it first, with the same result)
     let first = 0;
     let last = result.length;
     while (first < last && result.charCodeAt(first) <= SPACE)
@@ -108,7 +109,7 @@ function normalizeSpace(input) {
         --last;
     return result.slice(first, last);
 }
-// Java StringHelper.needsNormalization: whitespace at either end, or two together between
+// Java StringHelper.needsNormalization: whitespace at either end, or two whitespace characters in a row inside
 function needsNormalization(input) {
     if (input.length === 0)
         return false;
@@ -123,8 +124,8 @@ function needsNormalization(input) {
     }
     return false;
 }
-// Java Character.isWhitespace: the Unicode spaces that do not hold a place (not the no-break ones U+00A0, U+2007 and
-// U+202F) and the control characters that are spaces. A regular expression's \s differs: it includes the no-break
+// Java Character.isWhitespace: the Unicode separators except the no-break ones (U+00A0, U+2007 and U+202F),
+// and the control characters that are whitespace. A regular expression's \s differs: it includes the no-break
 // spaces and the byte order mark, and excludes U+001C to U+001F
 function isWhitespace(unit) {
     if (unit === SPACE)