@lunora/vue 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/useInfiniteQuery-CEfbw7Nw.mjs

@@ -0,0 +1,199 @@
+import { shallowRef, watch, toValue, onScopeDispose, computed } from 'vue';
+import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
+import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
+const buildPageArgs = (page, baseArgs) => {
+  return {
+    ...baseArgs,
+    paginationOpts: { cursor: page.lower, endCursor: page.upper, numItems: page.numItems }
+  };
+};
+const usePaginatedCore = (function_, args, options) => {
+  const client = useLunora();
+  const { initialNumItems, shardKey } = options;
+  const pages = shallowRef(initialPages(initialNumItems));
+  const pageResults = shallowRef([]);
+  const activeSubs = /* @__PURE__ */ new Map();
+  const resultsByKey = /* @__PURE__ */ new Map();
+  const pendingPageKeys = /* @__PURE__ */ new Set();
+  const rebuildPageResults = (currentPages, baseArgs) => {
+    pageResults.value = currentPages.map((page) => {
+      const key = buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs));
+      return resultsByKey.get(key);
+    });
+  };
+  const migrateResultsForRebalance = (oldPages, newPages, baseArgs) => {
+    const keyOf = (page) => buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs));
+    for (const newPage of newPages) {
+      const newKey = keyOf(newPage);
+      if (resultsByKey.has(newKey)) {
+        continue;
+      }
+      const donor = oldPages.find((op) => op.lower === newPage.lower);
+      if (donor) {
+        const carried = resultsByKey.get(keyOf(donor));
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+        }
+      }
+    }
+  };
+  const syncSubscriptions = (currentPages, baseArgs) => {
+    const wantedKeys = /* @__PURE__ */ new Set();
+    for (const page of currentPages) {
+      wantedKeys.add(buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs)));
+    }
+    for (const [originalKey, entry] of activeSubs) {
+      if (!wantedKeys.has(entry.currentKey)) {
+        entry.unsub();
+        activeSubs.delete(originalKey);
+        resultsByKey.delete(entry.currentKey);
+      }
+    }
+    const coveredKeys = new Set([...activeSubs.values()].map((subEntry) => subEntry.currentKey));
+    for (const page of currentPages) {
+      const pageArgs = buildPageArgs(page, baseArgs);
+      const key = buildPageKey(function_["__lunoraRef"], pageArgs);
+      if (coveredKeys.has(key)) {
+        continue;
+      }
+      const entry = {
+        currentKey: key,
+        unsub: void 0
+      };
+      pendingPageKeys.add(key);
+      const unsub = client.subscribe(
+        function_,
+        pageArgs,
+        (value) => {
+          resultsByKey.set(entry.currentKey, value);
+          pendingPageKeys.delete(entry.currentKey);
+          const currentBaseArgs = toValue(args);
+          rebuildPageResults(pages.value, currentBaseArgs);
+          if (pendingPageKeys.size === 0) {
+            const latestPages = pages.value;
+            const next = rebalance(latestPages, pageResults.value);
+            if (next) {
+              migrateResultsForRebalance(latestPages, next, currentBaseArgs);
+              pages.value = next;
+            }
+          }
+        },
+        { shardKey }
+      );
+      entry.unsub = unsub;
+      activeSubs.set(key, entry);
+      coveredKeys.add(key);
+    }
+  };
+  const teardownAll = () => {
+    for (const entry of activeSubs.values()) {
+      entry.unsub();
+    }
+    activeSubs.clear();
+    resultsByKey.clear();
+  };
+  watch(
+    () => toValue(args),
+    (current) => {
+      teardownAll();
+      pages.value = initialPages(initialNumItems);
+      pageResults.value = [];
+      if (current !== "skip") {
+        syncSubscriptions(pages.value, current);
+        rebuildPageResults(pages.value, current);
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => pages.value,
+    (currentPages) => {
+      const current = toValue(args);
+      if (current !== "skip") {
+        syncSubscriptions(currentPages, current);
+        rebuildPageResults(currentPages, current);
+      }
+    }
+  );
+  onScopeDispose(teardownAll);
+  const status = shallowRef("LoadingFirstPage");
+  watch(
+    [() => toValue(args), pageResults],
+    ([currentArgs, currentResults]) => {
+      status.value = derivePaginationStatus(currentArgs === "skip", currentResults).status;
+    },
+    { immediate: true }
+  );
+  const loadMore = (numberItems) => {
+    const currentArgs = toValue(args);
+    if (currentArgs === "skip") {
+      return;
+    }
+    const { nextCursor, status: currentStatus } = derivePaginationStatus(false, pageResults.value);
+    if (currentStatus !== "CanLoadMore") {
+      return;
+    }
+    const next = applyLoadMore(pages.value, nextCursor, numberItems);
+    if (!next) {
+      return;
+    }
+    const oldTail = pages.value.at(-1);
+    const newPinnedPage = next.at(-2);
+    if (oldTail && newPinnedPage) {
+      const oldKey = buildPageKey(function_["__lunoraRef"], buildPageArgs(oldTail, currentArgs));
+      const newKey = buildPageKey(function_["__lunoraRef"], buildPageArgs(newPinnedPage, currentArgs));
+      const entry = activeSubs.get(oldKey);
+      if (entry && oldKey !== newKey) {
+        entry.currentKey = newKey;
+        activeSubs.set(newKey, entry);
+        activeSubs.delete(oldKey);
+        const carried = resultsByKey.get(oldKey);
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+          resultsByKey.delete(oldKey);
+        }
+      }
+    }
+    pages.value = next;
+  };
+  return { loadMore, pageResults, status };
+};
+
+const usePaginatedQuery = (function_, args, options) => {
+  const { loadMore, pageResults, status } = usePaginatedCore(function_, args, options);
+  const results = computed(() => {
+    const items = [];
+    for (const result of pageResults.value) {
+      if (result) {
+        items.push(...result.page);
+      }
+    }
+    return items;
+  });
+  const isLoading = computed(() => status.value === "LoadingFirstPage" || status.value === "LoadingMore");
+  return { isLoading, loadMore, results, status };
+};
+const useInfiniteQuery = (function_, args, options) => {
+  const { initialNumItems } = options;
+  const { loadMore, pageResults, status } = usePaginatedCore(function_, args, options);
+  const pages = computed(() => {
+    const result = [];
+    for (const page of pageResults.value) {
+      if (page) {
+        result.push(page.page);
+      }
+    }
+    return result;
+  });
+  const isLoading = computed(() => status.value === "LoadingFirstPage");
+  const hasNextPage = computed(() => status.value === "CanLoadMore");
+  const isFetchingNextPage = computed(() => status.value === "LoadingMore");
+  const fetchNextPage = (numberItems) => {
+    loadMore(numberItems ?? initialNumItems);
+  };
+  return { fetchNextPage, hasNextPage, isFetchingNextPage, isLoading, pages, status };
+};
+
+export { useInfiniteQuery, usePaginatedQuery };

package/dist/packem_shared/useMutation-DWubV5pv.mjs

@@ -0,0 +1,29 @@
+import { createMutationRunner } from '@lunora/client';
+import { shallowRef, ref } from 'vue';
+import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+
+const useMutation = (function_) => {
+  const client = useLunora();
+  const data = shallowRef(void 0);
+  const error = shallowRef(void 0);
+  const pending = ref(false);
+  const reset = () => {
+    data.value = void 0;
+    error.value = void 0;
+  };
+  const mutate = createMutationRunner(client, function_, {
+    setError: (next) => {
+      error.value = next;
+    },
+    setPending: (next) => {
+      pending.value = next;
+    },
+    setResult: (result) => {
+      data.value = result;
+      error.value = void 0;
+    }
+  });
+  return { data, error, mutate, pending, reset };
+};
+
+export { useMutation };

package/dist/packem_shared/usePresence-BeN5xaZM.mjs

@@ -0,0 +1,59 @@
+import { shallowRef, onScopeDispose } from 'vue';
+import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+
+const makeSessionId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `sess-${Math.random().toString(36).slice(2)}-${String(Date.now())}`;
+};
+const DEFAULT_INTERVAL_MS = 1e4;
+const usePresence = (roomId, options) => {
+  const client = useLunora();
+  const { heartbeat, intervalMs = DEFAULT_INTERVAL_MS, listPresent, shardKey } = options;
+  const sessionId = options.sessionId ?? makeSessionId();
+  const present = shallowRef(void 0);
+  let latestData = options.data;
+  const sendHeartbeat = () => {
+    const args = {
+      roomId,
+      sessionId,
+      ...latestData === void 0 ? {} : { data: latestData }
+    };
+    client.mutation(heartbeat, args, { shardKey }).catch(() => void 0);
+  };
+  const setData = (next) => {
+    latestData = next;
+    sendHeartbeat();
+  };
+  sendHeartbeat();
+  const intervalHandle = setInterval(sendHeartbeat, intervalMs);
+  const onVisible = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "visible") {
+      sendHeartbeat();
+    }
+  };
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", onVisible);
+  }
+  const releaseConnectionContext = client.acquireConnectionContext({ roomId, sessionId }, { shardKey });
+  const unsubscribe = client.subscribe(
+    listPresent,
+    { roomId },
+    (value) => {
+      present.value = value;
+    },
+    { shardKey }
+  );
+  onScopeDispose(() => {
+    clearInterval(intervalHandle);
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", onVisible);
+    }
+    releaseConnectionContext();
+    unsubscribe();
+  });
+  return { present, sessionId, setData };
+};
+
+export { usePresence };

package/dist/packem_shared/useRateLimit-DlPWjcX1.mjs

@@ -0,0 +1,67 @@
+import { evaluate } from '@lunora/ratelimit';
+import { shallowRef, toValue, watchEffect, onScopeDispose, computed } from 'vue';
+
+const useRateLimit = (config, options = {}) => {
+  const now = options.now ?? Date.now;
+  const tickMs = options.tickMs ?? 1e3;
+  let value;
+  const epoch = shallowRef(0);
+  const bump = () => {
+    epoch.value += 1;
+  };
+  const status = shallowRef(evaluate(toValue(config), value, { consume: false, count: 1, now: now(), reserve: false }).status);
+  const stopStatusEffect = watchEffect(
+    () => {
+      status.value = evaluate(toValue(config), value, { consume: false, count: 1, now: now(), reserve: false }).status;
+    },
+    { flush: "sync" }
+  );
+  let intervalHandle;
+  const stopInterval = () => {
+    if (intervalHandle !== void 0) {
+      clearInterval(intervalHandle);
+      intervalHandle = void 0;
+    }
+  };
+  const startIntervalIfThrottled = () => {
+    if (status.value.ok || intervalHandle !== void 0) {
+      return;
+    }
+    intervalHandle = setInterval(() => {
+      bump();
+      if (status.value.ok) {
+        stopInterval();
+      }
+    }, tickMs);
+  };
+  onScopeDispose(() => {
+    stopInterval();
+    stopStatusEffect();
+  });
+  startIntervalIfThrottled();
+  const consume = (count = 1) => {
+    const result = evaluate(toValue(config), value, { consume: true, count, now: now(), reserve: false });
+    if (result.value !== void 0) {
+      value = result.value;
+    }
+    bump();
+    startIntervalIfThrottled();
+    return result.status;
+  };
+  const check = (count = 1) => evaluate(toValue(config), value, { consume: false, count, now: now(), reserve: false }).status.ok;
+  const reset = () => {
+    value = void 0;
+    stopInterval();
+    bump();
+  };
+  return {
+    check,
+    consume,
+    disabled: computed(() => !status.value.ok),
+    ok: computed(() => status.value.ok),
+    reset,
+    retryAfter: computed(() => status.value.retryAfter)
+  };
+};
+
+export { useRateLimit };

package/dist/packem_shared/useSubscription-Ol0AZFUv.mjs

@@ -0,0 +1,47 @@
+import { createQuerySubscription } from '@lunora/client/query';
+import { ref, watch, toValue, onScopeDispose } from 'vue';
+import { useLunora } from './LUNORA_INJECTION_KEY-DtFXLDQ_.mjs';
+
+const useSubscription = (function_, args, options = {}) => {
+  const client = useLunora();
+  const data = ref(void 0);
+  const error = ref(void 0);
+  watch(
+    () => toValue(args),
+    (currentArgs, _previous, onCleanup) => {
+      if (currentArgs === "skip") {
+        data.value = void 0;
+        error.value = void 0;
+        return;
+      }
+      const unsubscribe = createQuerySubscription(
+        client,
+        function_,
+        currentArgs,
+        {
+          onData: (value) => {
+            data.value = value;
+            error.value = void 0;
+          },
+          onError: (subscriptionError) => {
+            error.value = new Error(subscriptionError.message);
+            data.value = void 0;
+          },
+          onReset: () => {
+            data.value = void 0;
+          }
+        },
+        { shardKey: options.shardKey }
+      );
+      onCleanup(unsubscribe);
+    },
+    { immediate: true }
+  );
+  onScopeDispose(() => {
+    data.value = void 0;
+    error.value = void 0;
+  });
+  return { data, error };
+};
+
+export { useSubscription };

package/dist/server.d.mts

@@ -0,0 +1 @@
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.d.ts

@@ -0,0 +1 @@
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.mjs

@@ -0,0 +1 @@
+export { createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/worker.d.mts

@@ -0,0 +1 @@
+export { type LunoraWorker as ComposedWorker, type ExecutionContextLike, type FrameworkWorkerOptionsInput, type FrameworkHostHandler as NitroCloudflareHandler, type ScheduledControllerLike, type FrameworkWorkerOptions as WithLunoraOptions, withFrameworkWorker as withLunora } from '@lunora/runtime';

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export { type LunoraWorker as ComposedWorker, type ExecutionContextLike, type FrameworkWorkerOptionsInput, type FrameworkHostHandler as NitroCloudflareHandler, type ScheduledControllerLike, type FrameworkWorkerOptions as WithLunoraOptions, withFrameworkWorker as withLunora } from '@lunora/runtime';

package/dist/worker.mjs

@@ -0,0 +1 @@
+export { withFrameworkWorker as withLunora } from '@lunora/runtime';

package/package.json

@@ -1,31 +1,72 @@
 {
   "name": "@lunora/vue",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.2",
   "description": "Vue adapter for Lunora — live composables, optimistic mutations, and reactive loaders",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "composables",
+    "durable-objects",
+    "lunora",
+    "optimistic-updates",
+    "realtime",
+    "vue",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/vue"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "vue",
-    "composables",
-    "realtime",
-    "optimistic-updates"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "__assets__"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.mjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/client": "1.0.0-alpha.1",
+    "@lunora/ratelimit": "1.0.0-alpha.2",
+    "@lunora/runtime": "1.0.0-alpha.1"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": false
+    }
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }