@tallyui/pos 3.0.0-next.0 → 3.0.0-next.1

package/dist/index.d.ts

@@ -177,7 +177,7 @@ declare function resolveStoreSettings(options: ResolveStoreSettingsOptions, choi
 /** The replication's context with the settings' opaque pricing context; the key is left out when the settings have none. */
 declare function withPricingContext(context: SyncContext, settings: StoreSettings): SyncContext;
 /**
- * `<TaxProvider>`'s props from the same settings, so its tax inclusivity and rounding match the store's. `custom`
+ * `<TaxProvider>`'s props from the same settings, so its tax inclusivity, rounding and rate codes match the store's. `custom`
  * rounding passes none, the default (#287). An explicit `rounding` prop after the spread still wins, since JSX
  * applies props in order; so `<TaxProvider {...taxProviderProps(s)} rounding={undefined}>` wipes the store's rounding.
  */
@@ -198,6 +198,7 @@ type StoreSettingsState = {
     state: 'error';
     error: unknown;
     retry: () => void;
+    nextRetryAt?: number;
 } | {
     state: 'unsupported';
 };
@@ -208,6 +209,7 @@ type StoreSettingsState = {
  * The ready settings carry the store's `taxRounding` from the capabilities, so `taxProviderProps` passes it on (#324).
  * The capabilities are read beside the settings, before `ready`, so each resolve emits the settings once, with the
  * rounding already known: no later change of `settings` holds a sale.
+ * Unknown rounding keeps settings unresolved and retries by itself; show "Can't reach the store's settings yet. Retrying…" while `nextRetryAt` is set.
  *
  * ```tsx
  * const store = useStoreSettings({ connector, context, loadChoice, saveChoice });

package/dist/index.js

@@ -319,26 +319,45 @@ function withPricingContext(context, settings) {
 }
 function taxProviderProps(settings) {
   const rounding = settings.taxRounding?.granularity === "custom" ? void 0 : settings.taxRounding;
-  return { ratesPpm: settings.taxRatesPpm, pricesIncludeTax: settings.pricesIncludeTax, ...rounding && { rounding } };
+  return { ratesPpm: settings.taxRatesPpm, pricesIncludeTax: settings.pricesIncludeTax, ...rounding && { rounding }, ...settings.taxRateCodes && { rateCodes: settings.taxRateCodes } };
 }
 
 // src/store-settings/use-store-settings.ts
 import { useCallback as useCallback2, useEffect, useRef, useState } from "react";
 var LOADING = { state: "loading" };
+var StoreCapabilitiesUnavailableError = class extends Error {
+  constructor(cause) {
+    super("Store capabilities unavailable", { cause });
+    this.name = "StoreCapabilitiesUnavailableError";
+  }
+};
+var INITIAL_RETRY_MS = 5e3;
+var MAX_RETRY_MS = 5 * 6e4;
 function readTaxRounding({ connector, context }) {
   if (context.capabilities) return Promise.resolve(context.capabilities.taxRounding);
   if (!connector.storeSettings || !connector.capabilities) return Promise.resolve(void 0);
   const read = connector.capabilities;
-  return Promise.resolve().then(() => read(context)).then((capabilities) => capabilities?.taxRounding, () => void 0);
+  return Promise.resolve().then(() => read(context)).then(
+    (capabilities) => {
+      if (!capabilities) throw new StoreCapabilitiesUnavailableError();
+      return capabilities.taxRounding;
+    },
+    (cause) => {
+      throw new StoreCapabilitiesUnavailableError(cause);
+    }
+  );
 }
 function useStoreSettings(options) {
   const { connector, context } = options;
   const optionsRef = useRef(options);
   optionsRef.current = options;
   const requestRef = useRef(0);
+  const retryTimerRef = useRef(void 0);
+  const retryDelayRef = useRef(INITIAL_RETRY_MS);
   const [state, setState] = useState(LOADING);
   const resolve = useCallback2((choice, from, known) => {
     if (from !== void 0 && from !== requestRef.current) return;
+    clearTimeout(retryTimerRef.current);
     const request = ++requestRef.current;
     const current = () => request === requestRef.current;
     setState(LOADING);
@@ -346,6 +365,7 @@ function useStoreSettings(options) {
     Promise.all([resolveStoreSettings(optionsRef.current, choice), rounding]).then(
       ([result, taxRounding]) => {
         if (!current()) return;
+        retryDelayRef.current = INITIAL_RETRY_MS;
         if (result.status === "ready")
           setState({ state: "ready", settings: taxRounding ? { ...result.settings, taxRounding } : result.settings, choice: result.choice });
         else if (result.status === "choose")
@@ -354,13 +374,23 @@ function useStoreSettings(options) {
       },
       // A retry keeps the choice that failed: a new pick is saved only once it resolves.
       (error) => {
-        if (current()) setState({ state: "error", error, retry: () => resolve(choice, request) });
+        if (!current()) return;
+        const retry = () => resolve(choice, request);
+        if (error instanceof StoreCapabilitiesUnavailableError) {
+          const delay = retryDelayRef.current;
+          const nextRetryAt = Date.now() + delay;
+          retryDelayRef.current = Math.min(delay * 2, MAX_RETRY_MS);
+          retryTimerRef.current = setTimeout(retry, delay);
+          setState({ state: "error", error, retry, nextRetryAt });
+        } else setState({ state: "error", error, retry });
       }
     );
   }, []);
   useEffect(() => {
     resolve();
     return () => {
+      clearTimeout(retryTimerRef.current);
+      retryDelayRef.current = INITIAL_RETRY_MS;
       requestRef.current += 1;
     };
   }, [connector, context, resolve]);
@@ -3980,6 +4010,7 @@ function createOrderOutbox(options) {
   }
   const bare = ({ serverFailures, _rev, _meta, ...data }) => data;
   const failuresOnly = (before, after) => !deepEqual2(before.serverFailures, after.serverFailures) && deepEqual2(bare(before), bare(after));
+  const recordsSentForm = (before, after) => deepEqual2(bare({ ...freezeSentForm(before), sentVersion: before.sentVersion ?? after.sentVersion }), bare(after));
   async function updateState(patch = {}) {
     const pending = await countFresh(collection, { syncStatus: "pending" });
     const rejected = await countFresh(collection, { syncStatus: "rejected" });
@@ -4311,7 +4342,7 @@ function createOrderOutbox(options) {
       stopped = false;
       watchBackendMissing();
       if (!subscription) subscription = collection.$.subscribe((event) => {
-        if (event.documentData?.syncStatus === "pending" && (event.operation === "INSERT" || event.operation === "UPDATE" && !(event.previousDocumentData !== void 0 && failuresOnly(event.previousDocumentData, event.documentData)))) {
+        if (event.documentData?.syncStatus === "pending" && (event.operation === "INSERT" || event.operation === "UPDATE" && !(event.previousDocumentData !== void 0 && (failuresOnly(event.previousDocumentData, event.documentData) || recordsSentForm(event.previousDocumentData, event.documentData))))) {
           insertedDuringRun = true;
           flush().catch(() => {
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyui/pos",
-  "version": "3.0.0-next.0",
+  "version": "3.0.0-next.1",
   "type": "module",
   "description": "Shared POS business logic for Tally UI — tax, orders, payments, discounts, receipts",
   "main": "./dist/index.js",
@@ -27,20 +27,20 @@
     "directory": "packages/pos"
   },
   "peerDependencies": {
-    "@tallyui/core": "^3.0.0-next.0",
+    "@tallyui/core": "^3.0.0-next.1",
     "react": ">=18",
     "rxdb": "~17.5.0",
     "rxjs": ">=7"
   },
   "devDependencies": {
-    "@tallyui/core": "3.0.0-next.0",
+    "@tallyui/core": "3.0.0-next.1",
     "@types/react": ">=18",
     "react": "^19.2.4",
     "rxdb": "17.5.0",
     "rxjs": "7.8.2",
-    "@tallyui/connector-medusa": "3.0.0-next.0",
-    "@tallyui/connector-woocommerce": "3.0.0-next.0",
-    "@tallyui/database": "3.0.0-next.0"
+    "@tallyui/connector-medusa": "3.0.0-next.1",
+    "@tallyui/connector-woocommerce": "3.0.0-next.1",
+    "@tallyui/database": "3.0.0-next.1"
   },
   "scripts": {
     "build": "tsup",

package/src/outbox/order-outbox.ts

@@ -166,6 +166,10 @@ export function createOrderOutbox(options: OrderOutboxOptions): OrderOutbox {
   const bare = ({ serverFailures, _rev, _meta, ...data }: RxDocumentData<PosOrder>) => data;
   const failuresOnly = (before: RxDocumentData<PosOrder>, after: RxDocumentData<PosOrder>) =>
     !deepEqual(before.serverFailures, after.serverFailures) && deepEqual(bare(before), bare(after));
+  // The outbox's own write of an order's sent form (#300): the form frozen, and sentVersion stored on a first send.
+  // Not new work (medusapos/app#160). A changed sentVersion (a downgrade) is not this write.
+  const recordsSentForm = (before: RxDocumentData<PosOrder>, after: RxDocumentData<PosOrder>) =>
+    deepEqual(bare({ ...freezeSentForm(before), sentVersion: before.sentVersion ?? after.sentVersion } as RxDocumentData<PosOrder>), bare(after));
 
   // Every read bypasses the query cache. RxDB 17 fixed RxDB 16.21.1's bug 4 (rxdb#7067);
   // readFresh, countFresh and watchFresh remain correct public API.
@@ -482,7 +486,8 @@ export function createOrderOutbox(options: OrderOutboxOptions): OrderOutbox {
       if (!subscription) subscription = collection.$.subscribe((event) => {
         // An UPDATE without previousDocumentData counts as a change: a needless send costs a request, a skipped one a sale.
         if (event.documentData?.syncStatus === 'pending' && (event.operation === 'INSERT' || event.operation === 'UPDATE' &&
-          !(event.previousDocumentData !== undefined && failuresOnly(event.previousDocumentData, event.documentData)))) {
+          !(event.previousDocumentData !== undefined && (failuresOnly(event.previousDocumentData, event.documentData)
+            || recordsSentForm(event.previousDocumentData, event.documentData))))) {
           insertedDuringRun = true;
           flush().catch(() => {});
         }

package/src/store-settings/map-store-settings.ts

@@ -8,11 +8,11 @@ export function withPricingContext(context: SyncContext, settings: StoreSettings
 }
 
 /**
- * `<TaxProvider>`'s props from the same settings, so its tax inclusivity and rounding match the store's. `custom`
+ * `<TaxProvider>`'s props from the same settings, so its tax inclusivity, rounding and rate codes match the store's. `custom`
  * rounding passes none, the default (#287). An explicit `rounding` prop after the spread still wins, since JSX
  * applies props in order; so `<TaxProvider {...taxProviderProps(s)} rounding={undefined}>` wipes the store's rounding.
  */
 export function taxProviderProps(settings: StoreSettings): Omit<TaxProviderProps, 'children'> {
   const rounding = settings.taxRounding?.granularity === 'custom' ? undefined : settings.taxRounding;
-  return { ratesPpm: settings.taxRatesPpm, pricesIncludeTax: settings.pricesIncludeTax, ...(rounding && { rounding }) };
+  return { ratesPpm: settings.taxRatesPpm, pricesIncludeTax: settings.pricesIncludeTax, ...(rounding && { rounding }), ...(settings.taxRateCodes && { rateCodes: settings.taxRateCodes }) };
 }

package/src/store-settings/use-store-settings.ts

@@ -7,19 +7,35 @@ export type StoreSettingsState =
   | { state: 'loading' }
   | { state: 'ready'; settings: StoreSettings; choice?: StoreSettingsChoice }
   | { state: 'choose'; choices: StoreSettingsChoices; initial?: StoreSettingsChoice; choose: (choice: StoreSettingsChoice) => void }
-  | { state: 'error'; error: unknown; retry: () => void }
+  | { state: 'error'; error: unknown; retry: () => void; nextRetryAt?: number }
   | { state: 'unsupported' };
 
 // One object, so re-entering loading while already loading doesn't re-render.
 const LOADING: StoreSettingsState = { state: 'loading' };
 
-// The store's taxRounding (#324): the context's capabilities, else one read of the connector's. A failure or no
-// value leaves the field out, the default rounding; so does a connector without `capabilities`, with no read.
+export class StoreCapabilitiesUnavailableError extends Error {
+  constructor(cause?: unknown) {
+    super('Store capabilities unavailable', { cause });
+    this.name = 'StoreCapabilitiesUnavailableError';
+  }
+}
+
+// Exponential retry for unknown rounding: 5 seconds, doubling up to 5 minutes.
+const INITIAL_RETRY_MS = 5_000;
+const MAX_RETRY_MS = 5 * 60_000;
+
+// The store's taxRounding (#324): the context's capabilities, else one read of the connector's.
 function readTaxRounding({ connector, context }: ResolveStoreSettingsOptions): Promise<TaxRounding | undefined> {
   if (context.capabilities) return Promise.resolve(context.capabilities.taxRounding);
   if (!connector.storeSettings || !connector.capabilities) return Promise.resolve(undefined);
   const read = connector.capabilities;
-  return Promise.resolve().then(() => read(context)).then((capabilities) => capabilities?.taxRounding, () => undefined);
+  return Promise.resolve().then(() => read(context)).then(
+    (capabilities) => {
+      if (!capabilities) throw new StoreCapabilitiesUnavailableError();
+      return capabilities.taxRounding;
+    },
+    (cause) => { throw new StoreCapabilitiesUnavailableError(cause); },
+  );
 }
 
 /**
@@ -29,6 +45,7 @@ function readTaxRounding({ connector, context }: ResolveStoreSettingsOptions): P
  * The ready settings carry the store's `taxRounding` from the capabilities, so `taxProviderProps` passes it on (#324).
  * The capabilities are read beside the settings, before `ready`, so each resolve emits the settings once, with the
  * rounding already known: no later change of `settings` holds a sale.
+ * Unknown rounding keeps settings unresolved and retries by itself; show "Can't reach the store's settings yet. Retrying…" while `nextRetryAt` is set.
  *
  * ```tsx
  * const store = useStoreSettings({ connector, context, loadChoice, saveChoice });
@@ -44,6 +61,8 @@ export function useStoreSettings(options: ResolveStoreSettingsOptions): StoreSet
   const optionsRef = useRef(options);
   optionsRef.current = options;
   const requestRef = useRef(0);
+  const retryTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+  const retryDelayRef = useRef(INITIAL_RETRY_MS);
   const [state, setState] = useState<StoreSettingsState>(LOADING);
 
   // `from`, when given, is the request that created the `choose`/`retry` calling this: a call
@@ -52,6 +71,7 @@ export function useStoreSettings(options: ResolveStoreSettingsOptions): StoreSet
   // a pick doesn't read it again.
   const resolve = useCallback((choice?: StoreSettingsChoice, from?: number, known?: Promise<TaxRounding | undefined>) => {
     if (from !== undefined && from !== requestRef.current) return;
+    clearTimeout(retryTimerRef.current);
     const request = ++requestRef.current;
     const current = () => request === requestRef.current;
     setState(LOADING);
@@ -59,6 +79,7 @@ export function useStoreSettings(options: ResolveStoreSettingsOptions): StoreSet
     Promise.all([resolveStoreSettings(optionsRef.current, choice), rounding]).then(
       ([result, taxRounding]) => {
         if (!current()) return;
+        retryDelayRef.current = INITIAL_RETRY_MS;
         if (result.status === 'ready')
           setState({ state: 'ready', settings: taxRounding ? { ...result.settings, taxRounding } : result.settings, choice: result.choice });
         else if (result.status === 'choose')
@@ -67,7 +88,15 @@ export function useStoreSettings(options: ResolveStoreSettingsOptions): StoreSet
       },
       // A retry keeps the choice that failed: a new pick is saved only once it resolves.
       (error: unknown) => {
-        if (current()) setState({ state: 'error', error, retry: () => resolve(choice, request) });
+        if (!current()) return;
+        const retry = () => resolve(choice, request);
+        if (error instanceof StoreCapabilitiesUnavailableError) {
+          const delay = retryDelayRef.current;
+          const nextRetryAt = Date.now() + delay;
+          retryDelayRef.current = Math.min(delay * 2, MAX_RETRY_MS);
+          retryTimerRef.current = setTimeout(retry, delay);
+          setState({ state: 'error', error, retry, nextRetryAt });
+        } else setState({ state: 'error', error, retry });
       },
     );
   }, []);
@@ -76,6 +105,8 @@ export function useStoreSettings(options: ResolveStoreSettingsOptions): StoreSet
     resolve();
     // Discards the in-flight result on a store switch or unmount.
     return () => {
+      clearTimeout(retryTimerRef.current);
+      retryDelayRef.current = INITIAL_RETRY_MS;
       requestRef.current += 1;
     };
   }, [connector, context, resolve]);