@anfenn/zync 0.1.9 → 0.1.10

package/dist/index.js

@@ -2,27 +2,253 @@
 import { create } from "zustand";
 import { persist } from "zustand/middleware";
 
+// src/logger.ts
+function newLogger(base, min) {
+  const order = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    none: 100
+  };
+  const threshold = order[min];
+  const enabled = (lvl) => order[lvl] >= threshold;
+  return {
+    debug: (...a) => enabled("debug") && base.debug?.(...a),
+    info: (...a) => enabled("info") && base.info?.(...a),
+    warn: (...a) => enabled("warn") && base.warn?.(...a),
+    error: (...a) => enabled("error") && base.error?.(...a)
+  };
+}
+
+// src/helpers.ts
+function nextLocalId() {
+  return crypto.randomUUID();
+}
+function orderFor(a) {
+  switch (a) {
+    case "createOrUpdate" /* CreateOrUpdate */:
+      return 1;
+    case "remove" /* Remove */:
+      return 2;
+  }
+}
+function omitSyncFields(item, fields) {
+  const result = { ...item };
+  for (const k of fields) delete result[k];
+  return result;
+}
+function samePendingVersion(get, stateKey, localId, version) {
+  const q = get().syncState.pendingChanges || [];
+  const curChange = q.find((p) => p.localId === localId && p.stateKey === stateKey);
+  return curChange?.version === version;
+}
+function removeFromPendingChanges(set, localId, stateKey) {
+  set((s) => {
+    const queue = (s.syncState.pendingChanges || []).filter((p) => !(p.localId === localId && p.stateKey === stateKey));
+    return {
+      syncState: {
+        ...s.syncState || {},
+        pendingChanges: queue
+      }
+    };
+  });
+}
+function findApi(stateKey, syncApi) {
+  const api = syncApi[stateKey];
+  if (!api || !api.add || !api.update || !api.remove || !api.list || !api.firstLoad) {
+    throw new Error(`Missing API function(s) for state key: ${stateKey}.`);
+  }
+  return api;
+}
+
+// src/pull.ts
+async function pull(set, get, stateKey, api, logger) {
+  const lastPulled = get().syncState.lastPulled || {};
+  const lastPulledAt = new Date(lastPulled[stateKey] || /* @__PURE__ */ new Date(0));
+  logger.debug(`[Zync] pull:start stateKey=${stateKey} since=${lastPulledAt.toISOString()}`);
+  const serverData = await api.list(lastPulledAt);
+  if (!serverData?.length) return;
+  let newest = lastPulledAt;
+  set((state) => {
+    const pendingChanges = state.syncState.pendingChanges || [];
+    const localItems = state[stateKey] || [];
+    let nextItems = [...localItems];
+    const localById = new Map(localItems.filter((l) => l.id).map((l) => [l.id, l]));
+    const pendingRemovalById = new Set(pendingChanges.filter((p) => p.stateKey === stateKey && p.action === "remove" /* Remove */).map((p) => p.id));
+    for (const remote of serverData) {
+      const remoteUpdated = new Date(remote.updated_at);
+      if (remoteUpdated > newest) newest = remoteUpdated;
+      if (pendingRemovalById.has(remote.id)) {
+        logger.debug(`[Zync] pull:skip-pending-remove stateKey=${stateKey} id=${remote.id}`);
+        continue;
+      }
+      const localItem = localById.get(remote.id);
+      if (remote.deleted) {
+        if (localItem) {
+          nextItems = nextItems.filter((i) => i.id !== remote.id);
+          logger.debug(`[Zync] pull:remove stateKey=${stateKey} id=${remote.id}`);
+        }
+        continue;
+      }
+      const pending = localItem && pendingChanges.some((p) => p.stateKey === stateKey && p.localId === localItem._localId);
+      if (localItem && !pending) {
+        const merged = {
+          ...localItem,
+          ...remote,
+          _localId: localItem._localId
+        };
+        nextItems = nextItems.map((i) => i._localId === localItem._localId ? merged : i);
+        logger.debug(`[Zync] pull:merge stateKey=${stateKey} id=${remote.id}`);
+      } else if (!localItem) {
+        nextItems = [...nextItems, { ...remote, _localId: nextLocalId() }];
+        logger.debug(`[Zync] pull:add stateKey=${stateKey} id=${remote.id}`);
+      }
+    }
+    return {
+      [stateKey]: nextItems,
+      syncState: {
+        ...state.syncState || {},
+        lastPulled: {
+          ...state.syncState.lastPulled || {},
+          [stateKey]: newest.toISOString()
+        }
+      }
+    };
+  });
+}
+
+// src/push.ts
+var SYNC_FIELDS = ["id", "_localId", "updated_at", "deleted"];
+async function pushOne(set, get, change, api, logger, queueToSync, missingStrategy, onMissingRemoteRecordDuringUpdate, onAfterRemoteAdd) {
+  logger.debug(`[Zync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
+  const { action, stateKey, localId, id, version } = change;
+  switch (action) {
+    case "remove" /* Remove */:
+      await api.remove(id);
+      logger.debug(`[Zync] push:remove:success ${stateKey} ${localId} ${id}`);
+      removeFromPendingChanges(set, localId, stateKey);
+      break;
+    case "createOrUpdate" /* CreateOrUpdate */: {
+      const state = get();
+      const items = state[stateKey] || [];
+      const item = items.find((i) => i._localId === localId);
+      if (!item) {
+        logger.warn(`[Zync] push:${action}:no-local-item`, {
+          stateKey,
+          localId
+        });
+        removeFromPendingChanges(set, localId, stateKey);
+        return;
+      }
+      const omittedItem = omitSyncFields(item, SYNC_FIELDS);
+      if (item.id) {
+        const changed = await api.update(item.id, omittedItem);
+        if (changed) {
+          logger.debug("[Zync] push:update:success", {
+            stateKey,
+            localId,
+            id: item.id
+          });
+          if (samePendingVersion(get, stateKey, localId, version)) {
+            removeFromPendingChanges(set, localId, stateKey);
+          }
+          return;
+        } else {
+          logger.warn("[Zync] push:update:missingRemote", {
+            stateKey,
+            localId,
+            id: item.id
+          });
+          switch (missingStrategy) {
+            case "deleteLocalRecord":
+              set((s) => ({
+                [stateKey]: (s[stateKey] || []).filter((i) => i._localId !== localId)
+              }));
+              break;
+            case "insertNewRemoteRecord": {
+              omittedItem._localId = crypto.randomUUID();
+              omittedItem.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+              set((s) => ({
+                [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? omittedItem : i)
+              }));
+              queueToSync("createOrUpdate" /* CreateOrUpdate */, stateKey, omittedItem._localId);
+              break;
+            }
+          }
+          removeFromPendingChanges(set, localId, stateKey);
+          onMissingRemoteRecordDuringUpdate?.(missingStrategy, omittedItem, omittedItem._localId);
+        }
+        return;
+      }
+      const result = await api.add(omittedItem);
+      if (result) {
+        logger.debug("[Zync] push:create:success", {
+          stateKey,
+          localId,
+          id: result.id
+        });
+        set((s) => ({
+          [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? { ...i, ...result } : i)
+        }));
+        if (samePendingVersion(get, stateKey, localId, version)) {
+          removeFromPendingChanges(set, localId, stateKey);
+        }
+        onAfterRemoteAdd?.(set, get, queueToSync, stateKey, {
+          ...item,
+          ...result
+        });
+      } else {
+        logger.warn("[Zync] push:create:no-result", {
+          stateKey,
+          localId
+        });
+        if (samePendingVersion(get, stateKey, localId, version)) {
+          removeFromPendingChanges(set, localId, stateKey);
+        }
+      }
+      break;
+    }
+  }
+}
+
 // src/indexedDBStorage.ts
-import { openDB } from "idb";
 function createIndexedDBStorage(options) {
   const dbName = options.dbName;
   const storeName = options.storeName;
-  let dbPromise = openDB(dbName, 1, {
-    upgrade(db) {
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
+  let dbPromise = null;
+  async function initDB() {
+    if (dbPromise) return dbPromise;
+    try {
+      const idb = await import(
+        /* webpackChunkName: "idb" */
+        "./build-ELJGW24D.js"
+      );
+      dbPromise = idb.openDB(dbName, 1, {
+        upgrade(db) {
+          if (!db.objectStoreNames.contains(storeName)) {
+            db.createObjectStore(storeName);
+          }
+        }
+      });
+      return dbPromise;
+    } catch (_e) {
+      throw new Error('Missing optional dependency "idb". Install it to use IndexedDB storage: npm install idb');
     }
-  });
+  }
   async function ensureStore() {
-    const db = await dbPromise;
+    const db = await initDB();
     if (db.objectStoreNames.contains(storeName)) return;
     const nextVersion = (db.version || 0) + 1;
     try {
       db.close();
-    } catch (e) {
+    } catch (_e) {
     }
-    dbPromise = openDB(dbName, nextVersion, {
+    const idb = await import(
+      /* webpackChunkName: "idb" */
+      "./build-ELJGW24D.js"
+    );
+    dbPromise = idb.openDB(dbName, nextVersion, {
       upgrade(upg) {
         if (!upg.objectStoreNames.contains(storeName)) upg.createObjectStore(storeName);
       }
@@ -31,13 +257,13 @@ function createIndexedDBStorage(options) {
   }
   async function withRetry(fn) {
     try {
-      const db = await dbPromise;
+      const db = await initDB();
       return await fn(db);
     } catch (err) {
       const msg = String(err && err.message ? err.message : err);
       if (err && (err.name === "NotFoundError" || /objectStore/i.test(msg))) {
         await ensureStore();
-        const db2 = await dbPromise;
+        const db2 = await initDB();
         return await fn(db2);
       }
       throw err;
@@ -74,7 +300,14 @@ var DEFAULT_SYNC_INTERVAL_MILLIS = 5e3;
 var DEFAULT_LOGGER = console;
 var DEFAULT_MIN_LOG_LEVEL = "debug";
 var DEFAULT_MISSING_REMOTE_RECORD_ON_UPDATE_STRATEGY = "ignore";
-var SYNC_FIELDS = ["id", "_localId", "updated_at", "deleted"];
+function createWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}) {
+  const store = create(persistWithSync(stateCreator, persistOptions, syncApi, syncOptions));
+  return new Promise((resolve) => {
+    store.persist.onFinishHydration((_state) => {
+      resolve(store);
+    });
+  });
+}
 function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}) {
   const syncInterval = syncOptions.syncInterval ?? DEFAULT_SYNC_INTERVAL_MILLIS;
   const missingStrategy = syncOptions.missingRemoteRecordDuringUpdateStrategy ?? DEFAULT_MISSING_REMOTE_RECORD_ON_UPDATE_STRATEGY;
@@ -84,13 +317,13 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
   const wrappedPersistOptions = {
     ...persistOptions,
     onRehydrateStorage: () => {
-      logger.debug("[persistWithSync] Rehydration started");
+      logger.debug("[Zync] Rehydration started");
       return (state, error) => {
         if (error) {
-          logger.error("[persistWithSync] Rehydration failed", error);
+          logger.error("[Zync] Rehydration failed", error);
         } else {
           baseOnRehydrate?.(state, error);
-          logger.debug("[persistWithSync] Rehydration complete", state.syncState);
+          logger.debug("[Zync] Rehydration complete", state);
         }
       };
     },
@@ -107,12 +340,11 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
       };
     },
     merge: (persisted, current) => {
+      const state = { ...current, ...persisted };
       return {
-        ...current,
-        ...persisted,
+        ...state,
         syncState: {
-          ...current?.syncState,
-          ...persisted?.syncState,
+          ...state.syncState,
           status: "idle"
           // this confirms 'hydrating' is done
         }
@@ -137,7 +369,7 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
           await pull(set, get, stateKey, api, logger);
         } catch (err) {
           syncError = syncError ?? err;
-          logger.error(`[persistWithSync] Pull error for stateKey: ${stateKey}`, err);
+          logger.error(`[Zync] Pull error for stateKey: ${stateKey}`, err);
         }
       }
       const snapshot = [...get().syncState.pendingChanges || []];
@@ -158,7 +390,7 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
           );
         } catch (err) {
           syncError = syncError ?? err;
-          logger.error(`[persistWithSync] Push error for change: ${change}`, err);
+          logger.error(`[Zync] Push error for change: ${change}`, err);
         }
       }
       set((state2) => ({
@@ -172,40 +404,97 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
         await syncOnce();
       }
     }
+    async function startFirstLoad() {
+      let syncError;
+      for (const stateKey of Object.keys(syncApi)) {
+        try {
+          logger.info(`[Zync] firstLoad:start for stateKey: ${stateKey}`);
+          const api = findApi(stateKey, syncApi);
+          let lastId;
+          while (true) {
+            const batch = await api.firstLoad(lastId);
+            if (!batch?.length) break;
+            set((state) => {
+              const local = state[stateKey] || [];
+              const localById = new Map(local.filter((l) => l.id).map((l) => [l.id, l]));
+              let newest = new Date(state.syncState.lastPulled[stateKey] || 0);
+              const next = [...local];
+              for (const remote of batch) {
+                const remoteUpdated = new Date(remote.updated_at || 0);
+                if (remoteUpdated > newest) newest = remoteUpdated;
+                if (remote.deleted) continue;
+                const localItem = remote.id ? localById.get(remote.id) : void 0;
+                if (localItem) {
+                  const merged = {
+                    ...localItem,
+                    ...remote,
+                    _localId: localItem._localId
+                  };
+                  const idx = next.findIndex((i) => i._localId === localItem._localId);
+                  if (idx >= 0) next[idx] = merged;
+                } else {
+                  next.push({
+                    ...remote,
+                    _localId: nextLocalId()
+                  });
+                }
+              }
+              return {
+                [stateKey]: next,
+                syncState: {
+                  ...state.syncState || {},
+                  lastPulled: {
+                    ...state.syncState.lastPulled || {},
+                    [stateKey]: newest.toISOString()
+                  }
+                }
+              };
+            });
+            lastId = batch[batch.length - 1].id;
+          }
+          logger.info(`[Zync] firstLoad:done for stateKey: ${stateKey}`);
+        } catch (err) {
+          syncError = syncError ?? err;
+          logger.error(`[Zync] First load pull error for stateKey: ${stateKey}`, err);
+        }
+      }
+      set((state) => ({
+        syncState: {
+          ...state.syncState || {},
+          firstLoadDone: true,
+          error: syncError
+        }
+      }));
+    }
     function queueToSync(action, stateKey, ...localIds) {
       set((state) => {
-        const queue = state.syncState.pendingChanges || [];
+        const pendingChanges = state.syncState.pendingChanges || [];
         for (const localId of localIds) {
           const item = state[stateKey].find((i) => i._localId === localId);
           if (!item) {
-            logger.error("[persistWithSync] queueToSync:no-local-item", {
-              stateKey,
-              localId
-            });
-            continue;
-          }
-          if (action === "remove" /* Remove */ && !item.id) {
-            logger.warn("[persistWithSync] queueToSync:remove-no-id", {
+            logger.error("[Zync] queueToSync:no-local-item", {
               stateKey,
               localId
             });
             continue;
           }
-          const queueItem = queue.find((p) => p.localId === localId && p.stateKey === stateKey);
+          const queueItem = pendingChanges.find((p) => p.localId === localId && p.stateKey === stateKey);
           if (queueItem) {
             queueItem.version += 1;
             if (queueItem.action === "createOrUpdate" /* CreateOrUpdate */ && action === "remove" /* Remove */ && item.id) {
               queueItem.action = "remove" /* Remove */;
               queueItem.id = item.id;
             }
+            logger.debug(`[Zync] queueToSync:adjusted ${queueItem.version} ${action} ${item.id} ${stateKey} ${localId}`);
           } else {
-            queue.push({ action, stateKey, localId, id: item.id, version: 1 });
+            pendingChanges.push({ action, stateKey, localId, id: item.id, version: 1 });
+            logger.debug(`[Zync] queueToSync:added ${action} ${item.id} ${stateKey} ${localId}`);
           }
         }
         return {
           syncState: {
             ...state.syncState || {},
-            pendingChanges: queue
+            pendingChanges
           }
         };
       });
@@ -246,75 +535,13 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
     }
     function onVisibilityChange() {
       if (document.visibilityState === "visible") {
-        logger.debug("[persistWithSync] Sync started now app is in foreground");
+        logger.debug("[Zync] Sync started now app is in foreground");
         enableSyncTimer(true);
       } else {
-        logger.debug("[persistWithSync] Sync paused now app is in background");
+        logger.debug("[Zync] Sync paused now app is in background");
         enableSyncTimer(false);
       }
     }
-    async function startFirstLoad() {
-      let syncError;
-      for (const stateKey of Object.keys(syncApi)) {
-        try {
-          logger.info(`[persistWithSync] firstLoad:start for stateKey: ${stateKey}`);
-          const api = findApi(stateKey, syncApi);
-          let lastId;
-          while (true) {
-            const batch = await api.firstLoad(lastId);
-            if (!batch?.length) break;
-            set((state) => {
-              const local = state[stateKey] || [];
-              const localById = new Map(local.filter((l) => l.id).map((l) => [l.id, l]));
-              let newest = new Date(state.syncState.lastPulled[stateKey] || 0);
-              const next = [...local];
-              for (const remote of batch) {
-                const remoteUpdated = new Date(remote.updated_at || 0);
-                if (remoteUpdated > newest) newest = remoteUpdated;
-                if (remote.deleted) continue;
-                const localItem = remote.id ? localById.get(remote.id) : void 0;
-                if (localItem) {
-                  const merged = {
-                    ...localItem,
-                    ...remote,
-                    _localId: localItem._localId
-                  };
-                  const idx = next.findIndex((i) => i._localId === localItem._localId);
-                  if (idx >= 0) next[idx] = merged;
-                } else {
-                  next.push({
-                    ...remote,
-                    _localId: nextLocalId()
-                  });
-                }
-              }
-              return {
-                [stateKey]: next,
-                syncState: {
-                  ...state.syncState || {},
-                  lastPulled: {
-                    ...state.syncState.lastPulled || {},
-                    [stateKey]: newest.toISOString()
-                  }
-                }
-              };
-            });
-            lastId = batch[batch.length - 1].id;
-          }
-          logger.info(`[persistWithSync] firstLoad:done for stateKey: ${stateKey}`);
-        } catch (err) {
-          syncError = syncError ?? err;
-          logger.error(`[persistWithSync] First load pull error for stateKey: ${stateKey}`, err);
-        }
-      }
-      set((state) => ({
-        syncState: {
-          ...state.syncState || {},
-          firstLoadDone: true,
-          error: syncError
-        }
-      }));
-    }
     storeApi.sync = {
       enable,
       startFirstLoad
@@ -335,219 +562,10 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
   };
   return persist(creator, wrappedPersistOptions);
 }
-function createStoreWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}) {
-  return create(persistWithSync(stateCreator, persistOptions, syncApi, syncOptions));
-}
-function orderFor(a) {
-  switch (a) {
-    case "createOrUpdate" /* CreateOrUpdate */:
-      return 1;
-    case "remove" /* Remove */:
-      return 2;
-  }
-}
-async function pull(set, get, stateKey, api, logger) {
-  const lastPulled = get().syncState.lastPulled || {};
-  const lastPulledAt = new Date(lastPulled[stateKey] || /* @__PURE__ */ new Date(0));
-  logger.debug(`[persistWithSync] pull:start stateKey=${stateKey} since=${lastPulledAt.toISOString()}`);
-  const serverData = await api.list(lastPulledAt);
-  if (!serverData?.length) return;
-  let newest = lastPulledAt;
-  set((state) => {
-    const pendingChanges = state.syncState.pendingChanges || [];
-    const localItems = state[stateKey] || [];
-    let nextItems = [...localItems];
-    const localById = new Map(localItems.filter((l) => l.id).map((l) => [l.id, l]));
-    const pendingRemovalIds = /* @__PURE__ */ new Set();
-    for (const change of pendingChanges) {
-      if (change.stateKey === stateKey && change.action === "remove" /* Remove */) {
-        const item = localItems.find((i) => i._localId === change.localId);
-        if (item && item.id) pendingRemovalIds.add(item.id);
-      }
-    }
-    for (const remote of serverData) {
-      const remoteUpdated = new Date(remote.updated_at);
-      if (remoteUpdated > newest) newest = remoteUpdated;
-      const localItem = localById.get(remote.id);
-      if (pendingRemovalIds.has(remote.id)) {
-        logger.debug(`[persistWithSync] pull:skip-pending-remove stateKey=${stateKey} id=${remote.id}`);
-        continue;
-      }
-      if (remote.deleted) {
-        if (localItem) {
-          nextItems = nextItems.filter((i) => i.id !== remote.id);
-          logger.debug(`[persistWithSync] pull:remove stateKey=${stateKey} id=${remote.id}`);
-        }
-        continue;
-      }
-      const pending = localItem && pendingChanges.some((p) => p.stateKey === stateKey && p.localId === localItem._localId);
-      if (localItem && !pending) {
-        const merged = {
-          ...localItem,
-          ...remote,
-          _localId: localItem._localId
-        };
-        nextItems = nextItems.map((i) => i._localId === localItem._localId ? merged : i);
-        logger.debug(`[persistWithSync] pull:merge stateKey=${stateKey} id=${remote.id}`);
-      } else if (!localItem) {
-        nextItems = [...nextItems, { ...remote, _localId: nextLocalId() }];
-        logger.debug(`[persistWithSync] pull:add stateKey=${stateKey} id=${remote.id}`);
-      }
-    }
-    return {
-      [stateKey]: nextItems,
-      syncState: {
-        ...state.syncState || {},
-        lastPulled: {
-          ...state.syncState.lastPulled || {},
-          [stateKey]: newest.toISOString()
-        }
-      }
-    };
-  });
-}
-async function pushOne(set, get, change, api, logger, queueToSync, missingStrategy, onMissingRemoteRecordDuringUpdate, onAfterRemoteAdd) {
-  logger.debug(`[persistWithSync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
-  const { action, stateKey, localId, id, version } = change;
-  switch (action) {
-    case "remove" /* Remove */:
-      await api.remove(id);
-      logger.debug(`[persistWithSync] push:remove:success ${stateKey} ${localId} ${id}`);
-      removeFromPendingChanges(set, localId, stateKey);
-      break;
-    case "createOrUpdate" /* CreateOrUpdate */:
-      const state = get();
-      const items = state[stateKey] || [];
-      const item = items.find((i) => i._localId === localId);
-      if (!item) {
-        logger.warn(`[persistWithSync] push:${action}:no-local-item`, {
-          stateKey,
-          localId
-        });
-        removeFromPendingChanges(set, localId, stateKey);
-        return;
-      }
-      let omittedItem = omitSyncFields(item);
-      if (item.id) {
-        const changed = await api.update(item.id, omittedItem);
-        if (changed) {
-          logger.debug("[persistWithSync] push:update:success", {
-            stateKey,
-            localId,
-            id: item.id
-          });
-          if (samePendingVersion(get, stateKey, localId, version)) {
-            removeFromPendingChanges(set, localId, stateKey);
-          }
-          return;
-        } else {
-          logger.warn("[persistWithSync] push:update:missingRemote", {
-            stateKey,
-            localId,
-            id: item.id
-          });
-          switch (missingStrategy) {
-            case "deleteLocalRecord":
-              set((s) => ({
-                [stateKey]: (s[stateKey] || []).filter((i) => i._localId !== localId)
-              }));
-              break;
-            case "insertNewRemoteRecord": {
-              omittedItem._localId = nextLocalId();
-              omittedItem.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-              set((s) => ({
-                [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? omittedItem : i)
-              }));
-              queueToSync("createOrUpdate" /* CreateOrUpdate */, stateKey, omittedItem._localId);
-              break;
-            }
-          }
-          removeFromPendingChanges(set, localId, stateKey);
-          onMissingRemoteRecordDuringUpdate?.(missingStrategy, omittedItem, omittedItem._localId);
-        }
-        return;
-      }
-      const result = await api.add(omittedItem);
-      if (result) {
-        logger.debug("[persistWithSync] push:create:success", {
-          stateKey,
-          localId,
-          id: result.id
-        });
-        set((s) => ({
-          [stateKey]: (s[stateKey] || []).map((i) => i._localId === localId ? { ...i, ...result } : i)
-        }));
-        if (samePendingVersion(get, stateKey, localId, version)) {
-          removeFromPendingChanges(set, localId, stateKey);
-        }
-        onAfterRemoteAdd?.(set, get, queueToSync, stateKey, {
-          ...item,
-          ...result
-        });
-      } else {
-        logger.warn("[persistWithSync] push:create:no-result", {
-          stateKey,
-          localId
-        });
-        if (samePendingVersion(get, stateKey, localId, version)) {
-          removeFromPendingChanges(set, localId, stateKey);
-        }
-      }
-      break;
-  }
-}
-function samePendingVersion(get, stateKey, localId, version) {
-  const q = get().syncState.pendingChanges || [];
-  const curChange = q.find((p) => p.localId === localId && p.stateKey === stateKey);
-  return curChange?.version === version;
-}
-function removeFromPendingChanges(set, localId, stateKey) {
-  set((s) => {
-    const queue = (s.syncState.pendingChanges || []).filter((p) => !(p.localId === localId && p.stateKey === stateKey));
-    return {
-      syncState: {
-        ...s.syncState || {},
-        pendingChanges: queue
-      }
-    };
-  });
-}
-function omitSyncFields(item) {
-  const result = { ...item };
-  for (const k of SYNC_FIELDS) delete result[k];
-  return result;
-}
-function nextLocalId() {
-  return crypto.randomUUID();
-}
-function newLogger(logger, min) {
-  const order = {
-    debug: 10,
-    info: 20,
-    warn: 30,
-    error: 40,
-    none: 100
-  };
-  const threshold = order[min];
-  const enabled = (lvl) => order[lvl] >= threshold;
-  return {
-    debug: (...a) => enabled("debug") && logger.debug?.(...a),
-    info: (...a) => enabled("info") && logger.info?.(...a),
-    warn: (...a) => enabled("warn") && logger.warn?.(...a),
-    error: (...a) => enabled("error") && logger.error?.(...a)
-  };
-}
-function findApi(stateKey, syncApi) {
-  const api = syncApi[stateKey];
-  if (!api || !api.add || !api.update || !api.remove || !api.list || !api.firstLoad) {
-    throw new Error(`Missing API function(s) for state key: ${stateKey}.`);
-  }
-  return api;
-}
 export {
   SyncAction,
   createIndexedDBStorage,
-  createStoreWithSync,
+  createWithSync,
   nextLocalId,
   persistWithSync
 };