@lunora/client 0.0.0 → 1.0.0-alpha.2

package/dist/index.mjs

@@ -0,0 +1,14 @@
+export { createAsyncStoragePersistence } from './packem_shared/createAsyncStoragePersistence-1Z5BZ8RC.mjs';
+export { default as createInMemoryBookmarkStorage } from './packem_shared/createInMemoryBookmarkStorage-BoN7a7TH.mjs';
+export { applyDelta, isMutationDelta } from './packem_shared/applyDelta-4jFGTPA3.mjs';
+export { CONFLICT_ERROR_CODE, isConflictError } from './packem_shared/CONFLICT_ERROR_CODE-aUdVbEDw.mjs';
+export { createLocalStore } from './packem_shared/createLocalStore-DSUfoLqY.mjs';
+export { LunoraClient } from './packem_shared/LunoraClient-UiULzH_1.mjs';
+export { createMutationRunner } from './packem_shared/createMutationRunner-BqsavzvG.mjs';
+export { OfflineQueue } from './packem_shared/OfflineQueue-D5p_QgF_.mjs';
+export { createInMemoryPersistence, createIndexedDbPersistence } from './packem_shared/createInMemoryPersistence-CW82inU5.mjs';
+export { preloadQuery, preloadedQueryResult } from './packem_shared/preloadQuery-lobFkD2Z.mjs';
+export { createInMemoryQueryCache, createIndexedDbQueryCache, queryCacheKey } from './packem_shared/createInMemoryQueryCache-B1PQ9Twl.mjs';
+export { createReconnect } from './packem_shared/createReconnect-Di_-oHH7.mjs';
+export { DEFAULT_MAX_BUFFER, createStream } from './packem_shared/DEFAULT_MAX_BUFFER-BDkqO5PW.mjs';
+export { SubscriptionRegistry } from './packem_shared/SubscriptionRegistry-B-Qx_Gux.mjs';

package/dist/packem_shared/CONFLICT_ERROR_CODE-aUdVbEDw.mjs

@@ -0,0 +1,4 @@
+const CONFLICT_ERROR_CODE = "CONFLICT";
+const isConflictError = (error) => error instanceof Error && error.code === CONFLICT_ERROR_CODE;
+
+export { CONFLICT_ERROR_CODE, isConflictError };

package/dist/packem_shared/DEFAULT_MAX_BUFFER-BDkqO5PW.mjs

@@ -0,0 +1,107 @@
+const DEFAULT_MAX_BUFFER = 1024;
+const createStream = (options) => {
+  const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
+  const buffer = [];
+  const pending = [];
+  let done = false;
+  let failure;
+  let cancelled = false;
+  const flushOne = () => {
+    const waiter = pending.shift();
+    if (!waiter) {
+      return false;
+    }
+    if (failure) {
+      waiter.reject(failure);
+      return true;
+    }
+    if (buffer.length > 0) {
+      const value = buffer.shift();
+      waiter.resolve({ done: false, value });
+      return true;
+    }
+    if (done) {
+      waiter.resolve({ done: true, value: void 0 });
+      return true;
+    }
+    pending.unshift(waiter);
+    return false;
+  };
+  const handle = {
+    complete() {
+      if (done || failure) {
+        return;
+      }
+      done = true;
+      while (flushOne()) {
+      }
+    },
+    fail(error) {
+      if (done || failure) {
+        return;
+      }
+      failure = error;
+      buffer.length = 0;
+      while (flushOne()) {
+      }
+    },
+    push(value) {
+      if (done || failure || cancelled) {
+        return;
+      }
+      if (buffer.length >= maxBuffer) {
+        handle.fail(
+          Object.assign(new Error(`stream buffer overflow (max=${maxBuffer.toString()}); the consumer cannot keep up with the producer`), {
+            code: "STREAM_BACKPRESSURE"
+          })
+        );
+        return;
+      }
+      buffer.push(value);
+      flushOne();
+    }
+  };
+  const cancel = () => {
+    if (cancelled) {
+      return;
+    }
+    cancelled = true;
+    done = true;
+    buffer.length = 0;
+    try {
+      options.onCancel();
+    } catch {
+    }
+    while (flushOne()) {
+    }
+  };
+  const iterable = {
+    cancel,
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (failure) {
+            return Promise.reject(failure);
+          }
+          if (buffer.length > 0) {
+            const value = buffer.shift();
+            return Promise.resolve({ done: false, value });
+          }
+          if (done) {
+            return Promise.resolve({ done: true, value: void 0 });
+          }
+          return new Promise((resolve, reject) => {
+            pending.push({ reject, resolve });
+          });
+        },
+        return() {
+          cancel();
+          return Promise.resolve({ done: true, value: void 0 });
+        }
+      };
+    }
+  };
+  return { handle, iterable };
+};
+
+export { DEFAULT_MAX_BUFFER, createStream };