@peabody-soft/mbs-model-ts 1.4.0 → 1.6.0

package/dist/Routes.js

@@ -1,7 +1,7 @@
 // The last path segment of each call this library makes, appended to the base url a ServiceProxy is
-// built with. Named after the server method the segment reaches, in the kebab case Java Routes.java
-// uses, and prefixed to keep the storefront methods clear of the merchant ones that share the host.
-// No route takes an id: every one of these calls says everything it needs to in its request message.
+// built with. Named after the server method, in the kebab case Java Routes.java uses, with a prefix
+// that keeps storefront methods apart from the merchant ones on the same host.
+// No route takes an id: the request message carries everything.
 class Routes {
 }
 Routes.BUSINESS_SYNC_OUT = "shop-business-sync-out";

package/dist/ServiceExceptions.js

@@ -1,11 +1,11 @@
-// What a Service call fails with. Unlike the two in Exceptions.ts these are not programming errors:
-// a caller is expected to catch them and decide what to do - sign in again, retry, or show the shop
-// it already has cached. They mirror Java com.merabills.repository.client.exception so that the two
-// clients of this server describe the same failure the same way.
-// Each carries the status code rather than being told apart by a string, and the derived classes
-// exist so a caller can catch the one case it can actually handle without testing a number.
+// What a Service call fails with. Unlike the two in Exceptions.ts these are not programming errors.
+// A caller is expected to catch them and decide what to do: sign in again, retry, or show the shop
+// it has cached. They mirror Java com.merabills.repository.client.exception, so both clients of
+// this server describe a failure the same way.
+// Each carries the status code. The derived classes let a caller catch the one case it can handle
+// without testing a number.
 // A call reached the server and the server refused it. Thrown directly for a status code none of the
-// classes below names, so an unrecognised failure is still a ServiceException and not something else.
+// classes below names, so an unrecognised failure is still a ServiceException.
 export class ServiceException extends Error {
     constructor(httpStatusCode, message) {
         super(message);
@@ -70,9 +70,9 @@ export class ServiceUnavailableException extends ServiceException {
     }
 }
 ServiceUnavailableException.STATUS_CODE = 503;
-// The call never got an answer at all - offline, DNS, TLS, a refused connection or one cut short.
-// Not a ServiceException, because there is no status code and the server may well have acted on the
-// request: a caller that retries has to be prepared for the first attempt to have succeeded.
+// The call never got an answer: offline, DNS, TLS, a refused connection or one cut short.
+// Not a ServiceException, since there is no status code and the server may have acted on the
+// request. A caller that retries must be prepared for the first attempt to have succeeded.
 export class NetworkConnectionException extends Error {
     constructor(message, reason) {
         super(message);
@@ -80,5 +80,4 @@ export class NetworkConnectionException extends Error {
         this.name = new.target.name;
     }
 }
-// Which status code each of these stands for is HttpStatusCodes.ts, the way Java keeps the classes
-// in its exception package and the mapping in HttpStatusCodes.
+// The status code each of these stands for is mapped in HttpStatusCodes.ts.

package/dist/ServiceProxy.js

@@ -12,14 +12,13 @@ import { buildAuthTokensBytes } from "./ProtoMap";
 import Routes from "./Routes";
 import { NetworkConnectionException } from "./ServiceExceptions";
 // A Service that reaches a real MeraBills server. Every call is one POST to the route named after
-// it, carrying its request message encoded, and answering with the response message encoded - so
-// this class translates nothing and reads no field of either.
-// One call is one page: a sync out is paged, and the loop belongs to whoever is caching what comes
-// back, so that each page is written as it arrives - see Model.businessSyncIn.
+// it, with the encoded request message as the body and the encoded response message as the answer.
+// This class translates nothing and reads no field of either.
+// One call is one page: the loop over a paged sync out belongs to whoever caches what comes back,
+// so each page is written as it arrives (see Model.businessSyncIn).
 export default class ServiceProxy {
-    // The base url is everything before the route, with or without a trailing slash and with or
-    // without a path of its own - both are joined onto rather than replaced, so a server reached
-    // under a prefix works without the caller having to know how a route is built.
+    // The base url is everything before the route, with or without a trailing slash or a path of its
+    // own. The route is joined onto it, so a server reached under a prefix works.
     constructor(serviceBaseUrl, fetchFunction = null) {
         this._serviceBaseUrl = serviceBaseUrl.replace(TRAILING_SLASHES, "");
         this._fetchFunction = fetchFunction;
@@ -40,8 +39,8 @@ export default class ServiceProxy {
     async updateUser(user, authTokens) {
         return this.post(Routes.UPDATE_USER, proto_User, user, proto_ProfileSyncOutResponse, authTokens);
     }
-    // One call: encode, send, turn a refusal into the exception it stands for, decode. The message
-    // types are passed in rather than named per call so that every route is sent and read identically.
+    // One call: encode, send, turn a refusal into its exception, decode. The message types are
+    // passed in so every route is sent and read the same way.
     async post(route, requestType, request, responseType, authTokens) {
         const response = await this.send(route, requestType.toBinary(request), authTokens);
         // The body of a failure is not a response message, so it has to be dealt with before decoding
@@ -51,8 +50,8 @@ export default class ServiceProxy {
     }
     async send(route, body, authTokens) {
         const headers = { [CONTENT_TYPE_HEADER]: CONTENT_TYPE_PROTOBUF };
-        // An anonymous visitor is given no header at all rather than an empty one - the protocol has no
-        // anonymous form of the message, so the absence is what says nobody is claiming to be calling.
+        // An anonymous visitor gets no header, not an empty one. The protocol has no anonymous form of
+        // the message, so the absence says nobody claims to be calling.
         if (authTokens !== null)
             headers[AUTHORIZATION_HEADER] = toBase64(buildAuthTokensBytes(authTokens));
         try {
@@ -63,14 +62,13 @@ export default class ServiceProxy {
             });
         }
         catch (reason) {
-            // fetch rejects only when no answer arrived at all; a server that refused the call answers
-            // with a status code and resolves. So the request may still have been acted on, and a caller
-            // that retries has to be prepared for the first attempt to have succeeded.
+            // fetch rejects only when no answer arrived. A refusal resolves with a status code. See
+            // NetworkConnectionException for what a caller must expect.
             throw new NetworkConnectionException(`The call to ${route} could not be completed`, reason);
         }
     }
-    // Resolved per call rather than at construction, so a platform that installs fetch after this
-    // object is built still works and an absent one fails where it is actually needed.
+    // Resolved per call, not at construction, so a platform that installs fetch after this object is
+    // built still works and an absent fetch fails where it is needed.
     getFetchFunction() {
         const supplied = this._fetchFunction;
         if (supplied !== null)
@@ -82,9 +80,8 @@ export default class ServiceProxy {
         return platform.bind(globalThis);
     }
     // What the response says went wrong, if anything. This protocol has no error message of its own
-    // yet, so the body of a failure can be anything at all - a stack trace, an HTML page - and only
-    // the start of one is worth carrying; a body that cannot be read says nothing the status code
-    // does not already.
+    // yet, so a failure body can be anything (a stack trace, an HTML page) and only its start is
+    // worth carrying. A body that cannot be read adds nothing to the status code.
     static async readErrorMessage(route, response) {
         let body;
         try {
@@ -99,11 +96,10 @@ export default class ServiceProxy {
     }
 }
 // A header carries text, so the encoded credentials travel as base64. No scheme prefix: the server
-// reads the whole value as one encoded AuthTokens, exactly as the Java client sends the whole value
-// as one serialized AuthTokens.
+// reads the whole value as one encoded AuthTokens, as the Java client sends it.
 function toBase64(bytes) {
-    // Built a character at a time rather than by spreading the array into String.fromCharCode, which
-    // passes it as an argument list and overflows the stack once it is long enough
+    // Built a character at a time, since spreading the array into String.fromCharCode passes it as an
+    // argument list and overflows the stack when long enough
     let binary = "";
     for (const byte of bytes)
         binary += String.fromCharCode(byte);

package/dist/ShoppingList.d.ts

@@ -1,4 +1,5 @@
-import Tax from "./Tax";
+import { ReservedPackage as proto_ReservedPackage } from "./generated/ReservedPackage";
+import Tax, { TaxAmount } from "./Tax";
 export default class ShoppingList {
     private readonly _isFinal;
     private readonly _autoAddDeliveryCharge;
@@ -12,6 +13,7 @@ export default class ShoppingList {
     private readonly _existingItems;
     private readonly _deletedItems;
     static fromScaledValues(isFinal: boolean, autoAddDeliveryCharge: boolean, autoAddServiceCharge: boolean, inventoryLocationId: number, priceListId: bigint, scaledTotalAmountBeforeDiscount: bigint, scaledDiscount: bigint, existingItemCount: number, deletedItemCount: number, existingItems: ReadonlyArray<ShoppingListItem>, deletedItems: ReadonlyArray<ShoppingListItem>): ShoppingList;
+    static sumOfFinalPrices(items: ReadonlyArray<ShoppingListItem>): number;
     constructor(_isFinal: boolean, _autoAddDeliveryCharge: boolean, _autoAddServiceCharge: boolean, _inventoryLocationId: number, _priceListId: bigint, _totalAmountBeforeDiscount: number, _discount: number, _existingItemCount: number, _deletedItemCount: number, _existingItems: ReadonlyArray<ShoppingListItem>, _deletedItems: ReadonlyArray<ShoppingListItem>);
     get isFinal(): boolean;
     get autoAddDeliveryCharge(): boolean;
@@ -26,8 +28,19 @@ export default class ShoppingList {
     get itemCount(): number;
     get existingItems(): ReadonlyArray<ShoppingListItem>;
     get deletedItems(): ReadonlyArray<ShoppingListItem>;
+    get goodsItems(): ReadonlyArray<ShoppingListItem>;
+    get chargeItems(): ReadonlyArray<ShoppingListItem>;
+    get deliveryCharge(): ShoppingListItem | null;
+    get serviceCharge(): ShoppingListItem | null;
+    get removedItems(): ReadonlyArray<ShoppingListItem>;
+    changeOf(item: ShoppingListItem): ItemChange;
     get computedTotal(): number;
+    get computedGoodsTotal(): number;
     get computedTotalTax(): number;
+    get computedTaxes(): ReadonlyArray<TaxAmount>;
+    get computedTotalWithoutDiscounts(): number;
+    get savings(): number;
+    private get derived();
     static readonly EMPTY: ShoppingList;
 }
 export declare class ShoppingListItem {
@@ -47,18 +60,34 @@ export declare class ShoppingListItem {
     constructor(_packageId: bigint, _quantity: number, _unitPrice: number, _shoppingListOrder: number, _isOriginal: boolean, _isModified: boolean, _isStockKeepingRequired: boolean, _priceDiscount: number, _discount: number, _taxes: ReadonlyArray<Tax>, _expiryMinutes: number, _description: string | null);
     get packageId(): bigint;
     get isReservedPackage(): boolean;
+    get reservedPackage(): proto_ReservedPackage | null;
     get quantity(): number;
     get unitPrice(): number;
     get shoppingListOrder(): number;
     get isOriginal(): boolean;
     get isModified(): boolean;
+    get change(): ItemChange;
     get isStockKeepingRequired(): boolean;
     get priceDiscount(): number;
     get discount(): number;
     get taxes(): ReadonlyArray<Tax>;
     get expiryMinutes(): number;
     get description(): string | null;
+    get regularUnitPrice(): number;
+    get unitPriceWithTaxes(): number;
+    get regularUnitPriceWithTaxes(): number;
     get amount(): number;
+    get taxAmounts(): ReadonlyArray<number>;
     get totalTax(): number;
     get finalPrice(): number;
+    get finalPriceWithoutDiscounts(): number;
+    get isDiscounted(): boolean;
+    get isFree(): boolean;
 }
+export declare enum ItemChange {
+    NONE = 0,
+    ADDED = 1,
+    MODIFIED = 2,
+    REMOVED = 3
+}
+export declare function validatePricing(item: ShoppingListItem): void;