@lunora/client 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/packem_shared/OfflineQueue-BI0FNNvc.mjs

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

package/dist/packem_shared/SubscriptionRegistry-Dn-7k7eo.mjs

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

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

@@ -101,5 +101,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/{createIndexedDbQueryCache-B1PQ9Twl.mjs → createInMemoryQueryCache-4AkTV38-.mjs}

@@ -134,5 +134,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-DyFIHnWZ.mjs → createServerClient-CtklXrs2.mjs}

@@ -1,4 +1,4 @@
-import { LunoraClient } from './LunoraClient-B00f7VUM.mjs';
+import { LunoraClient } from './LunoraClient-6J-4BGWK.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 };