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

package/dist/HttpStatusCodes.js

@@ -1,15 +1,15 @@
 import { BadRequestException, ConflictException, InternalServerException, MethodNotAllowedException, NotFoundException, ServiceException, ServiceUnavailableException, UnauthorizedException, UpgradeRequiredException, } from "./ServiceExceptions";
-// Which failure a status code stands for. The classes are in ServiceExceptions.ts. The split matches
-// Java's HttpStatusCodes and exception package, so the table of what each code means has one home
-// in each client.
+// Maps a status code to its exception. The classes are in ServiceExceptions.ts. The split matches
+// Java's HttpStatusCodes and exception package, so each client has one table of what each code
+// means.
 // Everything from 300 up (Java's HttpURLConnection.HTTP_MULT_CHOICE). A redirect counts as a
-// failure because this client follows none, so being sent elsewhere means the call did not happen.
+// failure because this client follows none, so 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 for a code that is not an error.
-// A code with no class of its own becomes a ServiceException carrying the code, so a new server
-// response cannot pass as a success.
+// Throws the exception for a status code, and does nothing for a code that is not an error. A code
+// with no class throws a ServiceException carrying the code, so an unlisted error code cannot pass
+// as a success.
 export function throwOnError(httpStatusCode, message) {
     if (!isError(httpStatusCode))
         return;

package/dist/Ids.js

@@ -22,8 +22,7 @@ class Ids {
     }
     // A fresh id for an entity this client creates (Java Entity.getRandomLongForId): random, never
     // in 0-255, which every entity type reserves. Only the low part is drawn, as buildId masks the
-    // rest off. It uses the cryptographic generator because a Math.random id is guessable and a
-    // message id can be handed to a caller.
+    // rest off. It uses the cryptographic generator because a Math.random id is guessable.
     static getNewId(entityTypeId) {
         for (;;) {
             const bytes = new Uint8Array(8);
@@ -55,9 +54,9 @@ class Ids {
     static toOrderNumberString(orderId) {
         return (orderId & Ids.UNSIGNED_32_BIT_MASK).toString(16).toUpperCase();
     }
-    // Where a container keeps how far its reads of one entity type have got. The blob's eTag is the
-    // cursor the next read sends, and the blob holds nothing else. The store keeps the greater eTag,
-    // so a cursor never drops on a stale or repeated page or a write from another tab. Written in
+    // The blob in which a container keeps the sync cursor of one entity type. Its eTag is the cursor
+    // the next read sends, and the blob holds no other data. The store keeps the greater eTag, so a
+    // stale or repeated page, or a write from another tab, cannot lower the cursor. It is written in
     // the batch of the page that moved it, so it cannot get ahead of the entities it describes. key
     // is one of SyncKeys.
     static getSyncCursorBlobId(key) {

package/dist/Item.js

@@ -2,7 +2,8 @@ import Entity from "./Entity";
 // Something a business buys or sells, or a category or price of one. Mirrors the protocol's Item, embedded in each of the five real types.
 // parentItemId is the wire parent (a product's category). Entity.parent is the sync layer's containment parent (the business).
 export default class Item extends Entity {
-    // Public because ProductCategory and PriceList add nothing of their own. The class is still abstract.
+    // Public because ProductCategory and PriceList declare no constructor and inherit this one. The
+    // class is still abstract.
     constructor(header, _name, _description, _parentItemId, _isDisabled) {
         super(header);
         this._name = _name;
@@ -20,9 +21,10 @@ export default class Item extends Entity {
     get parentItemId() {
         return this._parentItemId;
     }
-    // True when the business has disabled this item. Unlike isPublic and Product.isDraft, it can
-    // change after an item exists, so it is sent rather than filtered out. A product-level check does
-    // not guarantee that every package of an otherwise visible product is enabled.
+    // True when the business has disabled this item. The server filters out draft and non-public
+    // products, but this flag can change after an item exists, so a disabled item is sent flagged. A
+    // product-level check does not guarantee that every package of an otherwise visible product is
+    // enabled.
     get isDisabled() {
         return this._isDisabled;
     }

package/dist/LiveData.js

@@ -29,7 +29,7 @@ class LiveData {
     // 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).
+            // NOT_NOTIFIED means the immediate notification below has something to deliver; otherwise a new observer receives only future changes (not sticky, unlike Android LiveData).
             this._observers.set(observer, notifyImmediately ? LiveData.NOT_NOTIFIED : this._version);
         }
         if (notifyImmediately)
@@ -54,7 +54,7 @@ class LiveData {
                     if (this._isNotificationStale)
                         break; // Start again with the newer value
                     if (this._observers.get(observer) === this._version)
-                        continue; // Already told
+                        continue; // Already notified
                     this._observers.set(observer, this._version);
                     observer(this._holder);
                 }

package/dist/Measures.js

@@ -1,5 +1,6 @@
-// How big a package is and how much it weighs, grouped 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. A value displays in the unit the merchant entered it in, and nothing here converts between units.
+// How big a package is and how much it weighs, in one file since a UI showing one usually shows both.
+// Neither is an entity; both are values on Package.
+// Units are the generated proto enums. A value is shown in the unit the merchant entered it in, and nothing here converts between units.
 export class Dimensions {
     constructor(_unit, _length, _width, _height) {
         this._unit = _unit;

package/dist/Message.js

@@ -12,7 +12,7 @@ export default class Message extends Entity {
     }
     // The customer's party id at the business (BusinessLink.partyId), not the id of their User. A
     // business sync out sends a customer only messages from their own party. senderName and
-    // senderPhone say who it was without resolving the party.
+    // senderPhone identify the sender without resolving the party.
     get senderId() {
         return this._senderId;
     }

package/dist/MockDatabase.js

@@ -1,5 +1,6 @@
-// A Database that holds everything in a Map, for tests and training mode to run against with no
-// network. Enforces the eTag rule (write only if the new eTag is greater), so a test proves the sync is idempotent.
+// A Database that holds everything in a Map, for tests and training mode, which run with no
+// network. It enforces the eTag rule (a write applies only if its eTag is greater), so a test can
+// check that a sync is idempotent.
 export default class MockDatabase {
     constructor() {
         this._containers = new Map();
@@ -18,14 +19,14 @@ export default class MockDatabase {
     async deleteContainer(name) {
         this._containers.delete(name);
     }
-    // For a test that wants to look at what was stored without going through a sync
+    // Lets a test inspect what was stored without going through a sync
     getContainerIfPresent(name) {
         return this._containers.get(name) ?? null;
     }
 }
 export class MockContainer {
     constructor() {
-        // Set by a test just before the write it wants to fail
+        // A test sets this just before the write that should fail. That write clears it.
         this.failNextWrite = false;
         // How many times write has been called, so that a test can show a sync did not write per entity
         this.writeCount = 0;
@@ -56,7 +57,7 @@ export class MockContainer {
             this._blobs.delete(id);
         return appliedCount;
     }
-    // Greater eTag wins; a blob with no eTag (or overwriting one with none) is always written.
+    // The greater eTag wins. A write always applies when the incoming blob or the stored one has no eTag.
     static isNewer(incoming, stored) {
         if (stored === null)
             return true;