@lunora/react 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/CheckoutButton-CVSry8U1.mjs

@@ -0,0 +1,185 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useState, useCallback } from 'react';
+import { jsxDEV } from 'react/jsx-dev-runtime';
+
+const useCheckout = (trigger) => {
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState(void 0);
+  const checkout = useCallback(async () => {
+    setPending(true);
+    setError(void 0);
+    try {
+      const target = await trigger();
+      const {
+        url
+      } = target;
+      globalThis.location.assign(url);
+    } catch (error_) {
+      const normalized = error_ instanceof Error ? error_ : new Error(String(error_));
+      setError(normalized);
+      throw normalized;
+    } finally {
+      setPending(false);
+    }
+  }, [trigger]);
+  return {
+    checkout,
+    error,
+    pending
+  };
+};
+const RedirectButton = (t0) => {
+  const $ = c(11);
+  const {
+    "aria-label": ariaLabel,
+    children,
+    className,
+    disabled,
+    onError,
+    title,
+    trigger
+  } = t0;
+  const {
+    checkout,
+    pending
+  } = useCheckout(trigger);
+  let t1;
+  if ($[0] !== checkout || $[1] !== onError) {
+    t1 = () => {
+      checkout().catch((error) => {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        onError?.(normalized);
+      });
+    };
+    $[0] = checkout;
+    $[1] = onError;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const handleClick = t1;
+  const t2 = disabled === true || pending;
+  let t3;
+  if ($[3] !== ariaLabel || $[4] !== children || $[5] !== className || $[6] !== handleClick || $[7] !== pending || $[8] !== t2 || $[9] !== title) {
+    t3 = /* @__PURE__ */ jsxDEV("button", {
+      "aria-busy": pending,
+      "aria-label": ariaLabel,
+      className,
+      disabled: t2,
+      onClick: handleClick,
+      title,
+      type: "button",
+      children
+    }, void 0, false);
+    $[3] = ariaLabel;
+    $[4] = children;
+    $[5] = className;
+    $[6] = handleClick;
+    $[7] = pending;
+    $[8] = t2;
+    $[9] = title;
+    $[10] = t3;
+  } else {
+    t3 = $[10];
+  }
+  return t3;
+};
+const CheckoutButton = (t0) => {
+  const $ = c(11);
+  let onCheckout;
+  let rest;
+  if ($[0] !== t0) {
+    ({
+      onCheckout,
+      ...rest
+    } = t0);
+    $[0] = t0;
+    $[1] = onCheckout;
+    $[2] = rest;
+  } else {
+    onCheckout = $[1];
+    rest = $[2];
+  }
+  const {
+    "aria-label": ariaLabel,
+    children,
+    className,
+    disabled,
+    onError,
+    title
+  } = rest;
+  let t1;
+  if ($[3] !== ariaLabel || $[4] !== children || $[5] !== className || $[6] !== disabled || $[7] !== onCheckout || $[8] !== onError || $[9] !== title) {
+    t1 = /* @__PURE__ */ jsxDEV(RedirectButton, {
+      "aria-label": ariaLabel,
+      className,
+      disabled,
+      onError,
+      title,
+      trigger: onCheckout,
+      children
+    }, void 0, false);
+    $[3] = ariaLabel;
+    $[4] = children;
+    $[5] = className;
+    $[6] = disabled;
+    $[7] = onCheckout;
+    $[8] = onError;
+    $[9] = title;
+    $[10] = t1;
+  } else {
+    t1 = $[10];
+  }
+  return t1;
+};
+const CustomerPortalButton = (t0) => {
+  const $ = c(11);
+  let onPortal;
+  let rest;
+  if ($[0] !== t0) {
+    ({
+      onPortal,
+      ...rest
+    } = t0);
+    $[0] = t0;
+    $[1] = onPortal;
+    $[2] = rest;
+  } else {
+    onPortal = $[1];
+    rest = $[2];
+  }
+  const {
+    "aria-label": ariaLabel,
+    children,
+    className,
+    disabled,
+    onError,
+    title
+  } = rest;
+  let t1;
+  if ($[3] !== ariaLabel || $[4] !== children || $[5] !== className || $[6] !== disabled || $[7] !== onError || $[8] !== onPortal || $[9] !== title) {
+    t1 = /* @__PURE__ */ jsxDEV(RedirectButton, {
+      "aria-label": ariaLabel,
+      className,
+      disabled,
+      onError,
+      title,
+      trigger: onPortal,
+      children
+    }, void 0, false);
+    $[3] = ariaLabel;
+    $[4] = children;
+    $[5] = className;
+    $[6] = disabled;
+    $[7] = onError;
+    $[8] = onPortal;
+    $[9] = title;
+    $[10] = t1;
+  } else {
+    t1 = $[10];
+  }
+  return t1;
+};
+
+export { CheckoutButton, CustomerPortalButton, useCheckout };

package/dist/packem_shared/LunoraProvider-D38Xp16l.mjs

@@ -0,0 +1,80 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { QueryClientContext, QueryClientProvider, QueryClient } from '@tanstack/react-query';
+import { use, useState, createContext } from 'react';
+import { jsxDEV } from 'react/jsx-dev-runtime';
+
+const LunoraContext = /* @__PURE__ */ createContext(null);
+const createDefaultQueryClient = () => new QueryClient({
+  defaultOptions: {
+    mutations: {
+      retry: 0
+    },
+    queries: {
+      gcTime: 5 * 6e4,
+      retry: 0,
+      staleTime: Number.POSITIVE_INFINITY
+    }
+  }
+});
+const LunoraProvider = (t0) => {
+  const $ = c(9);
+  const {
+    children,
+    client,
+    queryClient
+  } = t0;
+  const parentQueryClient = use(QueryClientContext);
+  let t1;
+  if ($[0] !== parentQueryClient || $[1] !== queryClient) {
+    t1 = () => queryClient ?? parentQueryClient ?? createDefaultQueryClient();
+    $[0] = parentQueryClient;
+    $[1] = queryClient;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const [internalClient] = useState(t1);
+  const effectiveClient = queryClient ?? parentQueryClient ?? internalClient;
+  if (!effectiveClient) {
+    throw new Error("LunoraProvider: failed to resolve a QueryClient");
+  }
+  let t2;
+  if ($[3] !== children || $[4] !== client) {
+    t2 = /* @__PURE__ */ jsxDEV(LunoraContext, {
+      value: client,
+      children
+    }, void 0, false);
+    $[3] = children;
+    $[4] = client;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const content = t2;
+  if (parentQueryClient === effectiveClient) {
+    return content;
+  }
+  let t3;
+  if ($[6] !== content || $[7] !== effectiveClient) {
+    t3 = /* @__PURE__ */ jsxDEV(QueryClientProvider, {
+      client: effectiveClient,
+      children: content
+    }, void 0, false);
+    $[6] = content;
+    $[7] = effectiveClient;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  return t3;
+};
+const useLunora = () => {
+  const client = use(LunoraContext);
+  if (!client) {
+    throw new Error("useLunora must be used inside <LunoraProvider />");
+  }
+  return client;
+};
+
+export { LunoraProvider, useLunora };

package/dist/packem_shared/cache-CItk3fgN.mjs

@@ -0,0 +1,75 @@
+import { k as keyHash } from './query-key-C5rufkEE.mjs';
+
+class LunoraSubscriptionRegistry {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Hash a TanStack `queryKey` to the internal registry index. Exposed so a
+   * hook can look up the registry without re-implementing the hash.
+   */
+  // eslint-disable-next-line class-methods-use-this -- instance method by design: callers reach the hash through a registry handle rather than importing the module-level helper.
+  keyOf(queryKey) {
+    return keyHash(queryKey);
+  }
+  /**
+   * Attach a consumer to the live subscription for `queryKey`. The first
+   * attach opens the underlying WS subscription; subsequent attaches reuse
+   * it (refcount-bumped). Returns the detach function — call it exactly once
+   * per attach.
+   */
+  attach(queryClient, queryKey, function_, args, shardKey, options = {}) {
+    const key = keyHash(queryKey);
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = {
+        pollTimer: void 0,
+        refCount: 0,
+        unsubscribe: void 0
+      };
+      this.entries.set(key, entry);
+      try {
+        entry.unsubscribe = this.client.subscribe(function_, args, (value) => {
+          queryClient.setQueryData(queryKey, value);
+        }, {
+          shardKey
+        });
+      } catch {
+        entry.pollTimer = setInterval(() => {
+          queryClient.invalidateQueries({
+            queryKey
+          }).catch(() => {
+          });
+        }, options.pollIntervalMs ?? 5e3);
+      }
+    }
+    entry.refCount += 1;
+    return () => {
+      const current = this.entries.get(key);
+      if (!current) {
+        return;
+      }
+      current.refCount -= 1;
+      if (current.refCount <= 0) {
+        current.unsubscribe?.();
+        if (current.pollTimer) {
+          clearInterval(current.pollTimer);
+        }
+        this.entries.delete(key);
+      }
+    };
+  }
+}
+const registryByClient = /* @__PURE__ */ new WeakMap();
+const getSubscriptionRegistry = (client) => {
+  let registry = registryByClient.get(client);
+  if (!registry) {
+    registry = new LunoraSubscriptionRegistry(client);
+    registryByClient.set(client, registry);
+  }
+  return registry;
+};
+
+export { getSubscriptionRegistry as g };

package/dist/packem_shared/hydratePreloaded-BlFL9FGq.mjs

@@ -0,0 +1,46 @@
+'use client';
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import { useMemo, useEffect } from 'react';
+import { g as getSubscriptionRegistry } from './cache-CItk3fgN.mjs';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { l as lunoraQueryKey, s as serializeQueryKey } from './query-key-C5rufkEE.mjs';
+
+const usePreloadedQuery = function(preloaded) {
+  const client = useLunora();
+  const queryClient = useQueryClient();
+  const {
+    args,
+    functionPath,
+    shardKey,
+    value
+  } = preloaded;
+  const functionRef = useMemo(() => {
+    return {
+      __lunoraRef: functionPath
+    };
+  }, [functionPath]);
+  const queryKey = useMemo(() => lunoraQueryKey(functionRef, args, shardKey), [functionRef.__lunoraRef, JSON.stringify(args), shardKey]);
+  const {
+    data
+  } = useQuery({
+    // Seed the cache with the server value so the first paint doesn't
+    // re-fetch. TanStack treats `initialData` as fresh — the WS push from
+    // the registry is what supplies subsequent updates.
+    initialData: value,
+    queryFn: () => client.query(functionRef, args, {
+      shardKey
+    }),
+    queryKey,
+    staleTime: Number.POSITIVE_INFINITY
+  });
+  useEffect(() => {
+    const registry = getSubscriptionRegistry(client);
+    return registry.attach(queryClient, queryKey, functionRef, args, shardKey);
+  }, [client, queryClient, serializeQueryKey(queryKey)]);
+  return data ?? value;
+};
+const hydratePreloaded = function(preloaded) {
+  return usePreloadedQuery(preloaded);
+};
+
+export { usePreloadedQuery as default, hydratePreloaded };

package/dist/packem_shared/lunoraQueryOptions-CsuWzjg1.mjs

@@ -0,0 +1,16 @@
+import { l as lunoraQueryKey } from './query-key-C5rufkEE.mjs';
+
+const lunoraQueryOptions = (client, function_, args, options = {}) => {
+  const argsRecord = args ?? {};
+  return {
+    queryFn: () => client.query(function_, argsRecord, {
+      shardKey: options.shardKey
+    }),
+    queryKey: lunoraQueryKey(function_, argsRecord, options.shardKey),
+    // Lunora is push-driven: the value never goes stale on a timer. For
+    // reactivity use `useQuery`; this adapter is a one-shot/suspense read.
+    staleTime: Number.POSITIVE_INFINITY
+  };
+};
+
+export { lunoraQueryOptions };

package/dist/packem_shared/query-key-C5rufkEE.mjs

@@ -0,0 +1,21 @@
+const keyHash = (queryKey) => JSON.stringify(queryKey);
+const stableStringify = (value) => {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  }
+  const entries = Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([key, value_]) => `${JSON.stringify(key)}:${stableStringify(value_)}`).join(",")}}`;
+};
+const lunoraQueryKey = (function_, args, shardKey) => [
+  "lunora",
+  function_.__lunoraRef,
+  args,
+  // eslint-disable-next-line unicorn/no-null -- this literal is part of the JSON-serialized query key TanStack hashes for dedup; `null` keeps a stable, distinct slot from an absent shardKey across renders.
+  shardKey ?? null
+];
+const serializeQueryKey = (queryKey) => keyHash(queryKey);
+
+export { stableStringify as a, keyHash as k, lunoraQueryKey as l, serializeQueryKey as s };

package/dist/packem_shared/query-options.d-D4okOpO8.d.mts

@@ -0,0 +1,38 @@
+import { FunctionReference, ReturnOf, LunoraClient, ArgsOf } from '@lunora/client';
+import { QueryKey } from '@tanstack/react-query';
+/**
+* Pure, transport-free adapter between a Lunora function reference and a
+* TanStack Query options object. No `"use client"` directive and only a
+* type-level `@lunora/client` import, so it is safe to use on either side of an
+* RSC boundary (the runtime transport is the `LunoraClient` you pass in).
+*
+* Use it when you want to drive a Lunora query through TanStack's own hooks —
+* `useSuspenseQuery`, `useQueries`, or the server-side
+* `queryClient.ensureQueryData` / `prefetchQuery` — rather than the first-class
+* `useQuery` from `@lunora/react`.
+*/
+/** Shape returned by `lunoraQueryOptions`, spread into a TanStack hook. */
+interface LunoraQueryOptions<F extends FunctionReference> {
+  queryFn: () => Promise<ReturnOf<F>>;
+  queryKey: QueryKey;
+  staleTime: number;
+}
+/**
+* Build a TanStack Query options object for a Lunora query, keyed identically
+* to the first-class hooks (see `lunoraQueryKey`) so a value fetched through
+* this adapter shares cache identity with anything `useQuery` /
+* `prefetchQuery` reads or writes for the same `(fn, args, shardKey)` triple.
+*
+* ```ts
+* const { data } = useSuspenseQuery(lunoraQueryOptions(client, api.posts.list, {}));
+* ```
+*
+* This is a one-shot fetch: it resolves once and `staleTime` is infinite, so
+* TanStack never refetches on its own. It does not open a WebSocket — for live
+* updates that re-render on every server push, use `useQuery` from
+* `@lunora/react`, which attaches a shared subscription to the same cache key.
+*/
+declare const lunoraQueryOptions: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => LunoraQueryOptions<F>;
+export { LunoraQueryOptions as L, lunoraQueryOptions as l };

package/dist/packem_shared/query-options.d-D4okOpO8.d.ts

@@ -0,0 +1,38 @@
+import { FunctionReference, ReturnOf, LunoraClient, ArgsOf } from '@lunora/client';
+import { QueryKey } from '@tanstack/react-query';
+/**
+* Pure, transport-free adapter between a Lunora function reference and a
+* TanStack Query options object. No `"use client"` directive and only a
+* type-level `@lunora/client` import, so it is safe to use on either side of an
+* RSC boundary (the runtime transport is the `LunoraClient` you pass in).
+*
+* Use it when you want to drive a Lunora query through TanStack's own hooks —
+* `useSuspenseQuery`, `useQueries`, or the server-side
+* `queryClient.ensureQueryData` / `prefetchQuery` — rather than the first-class
+* `useQuery` from `@lunora/react`.
+*/
+/** Shape returned by `lunoraQueryOptions`, spread into a TanStack hook. */
+interface LunoraQueryOptions<F extends FunctionReference> {
+  queryFn: () => Promise<ReturnOf<F>>;
+  queryKey: QueryKey;
+  staleTime: number;
+}
+/**
+* Build a TanStack Query options object for a Lunora query, keyed identically
+* to the first-class hooks (see `lunoraQueryKey`) so a value fetched through
+* this adapter shares cache identity with anything `useQuery` /
+* `prefetchQuery` reads or writes for the same `(fn, args, shardKey)` triple.
+*
+* ```ts
+* const { data } = useSuspenseQuery(lunoraQueryOptions(client, api.posts.list, {}));
+* ```
+*
+* This is a one-shot fetch: it resolves once and `staleTime` is infinite, so
+* TanStack never refetches on its own. It does not open a WebSocket — for live
+* updates that re-render on every server push, use `useQuery` from
+* `@lunora/react`, which attaches a shared subscription to the same cache key.
+*/
+declare const lunoraQueryOptions: <F extends FunctionReference>(client: LunoraClient, function_: F, args: ArgsOf<F>, options?: {
+  shardKey?: string;
+}) => LunoraQueryOptions<F>;
+export { LunoraQueryOptions as L, lunoraQueryOptions as l };

package/dist/packem_shared/use-paginated-core-CoOfcc-p.mjs

@@ -0,0 +1,161 @@
+'use client';
+import { initialPages, rebalance, derivePaginationStatus, applyLoadMore } from '@lunora/client/pagination';
+import { useQueryClient } from '@tanstack/react-query';
+import { useRef, useReducer, useState, useEffect, useCallback } from 'react';
+import { g as getSubscriptionRegistry } from './cache-CItk3fgN.mjs';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { s as serializeQueryKey, l as lunoraQueryKey } from './query-key-C5rufkEE.mjs';
+
+const useLazyRef = function(create) {
+  const reference = useRef(void 0);
+  reference.current ??= create();
+  return reference;
+};
+
+const usePaginatedCore = function(function_, args, options) {
+  const client = useLunora();
+  const queryClient = useQueryClient();
+  const {
+    initialNumItems,
+    shardKey
+  } = options;
+  const skipped = args === "skip";
+  const baseArgs = skipped ? {} : args;
+  const baseArgsKey = JSON.stringify(baseArgs);
+  const [, forceRender] = useReducer((tick) => tick + 1, 0);
+  const [pages, setPages] = useState(() => initialPages(initialNumItems));
+  const resetKey = `${function_.__lunoraRef}::${baseArgsKey}::${String(initialNumItems)}::${shardKey ?? ""}`;
+  const resetKeyRef = useRef(resetKey);
+  if (resetKeyRef.current !== resetKey) {
+    resetKeyRef.current = resetKey;
+    setPages(initialPages(initialNumItems));
+  }
+  const pageEntries = pages.map((page) => {
+    const pageArgs = {
+      ...baseArgs,
+      paginationOpts: {
+        cursor: page.lower,
+        endCursor: page.upper,
+        numItems: page.numItems
+      }
+    };
+    const key = lunoraQueryKey(function_, pageArgs, shardKey);
+    return {
+      args: pageArgs,
+      key
+    };
+  });
+  const pageKeysHash = pageEntries.map(({
+    key: key_0
+  }) => serializeQueryKey(key_0)).join("|");
+  const desiredRef = useRef({
+    entries: [],
+    fn: function_,
+    shardKey
+  });
+  useEffect(() => {
+    desiredRef.current = {
+      entries: pageEntries,
+      fn: function_,
+      shardKey
+    };
+  });
+  const detachesRef = useLazyRef(() => /* @__PURE__ */ new Map());
+  const detachClientRef = useRef(client);
+  useEffect(() => {
+    const detaches = detachesRef.current;
+    if (detachClientRef.current !== client) {
+      for (const detach of detaches.values()) {
+        detach();
+      }
+      detaches.clear();
+      detachClientRef.current = client;
+    }
+    if (skipped) {
+      for (const detach_0 of detaches.values()) {
+        detach_0();
+      }
+      detaches.clear();
+      return;
+    }
+    const desired = desiredRef.current;
+    const registry = getSubscriptionRegistry(client);
+    const wanted = new Set(desired.entries.map(({
+      key: key_1
+    }) => serializeQueryKey(key_1)));
+    for (const [hash, detach_1] of detaches) {
+      if (!wanted.has(hash)) {
+        detach_1();
+        detaches.delete(hash);
+      }
+    }
+    for (const entry of desired.entries) {
+      const hash_0 = serializeQueryKey(entry.key);
+      if (detaches.has(hash_0)) {
+        continue;
+      }
+      const initialFetch = queryClient.fetchQuery({
+        queryFn: () => client.query(desired.fn, entry.args, {
+          shardKey: desired.shardKey
+        }),
+        queryKey: entry.key,
+        staleTime: 0
+      });
+      initialFetch.catch(() => {
+      });
+      detaches.set(hash_0, registry.attach(queryClient, entry.key, desired.fn, entry.args, desired.shardKey));
+    }
+  }, [client, queryClient, pageKeysHash, skipped]);
+  useEffect(() => () => {
+    for (const detach_2 of detachesRef.current.values()) {
+      detach_2();
+    }
+    detachesRef.current.clear();
+  }, []);
+  useEffect(() => {
+    const cache = queryClient.getQueryCache();
+    const unsubscribe = cache.subscribe((event) => {
+      if (event.type !== "updated") {
+        return;
+      }
+      const hash_1 = serializeQueryKey(event.query.queryKey);
+      if (pageEntries.some(({
+        key: key_2
+      }) => serializeQueryKey(key_2) === hash_1)) {
+        forceRender();
+      }
+    });
+    return unsubscribe;
+  }, [queryClient, pageKeysHash]);
+  const pageResults = skipped ? [] : pageEntries.map(({
+    key: key_3
+  }) => queryClient.getQueryData(key_3));
+  useEffect(() => {
+    if (skipped) {
+      return;
+    }
+    const next = rebalance(pages, pageResults);
+    if (next) {
+      setPages(next);
+    }
+  });
+  const {
+    nextCursor,
+    status
+  } = derivePaginationStatus(skipped, pageResults);
+  const nextCursorRef = useRef(void 0);
+  useEffect(() => {
+    nextCursorRef.current = status === "CanLoadMore" ? nextCursor : void 0;
+  });
+  const loadMore = useCallback((numberItems) => {
+    const cursor = nextCursorRef.current;
+    setPages((current) => applyLoadMore(current, cursor, numberItems) ?? current);
+  }, []);
+  return {
+    loadMore,
+    pageResults,
+    status
+  };
+};
+
+export { usePaginatedCore as u };