@supalive/react 0.1.1 → 0.1.6

package/dist/src/index.d.ts

@@ -1,11 +1,186 @@
-export { createSupaliveContext, type SupaliveContext } from "./context";
-export { createSupaliveProvider, type SupaliveProviderProps, } from "./provider";
-export { createUseSupalive } from "./use_supalive";
-export { createUseConnectionState } from "./use_connection_state";
-export { createLiveQuery } from "./create_live_query";
-export { createQuery } from "./create_query";
-export { createMutation } from "./create_mutation";
-export { createAction } from "./create_action";
-export type { QueryStatus, QueryResult, LiveQueryStatus, LiveQueryResult, LiveQueryState, MutationStatus, MutationState, ActionState, QueryProcedureLike, MutationProcedureLike, ActionProcedureLike, ProcedureSelector, } from "./types";
-export type { ClientPublicState } from "@supalive/core/client";
+import { Context, ReactNode } from "react";
+import { ClientPublicState, ClientPublicState as ClientPublicState$1, LiveQueryHandle, LiveQueryState, LiveQueryState as LiveQueryState$1 } from "@supalive/core/client";
+
+//#region src/context.d.ts
+/**
+ * The React context object that carries the typed client. Userland creates
+ * one of these per app, then passes it to every hook factory so they all
+ * agree on the same `TClient`.
+ */
+type SupaliveContext<TClient> = Context<TClient | null>;
+declare function createSupaliveContext<TClient>(): SupaliveContext<TClient>;
+//#endregion
+//#region src/provider.d.ts
+/**
+ * Minimal shape we need from any client passed through this provider. Both
+ * `createClient`'s output (which has `WSClientMethods`) and a hand-rolled
+ * client satisfy it, so the provider stays generic.
+ */
+interface SupaliveLifecycleClient {
+  connect(): Promise<void>;
+  disconnect(): void;
+}
+interface SupaliveProviderProps<TClient> {
+  /**
+   * Either a factory (built each mount, lazy) or a pre-built client. A
+   * factory matches the Convex pattern of letting the provider own the
+   * client's lifetime; passing a pre-built client lets you share it with
+   * non-React callers (SSR, scripts).
+   */
+  client: TClient | (() => TClient);
+  children: ReactNode;
+}
+/**
+ * Build a typed `<SupaliveProvider>` for a given `TClient`. Pass the same
+ * context object to every other hook factory so they share the client.
+ *
+ * StrictMode-safe: the client lives on a ref and is never recreated. The
+ * cleanup schedules `disconnect()` through a 250 ms timer parked on a ref,
+ * so a synchronous re-mount (as StrictMode does in dev) cancels it before
+ * the socket is torn down. A real unmount lets the timer fire.
+ */
+declare function createSupaliveProvider<TClient extends SupaliveLifecycleClient>(ctx: SupaliveContext<TClient>): ({
+  client,
+  children
+}: SupaliveProviderProps<TClient>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/use_supalive.d.ts
+/**
+ * Returns a `useSupalive` hook that yields the typed client. Use this when
+ * you need to call procedures imperatively (outside the standard query/
+ * mutation hooks), e.g. inside an event handler that doesn't fit one of
+ * the higher-level helpers.
+ */
+declare function createUseSupalive<TClient>(ctx: SupaliveContext<TClient>): () => TClient;
+//#endregion
+//#region src/use_connection_state.d.ts
+/**
+ * Shape of any client that surfaces the WS connection state. Both the
+ * generated `createClient` proxy and a hand-rolled client satisfy it.
+ */
+interface ClientWithState {
+  onState(listener: (s: ClientPublicState$1) => void): () => void;
+  getPublicState(): ClientPublicState$1;
+}
+/**
+ * Returns a `useSupaliveConnectionState` hook for showing connection
+ * banners ("Reconnecting…", "Offline", etc.) without having to subscribe
+ * to the client manually.
+ */
+declare function createUseConnectionState<TClient extends ClientWithState>(ctx: SupaliveContext<TClient>): () => ClientPublicState$1;
+//#endregion
+//#region src/types.d.ts
+/** Shape of a query procedure exposed by `ClientFromProcedures`. */
+interface QueryProcedureLike<TInput, TOutput> {
+  query: (input: TInput) => Promise<TOutput>;
+  liveQuery: (input: TInput, serializedInput: string) => LiveQueryHandle<TOutput>;
+}
+/** Shape of a mutation procedure. */
+interface MutationProcedureLike<TInput, TOutput> {
+  mutate: (input: TInput, opts?: {
+    onSend?: () => void;
+  }) => Promise<TOutput>;
+}
+/** Shape of an action procedure. */
+interface ActionProcedureLike<TInput, TOutput> {
+  action: (input: TInput, opts?: {
+    onSend?: () => void;
+  }) => Promise<TOutput>;
+}
+/** Selector function used by all hooks. */
+type ProcedureSelector<TClient, TProc> = (client: TClient) => TProc;
+type QueryStatus = "idle" | "loading" | "success" | "error";
+interface QueryResult<T> {
+  data: T | undefined;
+  status: QueryStatus;
+  error: Error | null;
+  refetch: () => void;
+}
+type LiveQueryStatus = LiveQueryState$1<unknown>["status"];
+interface LiveQueryResult<T> {
+  data: T | undefined;
+  status: LiveQueryStatus;
+  error: Error | null;
+  refetch: () => void;
+}
+type MutationStatus = "idle" | "queued" | "loading" | "success" | "error";
+interface MutationState<T> {
+  data: T | undefined;
+  status: MutationStatus;
+  error: Error | null;
+  reset: () => void;
+}
+interface ActionState<T> {
+  data: T | undefined;
+  status: MutationStatus;
+  error: Error | null;
+  reset: () => void;
+}
+//#endregion
+//#region src/create_live_query.d.ts
+/**
+ * Returns a typed `useLiveQuery` hook bound to a specific client type.
+ *
+ * Userland:
+ *   const useLiveQuery = createLiveQuery<SupaliveClient>(SupaliveCtx);
+ *   const { data, status, error } = useLiveQuery(c => c.listItems, { limit: 50 });
+ *
+ * Internals (modelled on Convex's `useQuery` + `useSubscription`, but
+ * using React 18's native `useSyncExternalStore` instead of the legacy
+ * shim Convex still bundles):
+ *
+ *   - Selector is fired synchronously to get the procedure object; the
+ *     procedure's `liveQuery(input)` returns a shared `LiveQueryHandle`
+ *     (ref-counted in the client) so multiple components reading the same
+ *     query share one server-side subscription.
+ *   - `useSyncExternalStore(handle.onState, handle.getState)` gives a
+ *     tearing-free, concurrent-safe render path.
+ *   - Re-subscription is keyed off `stableStringify(input)` so an inline
+ *     object literal that produces the same values doesn't churn handles.
+ *
+ * Define selectors at module scope (or with `useCallback`) so the reference
+ * is stable across renders; this isn't required for correctness, but it
+ * keeps the `useMemo` cheap.
+ */
+declare function createLiveQuery<TClient>(ctx: SupaliveContext<TClient>): <TInput, TOutput>(selector: ProcedureSelector<TClient, QueryProcedureLike<TInput, TOutput>>, input: TInput) => LiveQueryResult<TOutput>;
+//#endregion
+//#region src/create_query.d.ts
+/**
+ * One-shot query (no live updates). Re-runs when the serialised input
+ * changes. `refetch()` re-issues the same query immediately.
+ *
+ *   const { data, status, error, refetch } = useQuery(c => c.getItem, { id });
+ */
+declare function createQuery<TClient>(ctx: SupaliveContext<TClient>): <TInput, TOutput>(selector: ProcedureSelector<TClient, QueryProcedureLike<TInput, TOutput>>, input: TInput) => QueryResult<TOutput>;
+//#endregion
+//#region src/create_mutation.d.ts
+/**
+ * Typed mutation hook factory.
+ *
+ *   const [createItem, { status, error, data, reset }] =
+ *     useMutation(c => c.createItem);
+ *
+ * Statuses:
+ *   - "idle"    — initial state, or after `reset()`
+ *   - "queued"  — call has been queued because the client wasn't ready
+ *                 (offline, reconnecting, mid-handshake); we use the
+ *                 transport's `onSend` callback to flip to "loading" once
+ *                 the request actually leaves the wire
+ *   - "loading" — request is on the wire, awaiting response
+ *   - "success" — server returned success
+ *   - "error"   — server returned an error or the call rejected
+ */
+declare function createMutation<TClient>(ctx: SupaliveContext<TClient>): <TInput, TOutput>(selector: ProcedureSelector<TClient, MutationProcedureLike<TInput, TOutput>>) => [(input: TInput) => Promise<TOutput>, MutationState<TOutput>];
+//#endregion
+//#region src/create_action.d.ts
+/**
+ * Typed action hook factory. Same shape as `useMutation` — actions in
+ * Supalive have the same client-side semantics (single-call, response,
+ * may be queued during disconnect).
+ *
+ *   const [bulkUpdate, { status }] = useAction(c => c.bulkUpdateItems);
+ */
+declare function createAction<TClient>(ctx: SupaliveContext<TClient>): <TInput, TOutput>(selector: ProcedureSelector<TClient, ActionProcedureLike<TInput, TOutput>>) => [(input: TInput) => Promise<TOutput>, ActionState<TOutput>];
+//#endregion
+export { type ActionProcedureLike, type ActionState, type ClientPublicState, type LiveQueryResult, type LiveQueryState, type LiveQueryStatus, type MutationProcedureLike, type MutationState, type MutationStatus, type ProcedureSelector, type QueryProcedureLike, type QueryResult, type QueryStatus, type SupaliveContext, type SupaliveProviderProps, createAction, createLiveQuery, createMutation, createQuery, createSupaliveContext, createSupaliveProvider, createUseConnectionState, createUseSupalive };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,qBAAqB,EAAE,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,GAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,YAAY,EACV,WAAW,EACX,WAAW,EACX,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AAEjB,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/context.ts","../../src/provider.tsx","../../src/use_supalive.ts","../../src/use_connection_state.ts","../../src/types.ts","../../src/create_live_query.ts","../../src/create_query.ts","../../src/create_mutation.ts","../../src/create_action.ts"],"mappings":";;;;;;;AAOA;;KAAY,eAAA,YAA2B,OAAO,CAAC,OAAA;AAAA,iBAE/B,qBAAA,aAAkC,eAAe,CAAC,OAAA;;;;;AAFlE;;;UCCU,uBAAA;EACR,OAAA,IAAW,OAAO;EAClB,UAAA;AAAA;AAAA,UAGe,qBAAA;EDNqC;AAEtD;;;;;ECWE,MAAA,EAAQ,OAAA,UAAiB,OAAA;EACzB,QAAA,EAAU,SAAA;AAAA;ADZ6D;;;;ACRxB;;;;;ADQwB,iBCwBzD,sBAAA,iBAAuC,uBAAA,EACrD,GAAA,EAAK,eAAA,CAAgB,OAAA;EAEY,MAAA;EAAA;AAAA,GAG9B,qBAAA,CAAsB,OAAA,kCAAQ,GAAA,CAAA,OAAA;;;;;;ADhCnC;;;iBEEgB,iBAAA,UAA2B,GAAA,EAAK,eAAA,CAAgB,OAAA,UAC/B,OAAA;;;;;AFHjC;;UGEU,eAAA;EACR,OAAA,CAAQ,QAAA,GAAW,CAAA,EAAG,mBAAA;EACtB,cAAA,IAAkB,mBAAiB;AAAA;;;AHJiB;AAEtD;;iBGUgB,wBAAA,iBAAyC,eAAA,EACvD,GAAA,EAAK,eAAA,CAAgB,OAAA,UAEyB,mBAAA;;;;UCN/B,kBAAA;EACf,KAAA,GAAQ,KAAA,EAAO,MAAA,KAAW,OAAA,CAAQ,OAAA;EAClC,SAAA,GAAY,KAAA,EAAO,MAAA,EAAQ,eAAA,aAA4B,eAAA,CAAgB,OAAA;AAAA;;UAIxD,qBAAA;EACf,MAAA,GAAS,KAAA,EAAO,MAAA,EAAQ,IAAA;IAAS,MAAA;EAAA,MAA0B,OAAA,CAAQ,OAAA;AAAA;;UAIpD,mBAAA;EACf,MAAA,GAAS,KAAA,EAAO,MAAA,EAAQ,IAAA;IAAS,MAAA;EAAA,MAA0B,OAAA,CAAQ,OAAA;AAAA;;KAIzD,iBAAA,oBAAqC,MAAA,EAAQ,OAAA,KAAY,KAAK;AAAA,KAE9D,WAAA;AAAA,UAEK,WAAA;EACf,IAAA,EAAM,CAAA;EACN,MAAA,EAAQ,WAAA;EACR,KAAA,EAAO,KAAA;EACP,OAAA;AAAA;AAAA,KAGU,eAAA,GAAkB,gBAAc;AAAA,UAE3B,eAAA;EACf,IAAA,EAAM,CAAA;EACN,MAAA,EAAQ,eAAA;EACR,KAAA,EAAO,KAAA;EACP,OAAA;AAAA;AAAA,KAGU,cAAA;AAAA,UAOK,aAAA;EACf,IAAA,EAAM,CAAA;EACN,MAAA,EAAQ,cAAA;EACR,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,UAGe,WAAA;EACf,IAAA,EAAM,CAAA;EACN,MAAA,EAAQ,cAAA;EACR,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;;;;;AJ/DF;;;;;;;;AAAsD;AAEtD;;;;;;;;AAAyE;;;;ACRxB;iBIkCjC,eAAA,UAAyB,GAAA,EAAK,eAAA,CAAgB,OAAA,sBAE1D,QAAA,EAAU,iBAAA,CAAkB,OAAA,EAAS,kBAAA,CAAmB,MAAA,EAAQ,OAAA,IAChE,KAAA,EAAO,MAAA,KACN,eAAA,CAAgB,OAAA;;;;;ALhCrB;;;;iBMUgB,WAAA,UAAqB,GAAA,EAAK,eAAA,CAAgB,OAAA,sBAEtD,QAAA,EAAU,iBAAA,CAAkB,OAAA,EAAS,kBAAA,CAAmB,MAAA,EAAQ,OAAA,IAChE,KAAA,EAAO,MAAA,KACN,WAAA,CAAY,OAAA;;;;;ANdjB;;;;;;;;AAAsD;AAEtD;;;;;iBOiBgB,cAAA,UAAwB,GAAA,EAAK,eAAA,CAAgB,OAAA,sBAEzD,QAAA,EAAU,iBAAA,CAAkB,OAAA,EAAS,qBAAA,CAAsB,MAAA,EAAQ,OAAA,SAElE,KAAA,EAAO,MAAA,KAAW,OAAA,CAAQ,OAAA,GAC3B,aAAA,CAAc,OAAA;;;;;APxBlB;;;;;iBQUgB,YAAA,UAAsB,GAAA,EAAK,eAAA,CAAgB,OAAA,sBAEvD,QAAA,EAAU,iBAAA,CAAkB,OAAA,EAAS,mBAAA,CAAoB,MAAA,EAAQ,OAAA,SAEhE,KAAA,EAAO,MAAA,KAAW,OAAA,CAAQ,OAAA,GAC3B,WAAA,CAAY,OAAA"}

package/dist/src/index.js

@@ -1,33 +1,270 @@
-// Public surface of @supalive/react.
-//
-// Userland wiring:
-//
-//   import {
-//     createSupaliveContext,
-//     createSupaliveProvider,
-//     createUseSupalive,
-//     createUseConnectionState,
-//     createLiveQuery,
-//     createQuery,
-//     createMutation,
-//     createAction,
-//   } from "@supalive/react";
-//
-//   const ctx = createSupaliveContext<SupaliveClient>();
-//
-//   export const SupaliveProvider          = createSupaliveProvider(ctx);
-//   export const useSupalive               = createUseSupalive(ctx);
-//   export const useSupaliveConnectionState = createUseConnectionState(ctx);
-//   export const useLiveQuery              = createLiveQuery(ctx);
-//   export const useQuery                  = createQuery(ctx);
-//   export const useMutation               = createMutation(ctx);
-//   export const useAction                 = createAction(ctx);
-export { createSupaliveContext } from "./context";
-export { createSupaliveProvider, } from "./provider";
-export { createUseSupalive } from "./use_supalive";
-export { createUseConnectionState } from "./use_connection_state";
-export { createLiveQuery } from "./create_live_query";
-export { createQuery } from "./create_query";
-export { createMutation } from "./create_mutation";
-export { createAction } from "./create_action";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { jsx } from "react/jsx-runtime";
+import { stableStringify } from "@supalive/core/types";
+//#region src/context.ts
+function createSupaliveContext() {
+	return createContext(null);
+}
+function useContextOrThrow(ctx) {
+	const value = useContext(ctx);
+	if (value === null) throw new Error("Supalive: no client found in React context. Wrap your app in <SupaliveProvider>.");
+	return value;
+}
+//#endregion
+//#region src/provider.tsx
+/**
+* Build a typed `<SupaliveProvider>` for a given `TClient`. Pass the same
+* context object to every other hook factory so they share the client.
+*
+* StrictMode-safe: the client lives on a ref and is never recreated. The
+* cleanup schedules `disconnect()` through a 250 ms timer parked on a ref,
+* so a synchronous re-mount (as StrictMode does in dev) cancels it before
+* the socket is torn down. A real unmount lets the timer fire.
+*/
+function createSupaliveProvider(ctx) {
+	return function SupaliveProvider({ client, children }) {
+		const clientRef = useRef(null);
+		const disconnectTimerRef = useRef(null);
+		if (!clientRef.current) clientRef.current = typeof client === "function" ? client() : client;
+		useEffect(() => {
+			if (disconnectTimerRef.current) {
+				clearTimeout(disconnectTimerRef.current);
+				disconnectTimerRef.current = null;
+			}
+			const c = clientRef.current;
+			c.connect().catch((err) => {
+				console.error("[Supalive] connect failed:", err);
+			});
+			return () => {
+				disconnectTimerRef.current = setTimeout(() => {
+					disconnectTimerRef.current = null;
+					c.disconnect();
+				}, 250);
+			};
+		}, []);
+		return /* @__PURE__ */ jsx(ctx.Provider, {
+			value: clientRef.current,
+			children
+		});
+	};
+}
+//#endregion
+//#region src/use_supalive.ts
+/**
+* Returns a `useSupalive` hook that yields the typed client. Use this when
+* you need to call procedures imperatively (outside the standard query/
+* mutation hooks), e.g. inside an event handler that doesn't fit one of
+* the higher-level helpers.
+*/
+function createUseSupalive(ctx) {
+	return function useSupalive() {
+		return useContextOrThrow(ctx);
+	};
+}
+//#endregion
+//#region src/use_connection_state.ts
+/**
+* Returns a `useSupaliveConnectionState` hook for showing connection
+* banners ("Reconnecting…", "Offline", etc.) without having to subscribe
+* to the client manually.
+*/
+function createUseConnectionState(ctx) {
+	return function useSupaliveConnectionState() {
+		const client = useContextOrThrow(ctx);
+		return useSyncExternalStore((cb) => client.onState(() => cb()), () => client.getPublicState(), () => client.getPublicState());
+	};
+}
+//#endregion
+//#region src/create_live_query.ts
+/**
+* Returns a typed `useLiveQuery` hook bound to a specific client type.
+*
+* Userland:
+*   const useLiveQuery = createLiveQuery<SupaliveClient>(SupaliveCtx);
+*   const { data, status, error } = useLiveQuery(c => c.listItems, { limit: 50 });
+*
+* Internals (modelled on Convex's `useQuery` + `useSubscription`, but
+* using React 18's native `useSyncExternalStore` instead of the legacy
+* shim Convex still bundles):
+*
+*   - Selector is fired synchronously to get the procedure object; the
+*     procedure's `liveQuery(input)` returns a shared `LiveQueryHandle`
+*     (ref-counted in the client) so multiple components reading the same
+*     query share one server-side subscription.
+*   - `useSyncExternalStore(handle.onState, handle.getState)` gives a
+*     tearing-free, concurrent-safe render path.
+*   - Re-subscription is keyed off `stableStringify(input)` so an inline
+*     object literal that produces the same values doesn't churn handles.
+*
+* Define selectors at module scope (or with `useCallback`) so the reference
+* is stable across renders; this isn't required for correctness, but it
+* keeps the `useMemo` cheap.
+*/
+function createLiveQuery(ctx) {
+	return function useLiveQuery(selector, input) {
+		const client = useContextOrThrow(ctx);
+		const selectorRef = useRef(selector);
+		selectorRef.current = selector;
+		const serializedInput = stableStringify(input);
+		const handle = useMemo(() => selectorRef.current(client).liveQuery(input, serializedInput), [client, serializedInput]);
+		const state = useSyncExternalStore(handle.onState, handle.getState, handle.getState);
+		const refetch = useCallback(() => handle.refetch(), [handle]);
+		return {
+			data: state.data,
+			status: state.status,
+			error: state.error,
+			refetch
+		};
+	};
+}
+//#endregion
+//#region src/create_query.ts
+/**
+* One-shot query (no live updates). Re-runs when the serialised input
+* changes. `refetch()` re-issues the same query immediately.
+*
+*   const { data, status, error, refetch } = useQuery(c => c.getItem, { id });
+*/
+function createQuery(ctx) {
+	return function useQuery(selector, input) {
+		const client = useContextOrThrow(ctx);
+		const selectorRef = useRef(selector);
+		selectorRef.current = selector;
+		const [data, setData] = useState();
+		const [status, setStatus] = useState("idle");
+		const [error, setError] = useState(null);
+		const [tick, setTick] = useState(0);
+		useEffect(() => {
+			let cancelled = false;
+			setStatus("loading");
+			setError(null);
+			selectorRef.current(client).query(input).then((result) => {
+				if (cancelled) return;
+				setData(result);
+				setStatus("success");
+			}).catch((err) => {
+				if (cancelled) return;
+				setError(err instanceof Error ? err : new Error(String(err)));
+				setStatus("error");
+			});
+			return () => {
+				cancelled = true;
+			};
+		}, [
+			client,
+			stableStringify(input),
+			tick
+		]);
+		return {
+			data,
+			status,
+			error,
+			refetch: useCallback(() => setTick((t) => t + 1), [])
+		};
+	};
+}
+//#endregion
+//#region src/create_mutation.ts
+/**
+* Typed mutation hook factory.
+*
+*   const [createItem, { status, error, data, reset }] =
+*     useMutation(c => c.createItem);
+*
+* Statuses:
+*   - "idle"    — initial state, or after `reset()`
+*   - "queued"  — call has been queued because the client wasn't ready
+*                 (offline, reconnecting, mid-handshake); we use the
+*                 transport's `onSend` callback to flip to "loading" once
+*                 the request actually leaves the wire
+*   - "loading" — request is on the wire, awaiting response
+*   - "success" — server returned success
+*   - "error"   — server returned an error or the call rejected
+*/
+function createMutation(ctx) {
+	return function useMutation(selector) {
+		const client = useContextOrThrow(ctx);
+		const selectorRef = useRef(selector);
+		selectorRef.current = selector;
+		const [data, setData] = useState(void 0);
+		const [status, setStatus] = useState("idle");
+		const [error, setError] = useState(null);
+		const reset = useCallback(() => {
+			setData(void 0);
+			setStatus("idle");
+			setError(null);
+		}, []);
+		return [useCallback(async (input) => {
+			setError(null);
+			setData(void 0);
+			setStatus("queued");
+			try {
+				const result = await selectorRef.current(client).mutate(input, { onSend: () => {
+					setStatus("loading");
+				} });
+				setData(result);
+				setStatus("success");
+				return result;
+			} catch (err) {
+				const e = err instanceof Error ? err : new Error(String(err));
+				setError(e);
+				setStatus("error");
+				throw e;
+			}
+		}, [client]), {
+			data,
+			status,
+			error,
+			reset
+		}];
+	};
+}
+//#endregion
+//#region src/create_action.ts
+/**
+* Typed action hook factory. Same shape as `useMutation` — actions in
+* Supalive have the same client-side semantics (single-call, response,
+* may be queued during disconnect).
+*
+*   const [bulkUpdate, { status }] = useAction(c => c.bulkUpdateItems);
+*/
+function createAction(ctx) {
+	return function useAction(selector) {
+		const client = useContextOrThrow(ctx);
+		const selectorRef = useRef(selector);
+		selectorRef.current = selector;
+		const [data, setData] = useState(void 0);
+		const [status, setStatus] = useState("idle");
+		const [error, setError] = useState(null);
+		const reset = useCallback(() => {
+			setData(void 0);
+			setStatus("idle");
+			setError(null);
+		}, []);
+		return [useCallback(async (input) => {
+			setError(null);
+			setData(void 0);
+			setStatus("queued");
+			try {
+				const result = await selectorRef.current(client).action(input, { onSend: () => setStatus("loading") });
+				setData(result);
+				setStatus("success");
+				return result;
+			} catch (err) {
+				const e = err instanceof Error ? err : new Error(String(err));
+				setError(e);
+				setStatus("error");
+				throw e;
+			}
+		}, [client]), {
+			data,
+			status,
+			error,
+			reset
+		}];
+	};
+}
+//#endregion
+export { createAction, createLiveQuery, createMutation, createQuery, createSupaliveContext, createSupaliveProvider, createUseConnectionState, createUseSupalive };
+
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,EAAE;AACF,mBAAmB;AACnB,EAAE;AACF,aAAa;AACb,6BAA6B;AAC7B,8BAA8B;AAC9B,yBAAyB;AACzB,gCAAgC;AAChC,uBAAuB;AACvB,mBAAmB;AACnB,sBAAsB;AACtB,oBAAoB;AACpB,8BAA8B;AAC9B,EAAE;AACF,yDAAyD;AACzD,EAAE;AACF,0EAA0E;AAC1E,qEAAqE;AACrE,6EAA6E;AAC7E,mEAAmE;AACnE,+DAA+D;AAC/D,kEAAkE;AAClE,gEAAgE;AAEhE,OAAO,EAAE,qBAAqB,EAAwB,MAAM,WAAW,CAAC;AACxE,OAAO,EACL,sBAAsB,GAEvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/context.ts","../../src/provider.tsx","../../src/use_supalive.ts","../../src/use_connection_state.ts","../../src/create_live_query.ts","../../src/create_query.ts","../../src/create_mutation.ts","../../src/create_action.ts"],"sourcesContent":["import { createContext, useContext, type Context } from \"react\";\n\n/**\n * The React context object that carries the typed client. Userland creates\n * one of these per app, then passes it to every hook factory so they all\n * agree on the same `TClient`.\n */\nexport type SupaliveContext<TClient> = Context<TClient | null>;\n\nexport function createSupaliveContext<TClient>(): SupaliveContext<TClient> {\n  return createContext<TClient | null>(null);\n}\n\nexport function useContextOrThrow<TClient>(ctx: SupaliveContext<TClient>): TClient {\n  const value = useContext(ctx);\n  if (value === null) {\n    throw new Error(\n      \"Supalive: no client found in React context. Wrap your app in <SupaliveProvider>.\",\n    );\n  }\n  return value;\n}\n","import { useEffect, useRef, type ReactNode } from \"react\";\nimport type { SupaliveContext } from \"./context\";\n\n/**\n * Minimal shape we need from any client passed through this provider. Both\n * `createClient`'s output (which has `WSClientMethods`) and a hand-rolled\n * client satisfy it, so the provider stays generic.\n */\ninterface SupaliveLifecycleClient {\n  connect(): Promise<void>;\n  disconnect(): void;\n}\n\nexport interface SupaliveProviderProps<TClient> {\n  /**\n   * Either a factory (built each mount, lazy) or a pre-built client. A\n   * factory matches the Convex pattern of letting the provider own the\n   * client's lifetime; passing a pre-built client lets you share it with\n   * non-React callers (SSR, scripts).\n   */\n  client: TClient | (() => TClient);\n  children: ReactNode;\n}\n\n/**\n * Build a typed `<SupaliveProvider>` for a given `TClient`. Pass the same\n * context object to every other hook factory so they share the client.\n *\n * StrictMode-safe: the client lives on a ref and is never recreated. The\n * cleanup schedules `disconnect()` through a 250 ms timer parked on a ref,\n * so a synchronous re-mount (as StrictMode does in dev) cancels it before\n * the socket is torn down. A real unmount lets the timer fire.\n */\nexport function createSupaliveProvider<TClient extends SupaliveLifecycleClient>(\n  ctx: SupaliveContext<TClient>,\n) {\n  return function SupaliveProvider({\n    client,\n    children,\n  }: SupaliveProviderProps<TClient>) {\n    const clientRef = useRef<TClient | null>(null);\n    const disconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n    if (!clientRef.current) {\n      clientRef.current = typeof client === \"function\" ? (client as () => TClient)() : client;\n    }\n\n    useEffect(() => {\n      // A pending disconnect from a prior cleanup (StrictMode) — cancel it\n      // before we'd start a redundant reconnect.\n      if (disconnectTimerRef.current) {\n        clearTimeout(disconnectTimerRef.current);\n        disconnectTimerRef.current = null;\n      }\n\n      const c = clientRef.current!;\n      void c.connect().catch((err: unknown) => {\n        console.error(\"[Supalive] connect failed:\", err);\n      });\n\n      return () => {\n        disconnectTimerRef.current = setTimeout(() => {\n          disconnectTimerRef.current = null;\n          c.disconnect();\n        }, 250);\n      };\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, []);\n\n    return <ctx.Provider value={clientRef.current}>{children}</ctx.Provider>;\n  };\n}\n","import type { SupaliveContext } from \"./context\";\nimport { useContextOrThrow } from \"./context\";\n\n/**\n * Returns a `useSupalive` hook that yields the typed client. Use this when\n * you need to call procedures imperatively (outside the standard query/\n * mutation hooks), e.g. inside an event handler that doesn't fit one of\n * the higher-level helpers.\n */\nexport function createUseSupalive<TClient>(ctx: SupaliveContext<TClient>) {\n  return function useSupalive(): TClient {\n    return useContextOrThrow(ctx);\n  };\n}\n","import { useSyncExternalStore } from \"react\";\nimport type { ClientPublicState } from \"@supalive/core/client\";\nimport type { SupaliveContext } from \"./context\";\nimport { useContextOrThrow } from \"./context\";\n\n/**\n * Shape of any client that surfaces the WS connection state. Both the\n * generated `createClient` proxy and a hand-rolled client satisfy it.\n */\ninterface ClientWithState {\n  onState(listener: (s: ClientPublicState) => void): () => void;\n  getPublicState(): ClientPublicState;\n}\n\n/**\n * Returns a `useSupaliveConnectionState` hook for showing connection\n * banners (\"Reconnecting…\", \"Offline\", etc.) without having to subscribe\n * to the client manually.\n */\nexport function createUseConnectionState<TClient extends ClientWithState>(\n  ctx: SupaliveContext<TClient>,\n) {\n  return function useSupaliveConnectionState(): ClientPublicState {\n    const client = useContextOrThrow(ctx);\n    return useSyncExternalStore(\n      (cb) => client.onState(() => cb()),\n      () => client.getPublicState(),\n      () => client.getPublicState(),\n    );\n  };\n}\n","import { useCallback, useMemo, useRef, useSyncExternalStore } from \"react\";\nimport type { LiveQueryHandle } from \"@supalive/core/client\";\nimport type { SupaliveContext } from \"./context\";\nimport { useContextOrThrow } from \"./context\";\nimport type {\n  LiveQueryResult,\n  ProcedureSelector,\n  QueryProcedureLike,\n} from \"./types\";\nimport { stableStringify } from \"@supalive/core/types\";\n\n/**\n * Returns a typed `useLiveQuery` hook bound to a specific client type.\n *\n * Userland:\n *   const useLiveQuery = createLiveQuery<SupaliveClient>(SupaliveCtx);\n *   const { data, status, error } = useLiveQuery(c => c.listItems, { limit: 50 });\n *\n * Internals (modelled on Convex's `useQuery` + `useSubscription`, but\n * using React 18's native `useSyncExternalStore` instead of the legacy\n * shim Convex still bundles):\n *\n *   - Selector is fired synchronously to get the procedure object; the\n *     procedure's `liveQuery(input)` returns a shared `LiveQueryHandle`\n *     (ref-counted in the client) so multiple components reading the same\n *     query share one server-side subscription.\n *   - `useSyncExternalStore(handle.onState, handle.getState)` gives a\n *     tearing-free, concurrent-safe render path.\n *   - Re-subscription is keyed off `stableStringify(input)` so an inline\n *     object literal that produces the same values doesn't churn handles.\n *\n * Define selectors at module scope (or with `useCallback`) so the reference\n * is stable across renders; this isn't required for correctness, but it\n * keeps the `useMemo` cheap.\n */\nexport function createLiveQuery<TClient>(ctx: SupaliveContext<TClient>) {\n  return function useLiveQuery<TInput, TOutput>(\n    selector: ProcedureSelector<TClient, QueryProcedureLike<TInput, TOutput>>,\n    input: TInput,\n  ): LiveQueryResult<TOutput> {\n    const client = useContextOrThrow(ctx);\n\n    // Keep the latest selector in a ref. We don't include it in the\n    // memo deps because selectors are usually inline arrow functions;\n    // we re-read it on every render but only re-acquire the handle\n    // when the *input key* changes (or the client identity changes).\n    const selectorRef = useRef(selector);\n    selectorRef.current = selector;\n\n    const serializedInput = stableStringify(input);\n    const handle: LiveQueryHandle<TOutput> = useMemo(\n      () => selectorRef.current(client).liveQuery(input, serializedInput),\n      [client, serializedInput],\n    );\n\n    const state = useSyncExternalStore(\n      handle.onState,\n      handle.getState,\n      handle.getState,\n    );\n\n    const refetch = useCallback(() => handle.refetch(), [handle]);\n\n    return {\n      data: state.data,\n      status: state.status,\n      error: state.error,\n      refetch,\n    };\n  };\n}\n","import { useCallback, useEffect, useRef, useState } from \"react\";\nimport type { SupaliveContext } from \"./context\";\nimport { useContextOrThrow } from \"./context\";\nimport type {\n  ProcedureSelector,\n  QueryProcedureLike,\n  QueryResult,\n  QueryStatus,\n} from \"./types\";\nimport { stableStringify } from \"@supalive/core/types\";\n\n/**\n * One-shot query (no live updates). Re-runs when the serialised input\n * changes. `refetch()` re-issues the same query immediately.\n *\n *   const { data, status, error, refetch } = useQuery(c => c.getItem, { id });\n */\nexport function createQuery<TClient>(ctx: SupaliveContext<TClient>) {\n  return function useQuery<TInput, TOutput>(\n    selector: ProcedureSelector<TClient, QueryProcedureLike<TInput, TOutput>>,\n    input: TInput,\n  ): QueryResult<TOutput> {\n    const client = useContextOrThrow(ctx);\n\n    const selectorRef = useRef(selector);\n    selectorRef.current = selector;\n\n    const [data, setData] = useState<TOutput | undefined>();\n    const [status, setStatus] = useState<QueryStatus>(\"idle\");\n    const [error, setError] = useState<Error | null>(null);\n    const [tick, setTick] = useState(0);\n    const serializedInput = stableStringify(input);\n\n    useEffect(() => {\n      let cancelled = false;\n      setStatus(\"loading\");\n      setError(null);\n\n      selectorRef.current(client)\n        .query(input)\n        .then((result) => {\n          if (cancelled) return;\n          setData(result);\n          setStatus(\"success\");\n        })\n        .catch((err: unknown) => {\n          if (cancelled) return;\n          setError(err instanceof Error ? err : new Error(String(err)));\n          setStatus(\"error\");\n        });\n\n      return () => {\n        cancelled = true;\n      };\n    }, [client, serializedInput, tick]);\n\n    const refetch = useCallback(() => setTick((t) => t + 1), []);\n\n    return { data, status, error, refetch };\n  };\n}\n","import { useCallback, useRef, useState } from \"react\";\nimport type { SupaliveContext } from \"./context\";\nimport { useContextOrThrow } from \"./context\";\nimport type {\n  MutationProcedureLike,\n  MutationState,\n  MutationStatus,\n  ProcedureSelector,\n} from \"./types\";\n\n/**\n * Typed mutation hook factory.\n *\n *   const [createItem, { status, error, data, reset }] =\n *     useMutation(c => c.createItem);\n *\n * Statuses:\n *   - \"idle\"    — initial state, or after `reset()`\n *   - \"queued\"  — call has been queued because the client wasn't ready\n *                 (offline, reconnecting, mid-handshake); we use the\n *                 transport's `onSend` callback to flip to \"loading\" once\n *                 the request actually leaves the wire\n *   - \"loading\" — request is on the wire, awaiting response\n *   - \"success\" — server returned success\n *   - \"error\"   — server returned an error or the call rejected\n */\nexport function createMutation<TClient>(ctx: SupaliveContext<TClient>) {\n  return function useMutation<TInput, TOutput>(\n    selector: ProcedureSelector<TClient, MutationProcedureLike<TInput, TOutput>>,\n  ): [\n    (input: TInput) => Promise<TOutput>,\n    MutationState<TOutput>,\n  ] {\n    const client = useContextOrThrow(ctx);\n\n    const selectorRef = useRef(selector);\n    selectorRef.current = selector;\n\n    const [data, setData] = useState<TOutput | undefined>(undefined);\n    const [status, setStatus] = useState<MutationStatus>(\"idle\");\n    const [error, setError] = useState<Error | null>(null);\n\n    const reset = useCallback(() => {\n      setData(undefined);\n      setStatus(\"idle\");\n      setError(null);\n    }, []);\n\n    const mutate = useCallback(\n      async (input: TInput): Promise<TOutput> => {\n        setError(null);\n        setData(undefined);\n        // We optimistically assume the transport will queue if not ready,\n        // and the transport's `onSend` will flip us to \"loading\".\n        setStatus(\"queued\");\n        let sent = false;\n        try {\n          const result = await selectorRef.current(client).mutate(input, {\n            onSend: () => {\n              sent = true;\n              setStatus(\"loading\");\n            },\n          });\n          // If the call was queued and dispatched in one tick, onSend may\n          // have fired before this line — `sent` reflects that. Either way\n          // we end up at \"success\".\n          setData(result);\n          setStatus(\"success\");\n          return result;\n        } catch (err: unknown) {\n          const e = err instanceof Error ? err : new Error(String(err));\n          setError(e);\n          setStatus(\"error\");\n          void sent;\n          throw e;\n        }\n      },\n      [client],\n    );\n\n    return [mutate, { data, status, error, reset }];\n  };\n}\n","import { useCallback, useRef, useState } from \"react\";\nimport type { SupaliveContext } from \"./context\";\nimport { useContextOrThrow } from \"./context\";\nimport type {\n  ActionProcedureLike,\n  ActionState,\n  MutationStatus,\n  ProcedureSelector,\n} from \"./types\";\n\n/**\n * Typed action hook factory. Same shape as `useMutation` — actions in\n * Supalive have the same client-side semantics (single-call, response,\n * may be queued during disconnect).\n *\n *   const [bulkUpdate, { status }] = useAction(c => c.bulkUpdateItems);\n */\nexport function createAction<TClient>(ctx: SupaliveContext<TClient>) {\n  return function useAction<TInput, TOutput>(\n    selector: ProcedureSelector<TClient, ActionProcedureLike<TInput, TOutput>>,\n  ): [\n    (input: TInput) => Promise<TOutput>,\n    ActionState<TOutput>,\n  ] {\n    const client = useContextOrThrow(ctx);\n\n    const selectorRef = useRef(selector);\n    selectorRef.current = selector;\n\n    const [data, setData] = useState<TOutput | undefined>(undefined);\n    const [status, setStatus] = useState<MutationStatus>(\"idle\");\n    const [error, setError] = useState<Error | null>(null);\n\n    const reset = useCallback(() => {\n      setData(undefined);\n      setStatus(\"idle\");\n      setError(null);\n    }, []);\n\n    const run = useCallback(\n      async (input: TInput): Promise<TOutput> => {\n        setError(null);\n        setData(undefined);\n        setStatus(\"queued\");\n        try {\n          const result = await selectorRef.current(client).action(input, {\n            onSend: () => setStatus(\"loading\"),\n          });\n          setData(result);\n          setStatus(\"success\");\n          return result;\n        } catch (err: unknown) {\n          const e = err instanceof Error ? err : new Error(String(err));\n          setError(e);\n          setStatus(\"error\");\n          throw e;\n        }\n      },\n      [client],\n    );\n\n    return [run, { data, status, error, reset }];\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supalive/react",
-  "version": "0.1.1",
+  "version": "0.1.6",
   "type": "module",
   "description": "React bindings for supalive",
   "license": "MIT",
@@ -19,13 +19,18 @@
       "default": "./dist/src/index.js"
     }
   },
-  "files": ["dist", "README.md"],
-  "publishConfig": { "access": "public" },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "tsc -p ."
+    "build": "tsdown"
   },
   "dependencies": {
-    "@supalive/core": "^0.1.4"
+    "@supalive/core": "workspace:*"
   },
   "peerDependencies": {
     "react": ">=18.0.0"

package/dist/src/context.d.ts

@@ -1,10 +0,0 @@
-import { type Context } from "react";
-/**
- * The React context object that carries the typed client. Userland creates
- * one of these per app, then passes it to every hook factory so they all
- * agree on the same `TClient`.
- */
-export type SupaliveContext<TClient> = Context<TClient | null>;
-export declare function createSupaliveContext<TClient>(): SupaliveContext<TClient>;
-export declare function useContextOrThrow<TClient>(ctx: SupaliveContext<TClient>): TClient;
-//# sourceMappingURL=context.d.ts.map

package/dist/src/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhE;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,OAAO,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;AAE/D,wBAAgB,qBAAqB,CAAC,OAAO,KAAK,eAAe,CAAC,OAAO,CAAC,CAEzE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,OAAO,CAQjF"}

package/dist/src/context.js

@@ -1,12 +0,0 @@
-import { createContext, useContext } from "react";
-export function createSupaliveContext() {
-    return createContext(null);
-}
-export function useContextOrThrow(ctx) {
-    const value = useContext(ctx);
-    if (value === null) {
-        throw new Error("Supalive: no client found in React context. Wrap your app in <SupaliveProvider>.");
-    }
-    return value;
-}
-//# sourceMappingURL=context.js.map

package/dist/src/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,OAAO,CAAC;AAShE,MAAM,UAAU,qBAAqB;IACnC,OAAO,aAAa,CAAiB,IAAI,CAAC,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAU,GAA6B;IACtE,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CACb,kFAAkF,CACnF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/create_action.d.ts

@@ -1,11 +0,0 @@
-import type { SupaliveContext } from "./context";
-import type { ActionProcedureLike, ActionState, ProcedureSelector } from "./types";
-/**
- * Typed action hook factory. Same shape as `useMutation` — actions in
- * Supalive have the same client-side semantics (single-call, response,
- * may be queued during disconnect).
- *
- *   const [bulkUpdate, { status }] = useAction(c => c.bulkUpdateItems);
- */
-export declare function createAction<TClient>(ctx: SupaliveContext<TClient>): <TInput, TOutput>(selector: ProcedureSelector<TClient, ActionProcedureLike<TInput, TOutput>>) => [(input: TInput) => Promise<TOutput>, ActionState<TOutput>];
-//# sourceMappingURL=create_action.d.ts.map

package/dist/src/create_action.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create_action.d.ts","sourceRoot":"","sources":["../../src/create_action.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,KAAK,EACV,mBAAmB,EACnB,WAAW,EAEX,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,IACvC,MAAM,EAAE,OAAO,EACvC,UAAU,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KACzE,CACD,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,EACnC,WAAW,CAAC,OAAO,CAAC,CACrB,CAwCF"}