@lunora/db 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/createOptimisticOnlineDetector-CRulWqZ7.mjs

@@ -1,65 +0,0 @@
-import { NonRetriableError } from '@tanstack/offline-transactions';
-
-const OUTBOX_DRAIN_INTERVAL_MS = 1e3;
-const toMap = (rows, getKey) => {
-  const map = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    map.set(getKey(row), row);
-  }
-  return map;
-};
-const makeDiffEmit = (synced, writer) => (next) => {
-  writer.begin();
-  for (const [key, value] of next) {
-    const previous = synced.get(key);
-    if (previous === void 0) {
-      writer.write({ type: "insert", value });
-    } else if (JSON.stringify(previous) !== JSON.stringify(value)) {
-      writer.write({ type: "update", value });
-    }
-  }
-  for (const key of synced.keys()) {
-    if (!next.has(key)) {
-      writer.write({ key, type: "delete" });
-    }
-  }
-  writer.commit();
-  synced.clear();
-  for (const [key, value] of next) {
-    synced.set(key, value);
-  }
-};
-const runOutboxMutation = async (mutate) => {
-  try {
-    await mutate();
-  } catch (error) {
-    if (typeof error.code === "string") {
-      throw new NonRetriableError(error instanceof Error ? error.message : String(error));
-    }
-    throw error;
-  }
-};
-const createOptimisticOnlineDetector = () => {
-  const intervals = /* @__PURE__ */ new Set();
-  return {
-    dispose: () => {
-      for (const handle of intervals) {
-        clearInterval(handle);
-      }
-      intervals.clear();
-    },
-    isOnline: () => true,
-    notifyOnline: () => {
-    },
-    subscribe: (callback) => {
-      const handle = setInterval(callback, OUTBOX_DRAIN_INTERVAL_MS);
-      intervals.add(handle);
-      return () => {
-        clearInterval(handle);
-        intervals.delete(handle);
-      };
-    }
-  };
-};
-
-export { createOptimisticOnlineDetector, makeDiffEmit, runOutboxMutation, toMap };

package/dist/packem_shared/defineCollections-BAmslSrF.mjs

@@ -1,109 +0,0 @@
-import { createCollection, BTreeIndex } from '@tanstack/db';
-import { startOfflineExecutor } from '@tanstack/offline-transactions';
-import { toMap, createOptimisticOnlineDetector, makeDiffEmit, runOutboxMutation } from './createOptimisticOnlineDetector-CRulWqZ7.mjs';
-
-const defineCollections = (client, defs) => {
-  const collections = {};
-  const scope = {};
-  const subscriptions = {};
-  const emitters = {};
-  const errorHandlers = {};
-  const mutationFns = {};
-  const entries = Object.entries(defs);
-  for (const [name, definition] of entries) {
-    const getKey = definition.getKey ?? ((row) => row._id);
-    const insert = definition.insert;
-    const synced = /* @__PURE__ */ new Map();
-    collections[name] = createCollection({
-      // Auto-build ordered (B-tree) indexes for whatever the app's live
-      // queries join / filter / sort on, so they stay fast as data grows.
-      autoIndex: "eager",
-      defaultIndexType: BTreeIndex,
-      getKey,
-      id: name,
-      sync: {
-        sync: (writer) => {
-          const emit = makeDiffEmit(synced, writer);
-          emitters[name] = emit;
-          const onError = (error) => {
-            writer.markReady();
-            definition.onError?.(error);
-          };
-          errorHandlers[name] = onError;
-          if (definition.scopeBy === void 0) {
-            subscriptions[name] = client.subscribe(
-              definition.list,
-              {},
-              (rows) => {
-                emit(toMap(rows, getKey));
-                writer.markReady();
-              },
-              { onError }
-            );
-          } else {
-            writer.markReady();
-          }
-          return () => {
-            emitters[name] = void 0;
-            errorHandlers[name] = void 0;
-            subscriptions[name]?.();
-            subscriptions[name] = void 0;
-          };
-        }
-      }
-    });
-    if (definition.scopeBy !== void 0) {
-      scope[name] = (args) => {
-        subscriptions[name]?.();
-        subscriptions[name] = void 0;
-        emitters[name]?.(/* @__PURE__ */ new Map());
-        if (args === void 0) {
-          return;
-        }
-        subscriptions[name] = client.subscribe(
-          definition.list,
-          args,
-          (rows) => {
-            emitters[name]?.(toMap(rows, getKey));
-          },
-          { onError: (error) => errorHandlers[name]?.(error) }
-        );
-      };
-    }
-    if (insert) {
-      mutationFns[name] = async ({ transaction }) => {
-        for (const mutation of transaction.mutations) {
-          const row = mutation.modified;
-          await runOutboxMutation(() => client.mutation(insert.mutation, insert.toArgs(row)));
-        }
-      };
-    }
-  }
-  const executor = startOfflineExecutor({
-    collections,
-    mutationFns,
-    onlineDetector: createOptimisticOnlineDetector()
-  });
-  const actions = {};
-  for (const [name, definition] of entries) {
-    const insert = definition.insert;
-    const collection = collections[name];
-    if (!insert || !collection) {
-      continue;
-    }
-    const action = executor.createOfflineAction({
-      mutationFnName: name,
-      onMutate: ({ id, input }) => {
-        collection.insert(insert.optimistic(input, id));
-      }
-    });
-    actions[name] = (input) => {
-      const id = crypto.randomUUID();
-      const transaction = action({ id, input });
-      return { id, transaction };
-    };
-  }
-  return { actions, collections, executor, scope };
-};
-
-export { defineCollections };