@velajs/react 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @velajs/react
+
+## 0.1.1
+
+### Patch Changes
+
+- 2419688: Modernize the package build, validation, and release toolchain.
+- Updated dependencies [2419688]
+  - @velajs/client@0.1.1

package/dist/index.d.ts

@@ -1,9 +1,78 @@
-export { LiveProvider, useLiveClient } from './context';
-export type { LiveProviderProps } from './context';
-export { useLiveQuery } from './use-live-query';
-export type { UseLiveQueryOptions } from './use-live-query';
-export { useLiveMutation } from './use-live-mutation';
-export type { UseLiveMutationResult } from './use-live-mutation';
-export { useConnectionStatus } from './use-connection-status';
-export { usePresence } from './use-presence';
-export type { UsePresenceOptions } from './use-presence';
+import { ReactNode, createElement } from "react";
+import { ArgsOf, ConnectionStatus, LiveClient, LiveContract, MutateOptions, ResultOf, SubscribeOptions } from "@velajs/client";
+import { PresenceMember } from "@velajs/client/presence";
+//#region src/context.d.ts
+interface LiveProviderProps {
+  client: LiveClient<LiveContract>;
+  children?: ReactNode;
+}
+/** Provides the LiveClient to the hook tree. `createElement`-based — no JSX toolchain required. */
+declare function LiveProvider(props: LiveProviderProps): ReturnType<typeof createElement>;
+declare function useLiveClient<C extends LiveContract = LiveContract>(): LiveClient<C>;
+//#endregion
+//#region src/use-live-query.d.ts
+interface UseLiveQueryOptions extends SubscribeOptions {
+  /** Render without subscribing (conditional queries). */
+  skip?: boolean;
+}
+/**
+ * Subscribe to a live query. Returns `undefined` until the first
+ * snapshot/hydrated value, then re-renders on every server push. Built on
+ * `useSyncExternalStore` — the client guarantees referentially stable
+ * snapshots between notifications, so there is no tearing and no external
+ * cache library.
+ *
+ * ```tsx
+ * const todos = useLiveQuery('todos.list', { listId }) ?? [];
+ * ```
+ */
+declare function useLiveQuery<C extends LiveContract, Q extends keyof C & string>(query: Q, args: ArgsOf<C, Q>, options?: UseLiveQueryOptions): ResultOf<C, Q> | undefined;
+//#endregion
+//#region src/use-live-mutation.d.ts
+interface UseLiveMutationResult<R> {
+  /** Fire the mutation. Per-call options (optimistic targets, method, …) merge over the hook defaults. */
+  mutate: (body?: unknown, options?: MutateOptions) => Promise<R>;
+  pending: boolean;
+  data: R | undefined;
+  error: unknown;
+  reset: () => void;
+}
+/**
+ * HTTP mutation hook with live-aware optimistic updates:
+ *
+ * ```tsx
+ * const { mutate: addTodo, pending } = useLiveMutation('/todos', {
+ *   optimistic: { query: 'todos.list', args: { listId }, apply: (t = []) => [...t, temp] },
+ * });
+ * ```
+ *
+ * The optimistic layer is dropped exactly when a live frame's cursor passes
+ * the mutation's `Vela-Commit-Cursor` (see @velajs/client); failures roll it
+ * back and reject.
+ */
+declare function useLiveMutation<R = unknown>(path: string, defaults?: MutateOptions): UseLiveMutationResult<R>;
+//#endregion
+//#region src/use-connection-status.d.ts
+/** The client's aggregate connection status, live. */
+declare function useConnectionStatus(): ConnectionStatus;
+//#endregion
+//#region src/use-presence.d.ts
+interface UsePresenceOptions {
+  /** Payload attached to this connection's roster entry (latest render's value rides each beat). */
+  meta?: unknown;
+  /** Keep well under the server TTL (default 10 000 ms vs 30 000 ms). */
+  heartbeatIntervalMs?: number;
+}
+/**
+ * Join a room's presence and observe its roster. Heartbeats ride the room's
+ * live socket; departure is immediate on close; a tab regaining visibility
+ * beats right away so the roster recovers from a throttled background timer.
+ *
+ * ```tsx
+ * const people = usePresence(roomId, { meta: { name: user.name } });
+ * ```
+ */
+declare function usePresence(room: string, options?: UsePresenceOptions): PresenceMember[];
+//#endregion
+export { LiveProvider, type LiveProviderProps, type UseLiveMutationResult, type UseLiveQueryOptions, type UsePresenceOptions, useConnectionStatus, useLiveClient, useLiveMutation, useLiveQuery, usePresence };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,161 @@
-export { LiveProvider, useLiveClient } from "./context.js";
-export { useLiveQuery } from "./use-live-query.js";
-export { useLiveMutation } from "./use-live-mutation.js";
-export { useConnectionStatus } from "./use-connection-status.js";
-export { usePresence } from "./use-presence.js";
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { argsKeyOf } from "@velajs/client";
+import { createPresence } from "@velajs/client/presence";
+//#region src/context.ts
+const LiveClientContext = createContext(null);
+/** Provides the LiveClient to the hook tree. `createElement`-based — no JSX toolchain required. */
+function LiveProvider(props) {
+	return createElement(LiveClientContext.Provider, { value: props.client }, props.children);
+}
+function useLiveClient() {
+	const client = useContext(LiveClientContext);
+	if (!client) throw new Error("useLiveClient: no LiveClient in context — wrap the tree in <LiveProvider client={…}>.");
+	return client;
+}
+//#endregion
+//#region src/use-live-query.ts
+/**
+* Subscribe to a live query. Returns `undefined` until the first
+* snapshot/hydrated value, then re-renders on every server push. Built on
+* `useSyncExternalStore` — the client guarantees referentially stable
+* snapshots between notifications, so there is no tearing and no external
+* cache library.
+*
+* ```tsx
+* const todos = useLiveQuery('todos.list', { listId }) ?? [];
+* ```
+*/
+function useLiveQuery(query, args, options) {
+	const client = useLiveClient();
+	const argsKey = useMemo(() => argsKeyOf(args), [args]);
+	const { room, key, skip, onError } = options ?? {};
+	const subscribe = useCallback((onStoreChange) => {
+		if (skip) return () => {};
+		return client.subscribe(query, args, () => onStoreChange(), {
+			room,
+			key,
+			onError
+		});
+	}, [
+		client,
+		query,
+		argsKey,
+		room,
+		key,
+		skip
+	]);
+	const getSnapshot = useCallback(() => skip ? void 0 : client.peek(query, args, room), [
+		client,
+		query,
+		argsKey,
+		room,
+		skip
+	]);
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+//#endregion
+//#region src/use-live-mutation.ts
+/**
+* HTTP mutation hook with live-aware optimistic updates:
+*
+* ```tsx
+* const { mutate: addTodo, pending } = useLiveMutation('/todos', {
+*   optimistic: { query: 'todos.list', args: { listId }, apply: (t = []) => [...t, temp] },
+* });
+* ```
+*
+* The optimistic layer is dropped exactly when a live frame's cursor passes
+* the mutation's `Vela-Commit-Cursor` (see @velajs/client); failures roll it
+* back and reject.
+*/
+function useLiveMutation(path, defaults) {
+	const client = useLiveClient();
+	const [state, setState] = useState({ pending: 0 });
+	const defaultsRef = useRef(defaults);
+	defaultsRef.current = defaults;
+	return {
+		mutate: useCallback(async (body, options) => {
+			setState((current) => ({
+				...current,
+				pending: current.pending + 1
+			}));
+			try {
+				const data = await client.mutate(path, body, {
+					...defaultsRef.current,
+					...options
+				});
+				setState((current) => ({
+					pending: current.pending - 1,
+					data,
+					error: void 0
+				}));
+				return data;
+			} catch (error) {
+				setState((current) => ({
+					...current,
+					pending: current.pending - 1,
+					error
+				}));
+				throw error;
+			}
+		}, [client, path]),
+		pending: state.pending > 0,
+		data: state.data,
+		error: state.error,
+		reset: useCallback(() => setState({ pending: 0 }), [])
+	};
+}
+//#endregion
+//#region src/use-connection-status.ts
+/** The client's aggregate connection status, live. */
+function useConnectionStatus() {
+	const client = useLiveClient();
+	const subscribe = useCallback((onStoreChange) => client.onConnectionStatus(() => onStoreChange()), [client]);
+	const getSnapshot = useCallback(() => client.connectionStatus(), [client]);
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+//#endregion
+//#region src/use-presence.ts
+/**
+* Join a room's presence and observe its roster. Heartbeats ride the room's
+* live socket; departure is immediate on close; a tab regaining visibility
+* beats right away so the roster recovers from a throttled background timer.
+*
+* ```tsx
+* const people = usePresence(roomId, { meta: { name: user.name } });
+* ```
+*/
+function usePresence(room, options) {
+	const client = useLiveClient();
+	const [members, setMembers] = useState([]);
+	const metaRef = useRef(options?.meta);
+	metaRef.current = options?.meta;
+	const heartbeatIntervalMs = options?.heartbeatIntervalMs;
+	useEffect(() => {
+		const handle = createPresence(client, {
+			room,
+			meta: () => metaRef.current,
+			heartbeatIntervalMs,
+			onRoster: setMembers
+		});
+		const doc = globalThis.document;
+		const onVisibility = () => {
+			if (doc?.visibilityState === "visible") handle.beat();
+		};
+		doc?.addEventListener?.("visibilitychange", onVisibility);
+		return () => {
+			doc?.removeEventListener?.("visibilitychange", onVisibility);
+			handle.stop();
+			setMembers([]);
+		};
+	}, [
+		client,
+		room,
+		heartbeatIntervalMs
+	]);
+	return members;
+}
+//#endregion
+export { LiveProvider, useConnectionStatus, useLiveClient, useLiveMutation, useLiveQuery, usePresence };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/context.ts","../src/use-live-query.ts","../src/use-live-mutation.ts","../src/use-connection-status.ts","../src/use-presence.ts"],"sourcesContent":["import { createContext, createElement, useContext } from 'react';\nimport type { ReactNode } from 'react';\nimport type { LiveClient } from '@velajs/client';\nimport type { LiveContract } from '@velajs/client';\n\n// Deliberately `any`-typed inside the context: the contract generic is\n// re-applied at the useLiveClient() boundary. One provider serves any app.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst LiveClientContext = createContext<LiveClient<any> | null>(null);\n\nexport interface LiveProviderProps {\n  client: LiveClient<LiveContract>;\n  children?: ReactNode;\n}\n\n/** Provides the LiveClient to the hook tree. `createElement`-based — no JSX toolchain required. */\nexport function LiveProvider(props: LiveProviderProps): ReturnType<typeof createElement> {\n  return createElement(LiveClientContext.Provider, { value: props.client }, props.children);\n}\n\nexport function useLiveClient<C extends LiveContract = LiveContract>(): LiveClient<C> {\n  const client = useContext(LiveClientContext);\n  if (!client) {\n    throw new Error(\n      'useLiveClient: no LiveClient in context — wrap the tree in <LiveProvider client={…}>.',\n    );\n  }\n  return client as LiveClient<C>;\n}\n","import { useCallback, useMemo, useSyncExternalStore } from 'react';\nimport { argsKeyOf } from '@velajs/client';\nimport type { ArgsOf, LiveContract, ResultOf, SubscribeOptions } from '@velajs/client';\nimport { useLiveClient } from './context';\n\nexport interface UseLiveQueryOptions extends SubscribeOptions {\n  /** Render without subscribing (conditional queries). */\n  skip?: boolean;\n}\n\n/**\n * Subscribe to a live query. Returns `undefined` until the first\n * snapshot/hydrated value, then re-renders on every server push. Built on\n * `useSyncExternalStore` — the client guarantees referentially stable\n * snapshots between notifications, so there is no tearing and no external\n * cache library.\n *\n * ```tsx\n * const todos = useLiveQuery('todos.list', { listId }) ?? [];\n * ```\n */\nexport function useLiveQuery<C extends LiveContract, Q extends keyof C & string>(\n  query: Q,\n  args: ArgsOf<C, Q>,\n  options?: UseLiveQueryOptions,\n): ResultOf<C, Q> | undefined {\n  const client = useLiveClient<C>();\n  // Stable identity for the deps array — callers pass fresh object literals.\n  const argsKey = useMemo(() => argsKeyOf(args), [args]);\n  const { room, key, skip, onError } = options ?? {};\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      if (skip) return () => {};\n      return client.subscribe(query, args, () => onStoreChange(), { room, key, onError });\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- argsKey stands in for args; onError is deliberately unbound\n    [client, query, argsKey, room, key, skip],\n  );\n\n  const getSnapshot = useCallback(\n    () => (skip ? undefined : client.peek(query, args, room)),\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- argsKey stands in for args\n    [client, query, argsKey, room, skip],\n  );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n","import { useCallback, useRef, useState } from 'react';\nimport type { MutateOptions } from '@velajs/client';\nimport { useLiveClient } from './context';\n\nexport interface UseLiveMutationResult<R> {\n  /** Fire the mutation. Per-call options (optimistic targets, method, …) merge over the hook defaults. */\n  mutate: (body?: unknown, options?: MutateOptions) => Promise<R>;\n  pending: boolean;\n  data: R | undefined;\n  error: unknown;\n  reset: () => void;\n}\n\n/**\n * HTTP mutation hook with live-aware optimistic updates:\n *\n * ```tsx\n * const { mutate: addTodo, pending } = useLiveMutation('/todos', {\n *   optimistic: { query: 'todos.list', args: { listId }, apply: (t = []) => [...t, temp] },\n * });\n * ```\n *\n * The optimistic layer is dropped exactly when a live frame's cursor passes\n * the mutation's `Vela-Commit-Cursor` (see @velajs/client); failures roll it\n * back and reject.\n */\nexport function useLiveMutation<R = unknown>(\n  path: string,\n  defaults?: MutateOptions,\n): UseLiveMutationResult<R> {\n  const client = useLiveClient();\n  const [state, setState] = useState<{ pending: number; data?: R; error?: unknown }>({\n    pending: 0,\n  });\n  const defaultsRef = useRef(defaults);\n  defaultsRef.current = defaults;\n\n  const mutate = useCallback(\n    async (body?: unknown, options?: MutateOptions): Promise<R> => {\n      setState((current) => ({ ...current, pending: current.pending + 1 }));\n      try {\n        const data = await client.mutate<R>(path, body, { ...defaultsRef.current, ...options });\n        setState((current) => ({ pending: current.pending - 1, data, error: undefined }));\n        return data;\n      } catch (error) {\n        setState((current) => ({ ...current, pending: current.pending - 1, error }));\n        throw error;\n      }\n    },\n    [client, path],\n  );\n\n  return {\n    mutate,\n    pending: state.pending > 0,\n    data: state.data,\n    error: state.error,\n    reset: useCallback(() => setState({ pending: 0 }), []),\n  };\n}\n","import { useCallback, useSyncExternalStore } from 'react';\nimport type { ConnectionStatus } from '@velajs/client';\nimport { useLiveClient } from './context';\n\n/** The client's aggregate connection status, live. */\nexport function useConnectionStatus(): ConnectionStatus {\n  const client = useLiveClient();\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => client.onConnectionStatus(() => onStoreChange()),\n    [client],\n  );\n  const getSnapshot = useCallback(() => client.connectionStatus(), [client]);\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n","import { useEffect, useRef, useState } from 'react';\nimport { createPresence } from '@velajs/client/presence';\nimport type { PresenceMember } from '@velajs/client/presence';\nimport { useLiveClient } from './context';\n\nexport interface UsePresenceOptions {\n  /** Payload attached to this connection's roster entry (latest render's value rides each beat). */\n  meta?: unknown;\n  /** Keep well under the server TTL (default 10 000 ms vs 30 000 ms). */\n  heartbeatIntervalMs?: number;\n}\n\n/**\n * Join a room's presence and observe its roster. Heartbeats ride the room's\n * live socket; departure is immediate on close; a tab regaining visibility\n * beats right away so the roster recovers from a throttled background timer.\n *\n * ```tsx\n * const people = usePresence(roomId, { meta: { name: user.name } });\n * ```\n */\nexport function usePresence(room: string, options?: UsePresenceOptions): PresenceMember[] {\n  const client = useLiveClient();\n  const [members, setMembers] = useState<PresenceMember[]>([]);\n  const metaRef = useRef(options?.meta);\n  metaRef.current = options?.meta;\n  const heartbeatIntervalMs = options?.heartbeatIntervalMs;\n\n  useEffect(() => {\n    const handle = createPresence(client, {\n      room,\n      meta: () => metaRef.current,\n      heartbeatIntervalMs,\n      onRoster: setMembers,\n    });\n\n    const doc = (globalThis as { document?: Document }).document;\n    const onVisibility = (): void => {\n      if (doc?.visibilityState === 'visible') handle.beat();\n    };\n    doc?.addEventListener?.('visibilitychange', onVisibility);\n\n    return () => {\n      doc?.removeEventListener?.('visibilitychange', onVisibility);\n      handle.stop();\n      setMembers([]);\n    };\n  }, [client, room, heartbeatIntervalMs]);\n\n  return members;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,65 +1,65 @@
 {
   "name": "@velajs/react",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "React hooks for Vela live queries: useLiveQuery, useLiveMutation, usePresence, useConnectionStatus on useSyncExternalStore",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
-  ],
-  "sideEffects": false,
   "keywords": [
-    "vela",
-    "react",
     "hooks",
     "live-queries",
+    "optimistic-updates",
+    "react",
     "realtime",
-    "optimistic-updates"
+    "vela"
   ],
-  "author": "ksh",
+  "homepage": "https://github.com/velajs/client#readme",
+  "bugs": {
+    "url": "https://github.com/velajs/client/issues"
+  },
   "license": "MIT",
+  "author": "ksh",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velajs/client.git",
     "directory": "packages/react"
   },
-  "homepage": "https://github.com/velajs/client#readme",
-  "bugs": {
-    "url": "https://github.com/velajs/client/issues"
-  },
-  "engines": {
-    "node": ">=20"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "dependencies": {
-    "@velajs/client": "^0.1.0"
-  },
-  "peerDependencies": {
-    "react": ">=18"
+    "@velajs/client": "^0.1.1"
   },
   "devDependencies": {
-    "@swc/cli": "^0.8.1",
     "@swc/core": "^1.15.43",
     "@testing-library/react": "^16.3.0",
     "@types/react": "^19.0.0",
     "happy-dom": "^20.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "typescript": "^6.0.3",
+    "tsdown": "^0.22.4",
+    "typescript": "^7.0.2",
     "unplugin-swc": "^1.5.9",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "engines": {
+    "node": ">=24"
   },
   "scripts": {
-    "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "build": "tsdown",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"
   }

package/dist/context.d.ts

@@ -1,11 +0,0 @@
-import { createElement } from 'react';
-import type { ReactNode } from 'react';
-import type { LiveClient } from '@velajs/client';
-import type { LiveContract } from '@velajs/client';
-export interface LiveProviderProps {
-    client: LiveClient<LiveContract>;
-    children?: ReactNode;
-}
-/** Provides the LiveClient to the hook tree. `createElement`-based — no JSX toolchain required. */
-export declare function LiveProvider(props: LiveProviderProps): ReturnType<typeof createElement>;
-export declare function useLiveClient<C extends LiveContract = LiveContract>(): LiveClient<C>;

package/dist/context.js

@@ -1,17 +0,0 @@
-import { createContext, createElement, useContext } from "react";
-// Deliberately `any`-typed inside the context: the contract generic is
-// re-applied at the useLiveClient() boundary. One provider serves any app.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const LiveClientContext = createContext(null);
-/** Provides the LiveClient to the hook tree. `createElement`-based — no JSX toolchain required. */ export function LiveProvider(props) {
-    return createElement(LiveClientContext.Provider, {
-        value: props.client
-    }, props.children);
-}
-export function useLiveClient() {
-    const client = useContext(LiveClientContext);
-    if (!client) {
-        throw new Error('useLiveClient: no LiveClient in context — wrap the tree in <LiveProvider client={…}>.');
-    }
-    return client;
-}

package/dist/use-connection-status.d.ts

@@ -1,3 +0,0 @@
-import type { ConnectionStatus } from '@velajs/client';
-/** The client's aggregate connection status, live. */
-export declare function useConnectionStatus(): ConnectionStatus;

package/dist/use-connection-status.js

@@ -1,12 +0,0 @@
-import { useCallback, useSyncExternalStore } from "react";
-import { useLiveClient } from "./context.js";
-/** The client's aggregate connection status, live. */ export function useConnectionStatus() {
-    const client = useLiveClient();
-    const subscribe = useCallback((onStoreChange)=>client.onConnectionStatus(()=>onStoreChange()), [
-        client
-    ]);
-    const getSnapshot = useCallback(()=>client.connectionStatus(), [
-        client
-    ]);
-    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-}

package/dist/use-live-mutation.d.ts

@@ -1,23 +0,0 @@
-import type { MutateOptions } from '@velajs/client';
-export interface UseLiveMutationResult<R> {
-    /** Fire the mutation. Per-call options (optimistic targets, method, …) merge over the hook defaults. */
-    mutate: (body?: unknown, options?: MutateOptions) => Promise<R>;
-    pending: boolean;
-    data: R | undefined;
-    error: unknown;
-    reset: () => void;
-}
-/**
- * HTTP mutation hook with live-aware optimistic updates:
- *
- * ```tsx
- * const { mutate: addTodo, pending } = useLiveMutation('/todos', {
- *   optimistic: { query: 'todos.list', args: { listId }, apply: (t = []) => [...t, temp] },
- * });
- * ```
- *
- * The optimistic layer is dropped exactly when a live frame's cursor passes
- * the mutation's `Vela-Commit-Cursor` (see @velajs/client); failures roll it
- * back and reject.
- */
-export declare function useLiveMutation<R = unknown>(path: string, defaults?: MutateOptions): UseLiveMutationResult<R>;

package/dist/use-live-mutation.js

@@ -1,59 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-import { useLiveClient } from "./context.js";
-/**
- * HTTP mutation hook with live-aware optimistic updates:
- *
- * ```tsx
- * const { mutate: addTodo, pending } = useLiveMutation('/todos', {
- *   optimistic: { query: 'todos.list', args: { listId }, apply: (t = []) => [...t, temp] },
- * });
- * ```
- *
- * The optimistic layer is dropped exactly when a live frame's cursor passes
- * the mutation's `Vela-Commit-Cursor` (see @velajs/client); failures roll it
- * back and reject.
- */ export function useLiveMutation(path, defaults) {
-    const client = useLiveClient();
-    const [state, setState] = useState({
-        pending: 0
-    });
-    const defaultsRef = useRef(defaults);
-    defaultsRef.current = defaults;
-    const mutate = useCallback(async (body, options)=>{
-        setState((current)=>({
-                ...current,
-                pending: current.pending + 1
-            }));
-        try {
-            const data = await client.mutate(path, body, {
-                ...defaultsRef.current,
-                ...options
-            });
-            setState((current)=>({
-                    pending: current.pending - 1,
-                    data,
-                    error: undefined
-                }));
-            return data;
-        } catch (error) {
-            setState((current)=>({
-                    ...current,
-                    pending: current.pending - 1,
-                    error
-                }));
-            throw error;
-        }
-    }, [
-        client,
-        path
-    ]);
-    return {
-        mutate,
-        pending: state.pending > 0,
-        data: state.data,
-        error: state.error,
-        reset: useCallback(()=>setState({
-                pending: 0
-            }), [])
-    };
-}

package/dist/use-live-query.d.ts

@@ -1,17 +0,0 @@
-import type { ArgsOf, LiveContract, ResultOf, SubscribeOptions } from '@velajs/client';
-export interface UseLiveQueryOptions extends SubscribeOptions {
-    /** Render without subscribing (conditional queries). */
-    skip?: boolean;
-}
-/**
- * Subscribe to a live query. Returns `undefined` until the first
- * snapshot/hydrated value, then re-renders on every server push. Built on
- * `useSyncExternalStore` — the client guarantees referentially stable
- * snapshots between notifications, so there is no tearing and no external
- * cache library.
- *
- * ```tsx
- * const todos = useLiveQuery('todos.list', { listId }) ?? [];
- * ```
- */
-export declare function useLiveQuery<C extends LiveContract, Q extends keyof C & string>(query: Q, args: ArgsOf<C, Q>, options?: UseLiveQueryOptions): ResultOf<C, Q> | undefined;

package/dist/use-live-query.js

@@ -1,46 +0,0 @@
-import { useCallback, useMemo, useSyncExternalStore } from "react";
-import { argsKeyOf } from "@velajs/client";
-import { useLiveClient } from "./context.js";
-/**
- * Subscribe to a live query. Returns `undefined` until the first
- * snapshot/hydrated value, then re-renders on every server push. Built on
- * `useSyncExternalStore` — the client guarantees referentially stable
- * snapshots between notifications, so there is no tearing and no external
- * cache library.
- *
- * ```tsx
- * const todos = useLiveQuery('todos.list', { listId }) ?? [];
- * ```
- */ export function useLiveQuery(query, args, options) {
-    const client = useLiveClient();
-    // Stable identity for the deps array — callers pass fresh object literals.
-    const argsKey = useMemo(()=>argsKeyOf(args), [
-        args
-    ]);
-    const { room, key, skip, onError } = options ?? {};
-    const subscribe = useCallback((onStoreChange)=>{
-        if (skip) return ()=>{};
-        return client.subscribe(query, args, ()=>onStoreChange(), {
-            room,
-            key,
-            onError
-        });
-    }, // eslint-disable-next-line react-hooks/exhaustive-deps -- argsKey stands in for args; onError is deliberately unbound
-    [
-        client,
-        query,
-        argsKey,
-        room,
-        key,
-        skip
-    ]);
-    const getSnapshot = useCallback(()=>skip ? undefined : client.peek(query, args, room), // eslint-disable-next-line react-hooks/exhaustive-deps -- argsKey stands in for args
-    [
-        client,
-        query,
-        argsKey,
-        room,
-        skip
-    ]);
-    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-}

package/dist/use-presence.d.ts

@@ -1,17 +0,0 @@
-import type { PresenceMember } from '@velajs/client/presence';
-export interface UsePresenceOptions {
-    /** Payload attached to this connection's roster entry (latest render's value rides each beat). */
-    meta?: unknown;
-    /** Keep well under the server TTL (default 10 000 ms vs 30 000 ms). */
-    heartbeatIntervalMs?: number;
-}
-/**
- * Join a room's presence and observe its roster. Heartbeats ride the room's
- * live socket; departure is immediate on close; a tab regaining visibility
- * beats right away so the roster recovers from a throttled background timer.
- *
- * ```tsx
- * const people = usePresence(roomId, { meta: { name: user.name } });
- * ```
- */
-export declare function usePresence(room: string, options?: UsePresenceOptions): PresenceMember[];

package/dist/use-presence.js

@@ -1,41 +0,0 @@
-import { useEffect, useRef, useState } from "react";
-import { createPresence } from "@velajs/client/presence";
-import { useLiveClient } from "./context.js";
-/**
- * Join a room's presence and observe its roster. Heartbeats ride the room's
- * live socket; departure is immediate on close; a tab regaining visibility
- * beats right away so the roster recovers from a throttled background timer.
- *
- * ```tsx
- * const people = usePresence(roomId, { meta: { name: user.name } });
- * ```
- */ export function usePresence(room, options) {
-    const client = useLiveClient();
-    const [members, setMembers] = useState([]);
-    const metaRef = useRef(options?.meta);
-    metaRef.current = options?.meta;
-    const heartbeatIntervalMs = options?.heartbeatIntervalMs;
-    useEffect(()=>{
-        const handle = createPresence(client, {
-            room,
-            meta: ()=>metaRef.current,
-            heartbeatIntervalMs,
-            onRoster: setMembers
-        });
-        const doc = globalThis.document;
-        const onVisibility = ()=>{
-            if (doc?.visibilityState === 'visible') handle.beat();
-        };
-        doc?.addEventListener?.('visibilitychange', onVisibility);
-        return ()=>{
-            doc?.removeEventListener?.('visibilitychange', onVisibility);
-            handle.stop();
-            setMembers([]);
-        };
-    }, [
-        client,
-        room,
-        heartbeatIntervalMs
-    ]);
-    return members;
-}