@lunora/client 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/packem_shared/OfflineQueue-GGYJRmhF.mjs

@@ -0,0 +1 @@
+export { O as OfflineQueue, n as nextId, r as reportPersistenceError } from './offline-queue-B9vfdSqp.mjs';

package/dist/packem_shared/SubscriptionRegistry-Cxr70og-.mjs

@@ -0,0 +1 @@
+export { S as SubscriptionRegistry } from './subscription-DoyO04-2.mjs';

package/dist/packem_shared/{createInMemoryPersistence-CW82inU5.mjs → createInMemoryPersistence-Ds7z8n8d.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const createInMemoryPersistence = () => {
   const entries = /* @__PURE__ */ new Map();
   const clone = (mutation) => {
@@ -25,7 +27,7 @@ const createInMemoryPersistence = () => {
     }
   };
 };
-const DEFAULT_DATABASE = "lunora";
+const DEFAULT_DATABASE = "lunora-outbox";
 const DEFAULT_STORE = "offline-mutations";
 const ID_INDEX = "by_id";
 const promisifyRequest = (request) => new Promise((resolve, reject) => {
@@ -39,7 +41,7 @@ const promisifyRequest = (request) => new Promise((resolve, reject) => {
 const createIndexedDbPersistence = (options = {}) => {
   const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
   if (!factory) {
-    throw new Error("createIndexedDbPersistence: no IndexedDB available — pass `indexedDB` or use createInMemoryPersistence()");
+    throw new LunoraError("INTERNAL", "createIndexedDbPersistence: no IndexedDB available — pass `indexedDB` or use createInMemoryPersistence()");
   }
   const databaseName = options.databaseName ?? DEFAULT_DATABASE;
   const storeName = options.storeName ?? DEFAULT_STORE;
@@ -101,5 +103,17 @@ const createIndexedDbPersistence = (options = {}) => {
     }
   };
 };
+const resolvePersistenceAdapter = (option, autoProbe = true) => {
+  if (option === false) {
+    return void 0;
+  }
+  if (option) {
+    return option;
+  }
+  if (!autoProbe || typeof indexedDB === "undefined") {
+    return void 0;
+  }
+  return createIndexedDbPersistence();
+};
 
-export { createInMemoryPersistence, createIndexedDbPersistence };
+export { createInMemoryPersistence, createIndexedDbPersistence, resolvePersistenceAdapter };

package/dist/packem_shared/{createInMemoryQueryCache-B1PQ9Twl.mjs → createInMemoryQueryCache-iWtKPrid.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const queryCacheKey = (functionPath, argsKey, shardKey) => `${functionPath}::${argsKey}::${shardKey ?? ""}`;
 const DEFAULT_MAX_ENTRIES = 500;
 const createInMemoryQueryCache = (options = {}) => {
@@ -35,10 +37,10 @@ const createInMemoryQueryCache = (options = {}) => {
     }
   };
 };
-const DEFAULT_DATABASE = "lunora";
+const DEFAULT_DATABASE = "lunora-query-cache";
 const DEFAULT_STORE = "query-cache";
 const TS_INDEX = "by_ts";
-const DATABASE_VERSION = 2;
+const DATABASE_VERSION = 1;
 const promisifyRequest = (request) => new Promise((resolve, reject) => {
   request.addEventListener("success", () => {
     resolve(request.result);
@@ -50,7 +52,7 @@ const promisifyRequest = (request) => new Promise((resolve, reject) => {
 const createIndexedDbQueryCache = (options = {}) => {
   const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
   if (!factory) {
-    throw new Error("createIndexedDbQueryCache: no IndexedDB available — pass `indexedDB` or use createInMemoryQueryCache()");
+    throw new LunoraError("INTERNAL", "createIndexedDbQueryCache: no IndexedDB available — pass `indexedDB` or use createInMemoryQueryCache()");
   }
   const databaseName = options.databaseName ?? DEFAULT_DATABASE;
   const storeName = options.storeName ?? DEFAULT_STORE;
@@ -134,5 +136,17 @@ const createIndexedDbQueryCache = (options = {}) => {
     }
   };
 };
+const resolveQueryCacheAdapter = (option) => {
+  if (option === false) {
+    return void 0;
+  }
+  if (option) {
+    return option;
+  }
+  if (typeof indexedDB === "undefined") {
+    return void 0;
+  }
+  return createIndexedDbQueryCache();
+};
 
-export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey };
+export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey, resolveQueryCacheAdapter };

package/dist/packem_shared/createLocalStore-IOur0jHF.mjs

@@ -0,0 +1 @@
+export { c as createLocalStore } from './local-store-BNgN3Dw3.mjs';

package/dist/packem_shared/createMutatorRunner-BETvCd0p.mjs

@@ -0,0 +1,31 @@
+const createMutatorRunner = (handle, sinks) => {
+  let inFlight = 0;
+  let latestInvocation = 0;
+  const mutate = async (args) => {
+    latestInvocation += 1;
+    const invocation = latestInvocation;
+    inFlight += 1;
+    sinks.setPending(true);
+    try {
+      await handle(args).isPersisted.promise;
+      if (invocation === latestInvocation) {
+        sinks.setError(void 0);
+      }
+    } catch (error) {
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      if (invocation === latestInvocation) {
+        sinks.setError(normalized);
+      }
+      throw normalized;
+    } finally {
+      inFlight -= 1;
+      sinks.setPending(inFlight > 0);
+    }
+  };
+  const reset = () => {
+    sinks.setError(void 0);
+  };
+  return { mutate, reset };
+};
+
+export { createMutatorRunner };

package/dist/packem_shared/{createServerClient-BjZc3gD8.mjs → createServerClient-CKKZrXLc.mjs}

@@ -1,4 +1,4 @@
-import { LunoraClient } from './LunoraClient-UiULzH_1.mjs';
+import { LunoraClient } from './LunoraClient-hrmLXEHd.mjs';
 
 const createServerClient = (options) => {
   const client = new LunoraClient({ fetch: options.fetch, url: options.url });

package/dist/packem_shared/local-store-BNgN3Dw3.mjs

@@ -0,0 +1,111 @@
+const foldOptimistic = (base, layers) => {
+  let value = base;
+  for (const layer of layers) {
+    try {
+      value = layer.transform(value);
+    } catch {
+    }
+  }
+  return value;
+};
+const notifySubscription = (state, value) => {
+  if (value === state.lastValue) {
+    return;
+  }
+  state.lastValue = value;
+  for (const callback of state.callbacks) {
+    try {
+      callback(value);
+    } catch {
+    }
+  }
+};
+const applyOptimisticLayer = (state, optimistic) => {
+  let next;
+  try {
+    next = optimistic(state.lastValue);
+  } catch {
+    return void 0;
+  }
+  const layer = { id: /* @__PURE__ */ Symbol("optimistic"), transform: optimistic };
+  state.optimisticLayers.push(layer);
+  notifySubscription(state, next);
+  const remove = () => {
+    const index = state.optimisticLayers.findIndex((entry) => entry.id === layer.id);
+    if (index === -1) {
+      return false;
+    }
+    state.optimisticLayers.splice(index, 1);
+    return true;
+  };
+  const refold = () => {
+    notifySubscription(state, foldOptimistic(state.serverBase, state.optimisticLayers));
+  };
+  return {
+    confirm: (commitCursor) => {
+      if (commitCursor === void 0) {
+        remove();
+        return;
+      }
+      layer.commitCursor = commitCursor;
+      if (state.serverCursor !== void 0 && state.serverCursor >= commitCursor && remove()) {
+        refold();
+      }
+    },
+    rollback: () => {
+      if (remove()) {
+        refold();
+      }
+    }
+  };
+};
+const dropConfirmedLayers = (state, cursor) => {
+  if (cursor === void 0 || state.optimisticLayers.length === 0) {
+    return false;
+  }
+  const before = state.optimisticLayers.length;
+  state.optimisticLayers = state.optimisticLayers.filter((layer) => layer.commitCursor === void 0 || layer.commitCursor > cursor);
+  return state.optimisticLayers.length !== before;
+};
+
+const createLocalStore = (subscriptions, shardKey, stableStringify) => {
+  const confirms = [];
+  const rollbacks = [];
+  const findState = (functionRef, argsKey) => {
+    for (const state of subscriptions.all()) {
+      if (state.fn.__lunoraRef === functionRef && state.shardKey === shardKey && state.argsKey === argsKey) {
+        return state;
+      }
+    }
+    return void 0;
+  };
+  const store = {
+    getAllQueries: (function_) => {
+      const matches = [];
+      for (const state of subscriptions.all()) {
+        if (state.fn.__lunoraRef === function_.__lunoraRef && state.shardKey === shardKey) {
+          matches.push({ args: state.args, value: state.lastValue });
+        }
+      }
+      return matches;
+    },
+    getQuery: (function_, args) => {
+      const state = findState(function_.__lunoraRef, stableStringify(args ?? {}));
+      return state?.lastValue;
+    },
+    setQuery: (function_, args, value) => {
+      const state = findState(function_.__lunoraRef, stableStringify(args ?? {}));
+      if (!state) {
+        return;
+      }
+      const handle = applyOptimisticLayer(state, () => value);
+      if (handle) {
+        confirms.push(handle.confirm);
+        rollbacks.push(handle.rollback);
+      }
+    }
+  };
+  return { confirms, rollbacks, store };
+};
+
+export { applyOptimisticLayer as a, createLocalStore as c, dropConfirmedLayers as d, foldOptimistic as f, notifySubscription as n };