@lunora/client 1.0.0-alpha.22 → 1.0.0-alpha.221

package/dist/packem_shared/createInMemoryQueryCache-DiaGZkA2.mjs

@@ -1,112 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { p as promisifyRequest, c as createWithStore, a as createDatabaseOpener } from './idb-utility-DrSVX43Q.mjs';
-
-const queryCacheKey = (functionPath, argsKey, shardKey) => `${functionPath}::${argsKey}::${shardKey ?? ""}`;
-const DEFAULT_MAX_ENTRIES = 500;
-const createInMemoryQueryCache = (options = {}) => {
-  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  const entries = /* @__PURE__ */ new Map();
-  const clone = (entry) => {
-    return { ...entry, value: structuredClone(entry.value) };
-  };
-  const evict = () => {
-    if (entries.size <= maxEntries) {
-      return;
-    }
-    const ordered = [...entries.values()].toSorted((a, b) => a.ts - b.ts);
-    for (const entry of ordered) {
-      if (entries.size <= maxEntries) {
-        break;
-      }
-      entries.delete(entry.key);
-    }
-  };
-  return {
-    clear: () => {
-      entries.clear();
-      return Promise.resolve();
-    },
-    load: () => Promise.resolve([...entries.values()].map((entry) => clone(entry))),
-    put: (key, entry) => {
-      entries.set(key, clone({ ...entry, key }));
-      evict();
-      return Promise.resolve();
-    },
-    remove: (key) => {
-      entries.delete(key);
-      return Promise.resolve();
-    }
-  };
-};
-const DEFAULT_DATABASE = "lunora-query-cache";
-const DEFAULT_STORE = "query-cache";
-const TS_INDEX = "by_ts";
-const DATABASE_VERSION = 1;
-const createIndexedDbQueryCache = (options = {}) => {
-  const factory = options.indexedDB ?? (typeof indexedDB === "undefined" ? void 0 : indexedDB);
-  if (!factory) {
-    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;
-  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  const openDatabase = createDatabaseOpener(factory, databaseName, DATABASE_VERSION, (database) => {
-    if (!database.objectStoreNames.contains(storeName)) {
-      const store = database.createObjectStore(storeName, { keyPath: "key" });
-      store.createIndex(TS_INDEX, "ts", { unique: false });
-    }
-  });
-  const withStore = createWithStore(openDatabase, storeName);
-  const evict = async (store) => {
-    const count = await promisifyRequest(store.count());
-    let overflow = count - maxEntries;
-    if (overflow <= 0) {
-      return;
-    }
-    await new Promise((resolve, reject) => {
-      const cursorRequest = store.index(TS_INDEX).openCursor();
-      cursorRequest.addEventListener("success", () => {
-        const cursor = cursorRequest.result;
-        if (!cursor || overflow <= 0) {
-          resolve();
-          return;
-        }
-        cursor.delete();
-        overflow -= 1;
-        cursor.continue();
-      });
-      cursorRequest.addEventListener("error", () => {
-        reject(cursorRequest.error ?? new Error("IndexedDB eviction failed"));
-      });
-    });
-  };
-  return {
-    clear: async () => {
-      await withStore("readwrite", (store) => promisifyRequest(store.clear()));
-    },
-    load: async () => withStore("readonly", (store) => promisifyRequest(store.getAll())),
-    put: async (key, entry) => {
-      await withStore("readwrite", async (store) => {
-        await promisifyRequest(store.put({ ...entry, key }));
-        await evict(store);
-      });
-    },
-    remove: async (key) => {
-      await withStore("readwrite", (store) => promisifyRequest(store.delete(key)));
-    }
-  };
-};
-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, resolveQueryCacheAdapter };

package/dist/packem_shared/createLocalStore-BDbbkoXw.mjs

@@ -1,2 +0,0 @@
-export { c as createLocalStore } from './local-store-DtcIW4c0.mjs';
-import './SubscriptionRegistry-D4jfIzZu.mjs';

package/dist/packem_shared/createMutationRunner-BqsavzvG.mjs

@@ -1,21 +0,0 @@
-const createMutationRunner = (client, function_, sinks) => {
-  let inFlight = 0;
-  return async (args, options) => {
-    inFlight += 1;
-    sinks.setPending(true);
-    try {
-      const result = await client.mutation(function_, args, options);
-      sinks.setResult(result);
-      return result;
-    } catch (error) {
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      sinks.setError(normalized);
-      throw normalized;
-    } finally {
-      inFlight -= 1;
-      sinks.setPending(inFlight > 0);
-    }
-  };
-};
-
-export { createMutationRunner };

package/dist/packem_shared/createMutatorRunner-BETvCd0p.mjs

@@ -1,31 +0,0 @@
-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/createReconnect-Di_-oHH7.mjs

@@ -1,22 +0,0 @@
-const createReconnect = (options = {}, random = Math.random) => {
-  const initialDelayMs = options.initialDelayMs ?? 250;
-  const maxDelayMs = options.maxDelayMs ?? 3e4;
-  const jitter = options.jitter ?? true;
-  let attempt = 0;
-  return {
-    next() {
-      const exponential = Math.min(maxDelayMs, initialDelayMs * 2 ** attempt);
-      attempt += 1;
-      if (!jitter) {
-        return exponential;
-      }
-      const min = exponential / 2;
-      return Math.floor(min + random() * (exponential - min));
-    },
-    reset() {
-      attempt = 0;
-    }
-  };
-};
-
-export { createReconnect };

package/dist/packem_shared/createReply-lI4tVS2w.mjs

@@ -1,36 +0,0 @@
-const sendToSw = (sw, message, expectResponse = false) => new Promise((resolve, reject) => {
-  if (!sw) {
-    reject(new Error("No active service worker"));
-    return;
-  }
-  const id = message.correlationId ?? crypto.randomUUID();
-  const outgoingMessage = { ...message, correlationId: id };
-  if (expectResponse) {
-    let timer;
-    const handler = (event) => {
-      if (event.data.correlationId === id) {
-        clearTimeout(timer);
-        navigator.serviceWorker.removeEventListener("message", handler);
-        resolve(event.data.payload);
-      }
-    };
-    timer = setTimeout(() => {
-      navigator.serviceWorker.removeEventListener("message", handler);
-      reject(new Error(`SW message ${id} timed out`));
-    }, 3e4);
-    navigator.serviceWorker.addEventListener("message", handler);
-    sw.postMessage(outgoingMessage);
-  } else {
-    sw.postMessage(outgoingMessage);
-    resolve(void 0);
-  }
-});
-const createReply = (original, payload) => {
-  return {
-    type: `${original.type}:reply`,
-    payload,
-    correlationId: original.correlationId
-  };
-};
-
-export { createReply, sendToSw };

package/dist/packem_shared/createServerClient-Dxemst5C.mjs

@@ -1,11 +0,0 @@
-import { LunoraClient } from './LunoraClient-Clb118SU.mjs';
-
-const createServerClient = (options) => {
-  const client = new LunoraClient({ fetch: options.fetch, url: options.url });
-  if (options.token !== void 0) {
-    client.setAuthToken(options.token);
-  }
-  return client;
-};
-
-export { createServerClient };

package/dist/packem_shared/createSnapshotPrecondition-CBwnVz6r.mjs

@@ -1,18 +0,0 @@
-import { s as stableStringify } from './stable-key-wv6eP48B.mjs';
-
-const createSnapshotPrecondition = (client, functionRef, args, shardKey) => {
-  const snapshot = client.peekActiveQueryValue(functionRef.__lunoraRef, args, shardKey);
-  const snapshotKey = snapshot === void 0 ? void 0 : stableStringify(snapshot);
-  return () => {
-    const current = client.peekActiveQueryValue(functionRef.__lunoraRef, args, shardKey);
-    if (snapshotKey === void 0 && current === void 0) {
-      return true;
-    }
-    if (snapshotKey === void 0 || current === void 0) {
-      return false;
-    }
-    return stableStringify(current) === snapshotKey;
-  };
-};
-
-export { createSnapshotPrecondition as default };

package/dist/packem_shared/deserializePreloaded-C0eJTY_W.mjs

@@ -1,4 +0,0 @@
-const serializePreloaded = (preloaded) => JSON.stringify(preloaded).replaceAll("<", String.raw`\u003c`);
-const deserializePreloaded = (serialized) => JSON.parse(serialized);
-
-export { deserializePreloaded, serializePreloaded };

package/dist/packem_shared/getServerSession-8jXewqxd.mjs

@@ -1,13 +0,0 @@
-const extractHeaders = (source) => {
-  if (source instanceof Headers) {
-    return source;
-  }
-  return source.headers;
-};
-const getServerSession = async (request, auth) => {
-  const headers = extractHeaders(request);
-  const result = await auth.api.getSession({ headers });
-  return result ?? null;
-};
-
-export { getServerSession };

package/dist/packem_shared/idb-utility-DrSVX43Q.mjs

@@ -1,48 +0,0 @@
-const promisifyRequest = (request) => new Promise((resolve, reject) => {
-  request.addEventListener("success", () => {
-    resolve(request.result);
-  });
-  request.addEventListener("error", () => {
-    reject(request.error ?? new Error("IndexedDB request failed"));
-  });
-});
-const createDatabaseOpener = (factory, databaseName, version, upgrade) => {
-  let databasePromise;
-  return () => {
-    if (databasePromise) {
-      return databasePromise;
-    }
-    databasePromise = new Promise((resolve, reject) => {
-      const request = factory.open(databaseName, version);
-      request.addEventListener("upgradeneeded", () => {
-        upgrade(request.result);
-      });
-      request.addEventListener("success", () => {
-        resolve(request.result);
-      });
-      request.addEventListener("error", () => {
-        reject(request.error ?? new Error("IndexedDB open failed"));
-      });
-    });
-    return databasePromise;
-  };
-};
-const createWithStore = (open, storeName) => async (mode, run) => {
-  const database = await open();
-  const transaction = database.transaction(storeName, mode);
-  const result = await run(transaction.objectStore(storeName));
-  await new Promise((resolve, reject) => {
-    transaction.addEventListener("complete", () => {
-      resolve();
-    });
-    transaction.addEventListener("error", () => {
-      reject(transaction.error ?? new Error("IndexedDB transaction failed"));
-    });
-    transaction.addEventListener("abort", () => {
-      reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
-    });
-  });
-  return result;
-};
-
-export { createDatabaseOpener as a, createWithStore as c, promisifyRequest as p };

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

@@ -1,106 +0,0 @@
-import { SubscriptionRegistry } from './SubscriptionRegistry-D4jfIzZu.mjs';
-
-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) => {
-  const confirms = [];
-  const rollbacks = [];
-  const findState = (functionRef, args) => subscriptions.get(SubscriptionRegistry.key(functionRef, args, shardKey));
-  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, args ?? {});
-      return state?.lastValue;
-    },
-    setQuery: (function_, args, value) => {
-      const state = findState(function_.__lunoraRef, 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 };