@lunora/react 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/usePresence-D7jLuxj0.mjs

@@ -0,0 +1,108 @@
+'use client';
+import { useMemo, useState, useRef, useEffect, useCallback } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.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 generatedSessionId = useMemo(() => options.sessionId ?? makeSessionId(), [options.sessionId]);
+  const [present, setPresent] = useState(void 0);
+  const dataRef = useRef(options.data);
+  const inputsRef = useRef({
+    client,
+    heartbeat,
+    roomId,
+    sessionId: generatedSessionId,
+    shardKey
+  });
+  useEffect(() => {
+    inputsRef.current = {
+      client,
+      heartbeat,
+      roomId,
+      sessionId: generatedSessionId,
+      shardKey
+    };
+  });
+  const sendHeartbeat = useCallback(() => {
+    const {
+      client: c,
+      heartbeat: hb,
+      roomId: room,
+      sessionId: sid,
+      shardKey: sk
+    } = inputsRef.current;
+    const args = {
+      roomId: room,
+      sessionId: sid,
+      ...dataRef.current === void 0 ? {} : {
+        data: dataRef.current
+      }
+    };
+    c.mutation(hb, args, {
+      shardKey: sk
+    }).catch(() => void 0);
+  }, []);
+  const setData = useCallback((next) => {
+    dataRef.current = next;
+    sendHeartbeat();
+  }, [sendHeartbeat]);
+  useEffect(() => {
+    sendHeartbeat();
+    const handle = setInterval(sendHeartbeat, intervalMs);
+    const onVisible = () => {
+      if (document.visibilityState === "visible") {
+        sendHeartbeat();
+      }
+    };
+    document.addEventListener("visibilitychange", onVisible);
+    return () => {
+      clearInterval(handle);
+      document.removeEventListener("visibilitychange", onVisible);
+    };
+  }, [sendHeartbeat, intervalMs]);
+  useEffect(() => {
+    const release = client.acquireConnectionContext({
+      roomId,
+      sessionId: generatedSessionId
+    }, {
+      shardKey
+    });
+    return release;
+  }, [client, roomId, generatedSessionId, shardKey]);
+  useEffect(() => {
+    let cancelled = false;
+    const unsubscribe = client.subscribe(listPresent, {
+      roomId
+    }, (value) => {
+      if (!cancelled) {
+        setPresent(value);
+      }
+    }, {
+      shardKey
+    });
+    return () => {
+      cancelled = true;
+      unsubscribe();
+    };
+  }, [client, listPresent.__lunoraRef, roomId, shardKey]);
+  return {
+    present,
+    sessionId: generatedSessionId,
+    setData
+  };
+};
+
+export { usePresence };

package/dist/packem_shared/useQuery-EB74gtBJ.mjs

@@ -0,0 +1,42 @@
+'use client';
+import { useQueryClient, useQuery as useQuery$1 } from '@tanstack/react-query';
+import { useMemo, useEffect } from 'react';
+import { g as getSubscriptionRegistry } from './cache-CAp1fVNL.mjs';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { l as lunoraQueryKey, s as serializeQueryKey } from './query-key-B5eRQCbR.mjs';
+import { s as stableStringify } from './stable-key-CaKZv9lp.mjs';
+
+const useQuery = (function_, args, options = {}) => {
+  const client = useLunora();
+  const queryClient = useQueryClient();
+  const {
+    shardKey
+  } = options;
+  const skipped = args === "skip";
+  const argsRecord = skipped ? {} : args;
+  const queryKey = useMemo(() => lunoraQueryKey(function_, argsRecord, shardKey), [function_.__lunoraRef, stableStringify(argsRecord), shardKey]);
+  const {
+    data
+  } = useQuery$1({
+    enabled: !skipped,
+    queryFn: () => client.query(function_, argsRecord, {
+      shardKey
+    }),
+    queryKey,
+    // Lunora is push-driven: once the initial fetch resolves, the WS owns
+    // freshness. Staleness only matters when the subscription is missing,
+    // and the registry handles that with a polling fallback.
+    staleTime: Number.POSITIVE_INFINITY
+  });
+  useEffect(() => {
+    if (skipped) {
+      return () => {
+      };
+    }
+    const registry = getSubscriptionRegistry(client);
+    return registry.attach(queryClient, queryKey, function_, argsRecord, shardKey);
+  }, [client, queryClient, serializeQueryKey(queryKey), skipped]);
+  return data;
+};
+
+export { useQuery as default };

package/dist/packem_shared/useRateLimit-DTEffQEi.mjs

@@ -0,0 +1,64 @@
+'use client';
+import { evaluate } from '@lunora/ratelimit';
+import { useRef, useReducer, useCallback, useEffect } from 'react';
+
+const useRateLimit = (config, options = {}) => {
+  const now = options.now ?? Date.now;
+  const tickMs = options.tickMs ?? 1e3;
+  const valueRef = useRef(void 0);
+  const [, forceRender] = useReducer((count) => count + 1, 0);
+  const consume = useCallback((count_0 = 1) => {
+    const {
+      status,
+      value
+    } = evaluate(config, valueRef.current, {
+      consume: true,
+      count: count_0,
+      now: now(),
+      reserve: false
+    });
+    if (value !== void 0) {
+      valueRef.current = value;
+    }
+    forceRender();
+    return status;
+  }, [config, now]);
+  const check = useCallback((count_1 = 1) => evaluate(config, valueRef.current, {
+    consume: false,
+    count: count_1,
+    now: now(),
+    reserve: false
+  }).status.ok, [config, now]);
+  const reset = useCallback(() => {
+    valueRef.current = void 0;
+    forceRender();
+  }, []);
+  const {
+    status: status_0
+  } = evaluate(config, valueRef.current, {
+    consume: false,
+    count: 1,
+    now: now(),
+    reserve: false
+  });
+  useEffect(() => {
+    if (status_0.ok) {
+      return () => {
+      };
+    }
+    const handle = setInterval(forceRender, tickMs);
+    return () => {
+      clearInterval(handle);
+    };
+  }, [status_0.ok, tickMs]);
+  return {
+    check,
+    consume,
+    disabled: !status_0.ok,
+    ok: status_0.ok,
+    reset,
+    retryAfter: status_0.retryAfter
+  };
+};
+
+export { useRateLimit };

package/dist/packem_shared/useStream-MdYnWDL_.mjs

@@ -0,0 +1,125 @@
+'use client';
+import { useReducer, useRef, useEffect } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { s as stableStringify } from './stable-key-CaKZv9lp.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-DSJuryrU.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 { s as stableStringify } from './stable-key-CaKZv9lp.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-B5eRQCbR.mjs';
+export { lunoraQueryOptions } from './packem_shared/lunoraQueryOptions-Cij4KWBK.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 };