@lunora/react 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/useStream-BRY9nemd.mjs

@@ -0,0 +1,125 @@
+'use client';
+import { useReducer, useRef, useEffect } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { a as stableStringify } from './query-key-C5rufkEE.mjs';
+
+const reducer = function(state, action) {
+  switch (action.type) {
+    case "chunk": {
+      return {
+        chunks: [...state.chunks, action.chunk],
+        error: void 0,
+        status: "streaming"
+      };
+    }
+    case "complete": {
+      return {
+        ...state,
+        status: "complete"
+      };
+    }
+    case "error": {
+      return {
+        ...state,
+        error: action.error,
+        status: "error"
+      };
+    }
+    case "reset": {
+      return {
+        chunks: [],
+        error: void 0,
+        status: "idle"
+      };
+    }
+    case "start": {
+      return {
+        ...state,
+        status: "streaming"
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const useStream = (function_, args, options = {}) => {
+  const client = useLunora();
+  const [state, dispatch] = useReducer(reducer, {
+    chunks: [],
+    error: void 0,
+    status: "idle"
+  });
+  const skipped = args === "skip";
+  const serialized = skipped ? "skip" : stableStringify(args);
+  const cancelRef = useRef(void 0);
+  useEffect(() => {
+    if (skipped) {
+      return () => {
+      };
+    }
+    dispatch({
+      type: "reset"
+    });
+    dispatch({
+      type: "start"
+    });
+    let stillMounted = true;
+    let cancelled = false;
+    const iterable = client.stream(function_, args, {
+      maxBuffer: options.maxBuffer,
+      shardKey: options.shardKey
+    });
+    const cancel = () => {
+      if (cancelled) {
+        return;
+      }
+      cancelled = true;
+      iterable.cancel();
+    };
+    cancelRef.current = cancel;
+    (async () => {
+      try {
+        for await (const chunk of iterable) {
+          if (!stillMounted) {
+            return;
+          }
+          dispatch({
+            chunk,
+            type: "chunk"
+          });
+        }
+        if (stillMounted) {
+          dispatch({
+            type: "complete"
+          });
+        }
+      } catch (error) {
+        if (!stillMounted) {
+          return;
+        }
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        dispatch({
+          error: normalized,
+          type: "error"
+        });
+      }
+    })().catch(() => {
+    });
+    return () => {
+      stillMounted = false;
+      cancel();
+      cancelRef.current = void 0;
+    };
+  }, [client, function_.__lunoraRef, serialized, skipped, options.shardKey, options.maxBuffer]);
+  return {
+    cancel: () => {
+      cancelRef.current?.();
+    },
+    chunks: state.chunks,
+    error: state.error,
+    status: state.status
+  };
+};
+
+export { useStream };

package/dist/packem_shared/useSubscription-CHMCjyQg.mjs

@@ -0,0 +1,139 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { createQuerySubscription } from '@lunora/client/query';
+import { useState, useRef, useEffect } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { a as stableStringify } from './query-key-C5rufkEE.mjs';
+
+const useSubscription = (function_, args, t0) => {
+  const $ = c(22);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  const client = useLunora();
+  let t2;
+  if ($[2] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t2 = {
+      data: void 0,
+      error: void 0
+    };
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const [state, setState] = useState(t2);
+  const skipped = args === "skip";
+  let t3;
+  if ($[3] !== args || $[4] !== skipped) {
+    t3 = skipped ? "skip" : stableStringify(args);
+    $[3] = args;
+    $[4] = skipped;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const serialized = t3;
+  let t4;
+  if ($[6] !== args || $[7] !== function_) {
+    t4 = {
+      args,
+      fn: function_
+    };
+    $[6] = args;
+    $[7] = function_;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  const subscribeRef = useRef(t4);
+  let t5;
+  if ($[9] !== args || $[10] !== function_) {
+    t5 = () => {
+      subscribeRef.current = {
+        args,
+        fn: function_
+      };
+    };
+    $[9] = args;
+    $[10] = function_;
+    $[11] = t5;
+  } else {
+    t5 = $[11];
+  }
+  useEffect(t5);
+  let t6;
+  if ($[12] !== client || $[13] !== options.shardKey || $[14] !== skipped) {
+    t6 = () => {
+      if (skipped) {
+        setState({
+          data: void 0,
+          error: void 0
+        });
+        return _temp;
+      }
+      let cancelled = false;
+      const {
+        args: currentArgs,
+        fn: currentFunction
+      } = subscribeRef.current;
+      const unsubscribe = createQuerySubscription(client, currentFunction, currentArgs, {
+        onData: (value) => {
+          if (cancelled) {
+            return;
+          }
+          setState({
+            data: value,
+            error: void 0
+          });
+        },
+        onError: (error) => {
+          const normalized = new Error(error.message);
+          queueMicrotask(() => {
+            if (!cancelled) {
+              setState({
+                data: void 0,
+                error: normalized
+              });
+            }
+          });
+        }
+      }, {
+        shardKey: options.shardKey
+      });
+      return () => {
+        cancelled = true;
+        unsubscribe();
+      };
+    };
+    $[12] = client;
+    $[13] = options.shardKey;
+    $[14] = skipped;
+    $[15] = t6;
+  } else {
+    t6 = $[15];
+  }
+  let t7;
+  if ($[16] !== client || $[17] !== function_.__lunoraRef || $[18] !== options.shardKey || $[19] !== serialized || $[20] !== skipped) {
+    t7 = [client, function_.__lunoraRef, serialized, options.shardKey, skipped];
+    $[16] = client;
+    $[17] = function_.__lunoraRef;
+    $[18] = options.shardKey;
+    $[19] = serialized;
+    $[20] = skipped;
+    $[21] = t7;
+  } else {
+    t7 = $[21];
+  }
+  useEffect(t6, t7);
+  return state;
+};
+function _temp() {
+}
+
+export { useSubscription as default };

package/dist/server.d.mts

@@ -0,0 +1,51 @@
+import { FunctionReference, ArgsOf, ReturnOf, LunoraClient } from '@lunora/client';
+export { type ArgsOf, type FunctionReference, type Preloaded, type ReturnOf, preloadQuery, preloadedQueryResult } from '@lunora/client';
+import { ServerClientOptions } from '@lunora/client/ssr';
+export { type AuthLike, type HeadersSource, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, serializePreloaded } from '@lunora/client/ssr';
+import { QueryClient } from '@tanstack/react-query';
+export { HydrationBoundary, dehydrate } from '@tanstack/react-query';
+export { type L as LunoraQueryOptions, l as lunoraQueryOptions } from "./packem_shared/query-options.d-D4okOpO8.mjs";
+/**
+* Run a query on the server and seed `queryClient` with the result under the
+* same key the client hooks use (see `lunoraQueryKey`), so a later
+* `useQuery(fn, args)` reads it straight from the hydrated cache — no loading
+* flash, no duplicate fetch on the client.
+*
+* Pair it with TanStack's `dehydrate` + `HydrationBoundary` (both re-exported
+* from this module): prefetch into a fresh `QueryClient`, `dehydrate` it, wrap
+* the client subtree in `HydrationBoundary`, and the client hooks pick the value
+* up from cache. Errors propagate — wrap the call if you'd rather render a
+* fallback than fail the server render. Drop the `await` for fire-and-forget
+* prefetch when you don't need the data present on the very first paint.
+*/
+declare const prefetchQuery: <F extends FunctionReference>(queryClient: QueryClient, client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => Promise<void>;
+/** Per-call options shared by the one-shot `fetch*` helpers. */
+interface ServerCallOptions {
+  /** Route to a specific shard when the target function is `.shardBy(...)`-partitioned. */
+  shardKey?: string;
+}
+/**
+* Run a query once on the server and return its result — the standalone
+* counterpart to `prefetchQuery`/`preloadQuery` for when you just want the data
+* inline in a Server Component (e.g. to compute metadata or branch on a value)
+* rather than seed a cache or hand a `Preloaded` to the client.
+*
+* Builds a fresh request-scoped client per call (see `createServerClient`), so
+* pass `token` to run as the signed-in user. For several reads in one request,
+* prefer holding one `createServerClient` and calling `.query()` yourself to
+* avoid rebuilding the transport each time. Errors propagate.
+*/
+declare const fetchQuery: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
+/**
+* Run a mutation once on the server and return its result. Server-side calls go
+* straight over HTTP RPC — the offline queue and optimistic-update machinery are
+* client-only and never engage here. Errors propagate.
+*/
+declare const fetchMutation: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
+/**
+* Run an action once on the server and return its result. Errors propagate.
+*/
+declare const fetchAction: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
+export { ServerCallOptions, fetchAction, fetchMutation, fetchQuery, prefetchQuery };

package/dist/server.d.ts

@@ -0,0 +1,51 @@
+import { FunctionReference, ArgsOf, ReturnOf, LunoraClient } from '@lunora/client';
+export { type ArgsOf, type FunctionReference, type Preloaded, type ReturnOf, preloadQuery, preloadedQueryResult } from '@lunora/client';
+import { ServerClientOptions } from '@lunora/client/ssr';
+export { type AuthLike, type HeadersSource, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, serializePreloaded } from '@lunora/client/ssr';
+import { QueryClient } from '@tanstack/react-query';
+export { HydrationBoundary, dehydrate } from '@tanstack/react-query';
+export { type L as LunoraQueryOptions, l as lunoraQueryOptions } from "./packem_shared/query-options.d-D4okOpO8.js";
+/**
+* Run a query on the server and seed `queryClient` with the result under the
+* same key the client hooks use (see `lunoraQueryKey`), so a later
+* `useQuery(fn, args)` reads it straight from the hydrated cache — no loading
+* flash, no duplicate fetch on the client.
+*
+* Pair it with TanStack's `dehydrate` + `HydrationBoundary` (both re-exported
+* from this module): prefetch into a fresh `QueryClient`, `dehydrate` it, wrap
+* the client subtree in `HydrationBoundary`, and the client hooks pick the value
+* up from cache. Errors propagate — wrap the call if you'd rather render a
+* fallback than fail the server render. Drop the `await` for fire-and-forget
+* prefetch when you don't need the data present on the very first paint.
+*/
+declare const prefetchQuery: <F extends FunctionReference>(queryClient: QueryClient, client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => Promise<void>;
+/** Per-call options shared by the one-shot `fetch*` helpers. */
+interface ServerCallOptions {
+  /** Route to a specific shard when the target function is `.shardBy(...)`-partitioned. */
+  shardKey?: string;
+}
+/**
+* Run a query once on the server and return its result — the standalone
+* counterpart to `prefetchQuery`/`preloadQuery` for when you just want the data
+* inline in a Server Component (e.g. to compute metadata or branch on a value)
+* rather than seed a cache or hand a `Preloaded` to the client.
+*
+* Builds a fresh request-scoped client per call (see `createServerClient`), so
+* pass `token` to run as the signed-in user. For several reads in one request,
+* prefer holding one `createServerClient` and calling `.query()` yourself to
+* avoid rebuilding the transport each time. Errors propagate.
+*/
+declare const fetchQuery: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
+/**
+* Run a mutation once on the server and return its result. Server-side calls go
+* straight over HTTP RPC — the offline queue and optimistic-update machinery are
+* client-only and never engage here. Errors propagate.
+*/
+declare const fetchMutation: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
+/**
+* Run an action once on the server and return its result. Errors propagate.
+*/
+declare const fetchAction: <F extends FunctionReference>(options: ServerClientOptions, function_: F, args: ArgsOf<F>, callOptions?: ServerCallOptions) => Promise<ReturnOf<F>>;
+export { ServerCallOptions, fetchAction, fetchMutation, fetchQuery, prefetchQuery };

package/dist/server.mjs

@@ -0,0 +1,31 @@
+import { createServerClient } from '@lunora/client/ssr';
+export { createServerClient, deserializePreloaded, getServerSession, serializePreloaded } from '@lunora/client/ssr';
+import { l as lunoraQueryKey } from './packem_shared/query-key-C5rufkEE.mjs';
+export { lunoraQueryOptions } from './packem_shared/lunoraQueryOptions-CsuWzjg1.mjs';
+export { preloadQuery, preloadedQueryResult } from '@lunora/client';
+export { HydrationBoundary, dehydrate } from '@tanstack/react-query';
+
+const prefetchQuery = async (queryClient, client, function_, args, options = {}) => {
+  const argsRecord = args ?? {};
+  await queryClient.prefetchQuery({
+    queryFn: () => client.query(function_, argsRecord, {
+      shardKey: options.shardKey
+    }),
+    queryKey: lunoraQueryKey(function_, argsRecord, options.shardKey),
+    // Match the client hooks: Lunora is push-driven, so the seeded value is
+    // never considered stale by TanStack — the WS subscription that attaches
+    // on mount is the only freshness signal.
+    staleTime: Number.POSITIVE_INFINITY
+  });
+};
+const fetchQuery = async (options, function_, args, callOptions = {}) => createServerClient(options).query(function_, args, {
+  shardKey: callOptions.shardKey
+});
+const fetchMutation = async (options, function_, args, callOptions = {}) => createServerClient(options).mutation(function_, args, {
+  shardKey: callOptions.shardKey
+});
+const fetchAction = async (options, function_, args, callOptions = {}) => createServerClient(options).action(function_, args, {
+  shardKey: callOptions.shardKey
+});
+
+export { fetchAction, fetchMutation, fetchQuery, prefetchQuery };

package/package.json

@@ -1,31 +1,74 @@
 {
   "name": "@lunora/react",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "React hooks for Lunora: useQuery, useMutation, useSubscription, and useAuth",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "durable-objects",
+    "hooks",
+    "lunora",
+    "react",
+    "realtime",
+    "usequery",
+    "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/react"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "react",
-    "hooks",
-    "usequery",
-    "realtime"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "__assets__"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "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"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/client": "1.0.0-alpha.1",
+    "@lunora/ratelimit": "1.0.0-alpha.1"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.101.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": false
+    },
+    "react": {
+      "optional": false
+    },
+    "react-dom": {
+      "optional": false
+    }
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }