@sylphx/lens-react 2.5.13 → 2.5.15

package/dist/index.d.ts

@@ -141,284 +141,4 @@ type TypedClient<TRouter extends RouterDef> = TRouter extends RouterDef<infer TR
 declare function createClient<TRouter extends RouterDef>(config: LensClientConfig | TypedClientConfig<{
 	router: TRouter;
 }>): TypedClient<TRouter>;
-import { LensClient } from "@sylphx/lens-client";
-import { ReactElement, ReactNode } from "react";
-interface LensProviderProps {
-	/** Lens client instance */
-	client: LensClient<any, any>;
-	/** Children */
-	children: ReactNode;
-}
-/**
-* Provides Lens client to component tree
-*
-* @example
-* ```tsx
-* import { createClient, http } from '@sylphx/lens-client';
-* import { LensProvider } from '@sylphx/lens-react';
-* import type { AppRouter } from './server';
-*
-* const client = createClient<AppRouter>({
-*   transport: http({ url: '/api' }),
-* });
-*
-* function App() {
-*   return (
-*     <LensProvider client={client}>
-*       <UserProfile />
-*     </LensProvider>
-*   );
-* }
-* ```
-*/
-declare function LensProvider({ client, children }: LensProviderProps): ReactElement;
-/**
-* Get Lens client from context
-*
-* @throws Error if used outside LensProvider
-*
-* @example
-* ```tsx
-* function UserProfile({ userId }: { userId: string }) {
-*   const client = useLensClient<AppRouter>();
-*   const { data } = useQuery(client.user.get({ id: userId }));
-*   return <h1>{data?.name}</h1>;
-* }
-* ```
-*/
-declare function useLensClient<TRouter = any>(): LensClient<any, any> & TRouter;
-import { LensClient as LensClient2, MutationResult, QueryResult as QueryResult2 } from "@sylphx/lens-client";
-import { DependencyList } from "react";
-/** Result of useQuery hook */
-interface UseQueryResult<T> {
-	/** Query data (null if loading or error) */
-	data: T | null;
-	/** Loading state */
-	loading: boolean;
-	/** Error state */
-	error: Error | null;
-	/** Refetch the query */
-	refetch: () => void;
-}
-/** Result of useMutation hook */
-interface UseMutationResult<
-	TInput,
-	TOutput
-> {
-	/** Execute the mutation */
-	mutate: (input: TInput) => Promise<MutationResult<TOutput>>;
-	/** Mutation is in progress */
-	loading: boolean;
-	/** Mutation error */
-	error: Error | null;
-	/** Last mutation result */
-	data: TOutput | null;
-	/** Reset mutation state */
-	reset: () => void;
-}
-/** Options for useQuery */
-interface UseQueryOptions<
-	TData = unknown,
-	TSelected = TData
-> {
-	/** Skip the query (don't execute) */
-	skip?: boolean;
-	/** Transform the query result */
-	select?: (data: TData) => TSelected;
-}
-/** Client type for callbacks */
-type Client = LensClient2<any, any>;
-/** Route selector - callback that returns a route function */
-type RouteSelector<
-	TParams,
-	TResult
-> = (client: Client) => ((params: TParams) => QueryResult2<TResult>) | null;
-/** Query accessor selector - callback that returns QueryResult */
-type QuerySelector<TResult> = (client: Client) => QueryResult2<TResult> | null | undefined;
-/** Mutation selector - callback that returns mutation function */
-type MutationSelector<
-	TInput,
-	TOutput
-> = (client: Client) => (input: TInput) => Promise<MutationResult<TOutput>>;
-/**
-* Subscribe to a query with reactive updates.
-* Client is automatically injected from LensProvider context.
-*
-* Two usage patterns:
-*
-* **1. Route + Params (recommended)** - Stable references, no infinite loops
-* ```tsx
-* const { data } = useQuery((client) => client.user.get, { id: userId });
-* ```
-*
-* **2. Accessor + Deps (escape hatch)** - For complex/composed queries
-* ```tsx
-* const { data } = useQuery((client) => client.user.get({ id }), [id]);
-* ```
-*
-* @example
-* ```tsx
-* // Basic usage - Route + Params
-* function UserProfile({ userId }: { userId: string }) {
-*   const { data: user, loading, error } = useQuery(
-*     (client) => client.user.get,
-*     { id: userId }
-*   );
-*
-*   if (loading) return <Spinner />;
-*   if (error) return <Error message={error.message} />;
-*   return <h1>{user?.name}</h1>;
-* }
-*
-* // With select transform
-* function UserName({ userId }: { userId: string }) {
-*   const { data: name } = useQuery(
-*     (client) => client.user.get,
-*     { id: userId },
-*     { select: (user) => user.name }
-*   );
-*   return <span>{name}</span>;
-* }
-*
-* // Conditional query (return null to skip)
-* function SessionInfo({ sessionId }: { sessionId: string | null }) {
-*   const { data } = useQuery(
-*     (client) => sessionId ? client.session.get : null,
-*     { id: sessionId ?? '' }
-*   );
-*   return <span>{data?.totalTokens}</span>;
-* }
-*
-* // Skip query with option
-* function ConditionalQuery({ userId, shouldFetch }: { userId: string; shouldFetch: boolean }) {
-*   const { data } = useQuery(
-*     (client) => client.user.get,
-*     { id: userId },
-*     { skip: !shouldFetch }
-*   );
-* }
-*
-* // Complex queries with accessor (escape hatch)
-* function ComplexQuery({ userId }: { userId: string }) {
-*   const { data } = useQuery(
-*     (client) => client.user.get({ id: userId }),
-*     [userId]
-*   );
-* }
-* ```
-*/
-declare function useQuery2<
-	TParams,
-	TResult,
-	TSelected = TResult
->(selector: RouteSelector<TParams, TResult>, params: TParams, options?: UseQueryOptions<TResult, TSelected>): UseQueryResult<TSelected>;
-declare function useQuery2<
-	TResult,
-	TSelected = TResult
->(selector: QuerySelector<TResult>, deps: DependencyList, options?: UseQueryOptions<TResult, TSelected>): UseQueryResult<TSelected>;
-/**
-* Execute mutations with loading/error state.
-* Client is automatically injected from LensProvider context.
-*
-* @param selector - Callback that returns mutation function from client
-*
-* @example
-* \`\`\`tsx
-* function CreatePost() {
-*   const { mutate, loading, error, data } = useMutation(
-*     (client) => client.post.create
-*   );
-*
-*   const handleSubmit = async (formData: FormData) => {
-*     try {
-*       const result = await mutate({
-*         title: formData.get('title'),
-*         content: formData.get('content'),
-*       });
-*       console.log('Created:', result.data);
-*     } catch (err) {
-*       console.error('Failed:', err);
-*     }
-*   };
-*
-*   return (
-*     <form onSubmit={handleSubmit}>
-*       <button type="submit" disabled={loading}>
-*         {loading ? 'Creating...' : 'Create'}
-*       </button>
-*       {error && <p className="error">{error.message}</p>}
-*     </form>
-*   );
-* }
-*
-* // With optimistic updates
-* function UpdatePost({ postId }: { postId: string }) {
-*   const { mutate } = useMutation((client) => client.post.update);
-*
-*   const handleUpdate = async (title: string) => {
-*     const result = await mutate({ id: postId, title });
-*     // result.rollback?.() can undo optimistic update
-*   };
-* }
-* \`\`\`
-*/
-declare function useMutation2<
-	TInput,
-	TOutput
->(selector: MutationSelector<TInput, TOutput>): UseMutationResult<TInput, TOutput>;
-/** Result of useLazyQuery hook */
-interface UseLazyQueryResult<T> {
-	/** Execute the query */
-	execute: () => Promise<T>;
-	/** Query data (null if not executed or error) */
-	data: T | null;
-	/** Loading state */
-	loading: boolean;
-	/** Error state */
-	error: Error | null;
-	/** Reset query state */
-	reset: () => void;
-}
-/**
-* Execute a query on demand (not on mount).
-* Client is automatically injected from LensProvider context.
-*
-* @example
-* ```tsx
-* // Route + Params pattern
-* function SearchUsers() {
-*   const [searchTerm, setSearchTerm] = useState('');
-*   const { execute, data, loading } = useLazyQuery(
-*     (client) => client.user.search,
-*     { query: searchTerm }
-*   );
-*
-*   return (
-*     <div>
-*       <input value={searchTerm} onChange={e => setSearchTerm(e.target.value)} />
-*       <button onClick={execute} disabled={loading}>Search</button>
-*       {data?.map(user => <UserCard key={user.id} user={user} />)}
-*     </div>
-*   );
-* }
-*
-* // Accessor pattern
-* function LazyComplexQuery({ userId }: { userId: string }) {
-*   const { execute, data } = useLazyQuery(
-*     (client) => client.user.get({ id: userId }),
-*     [userId]
-*   );
-*   return <button onClick={execute}>Load</button>;
-* }
-* ```
-*/
-declare function useLazyQuery<
-	TParams,
-	TResult,
-	TSelected = TResult
->(selector: RouteSelector<TParams, TResult>, params: TParams, options?: UseQueryOptions<TResult, TSelected>): UseLazyQueryResult<TSelected>;
-declare function useLazyQuery<
-	TResult,
-	TSelected = TResult
->(selector: QuerySelector<TResult>, deps: DependencyList, options?: UseQueryOptions<TResult, TSelected>): UseLazyQueryResult<TSelected>;
-export { useQuery2 as useQuery, useMutation2 as useMutation, useLensClient, useLazyQuery, createClient, UseQueryResult, UseQueryOptions, UseMutationResult, UseLazyQueryResult, TypedClient, RouteSelector, QuerySelector, QueryHookResult, QueryHookOptions, QueryEndpoint, MutationSelector, MutationHookResult, MutationHookOptions, MutationEndpoint, LensProviderProps, LensProvider };
+export { createClient, TypedClient, QueryHookResult, QueryHookOptions, QueryEndpoint, MutationHookResult, MutationHookOptions, MutationEndpoint };

package/dist/index.js

@@ -206,256 +206,6 @@ function createClient(config) {
   }
   return createProxy("");
 }
-// src/context.tsx
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-var LENS_CONTEXT_KEY = Symbol.for("@sylphx/lens-react/context");
-function getOrCreateContext() {
-  const globalObj = globalThis;
-  if (!globalObj[LENS_CONTEXT_KEY]) {
-    globalObj[LENS_CONTEXT_KEY] = createContext(null);
-  }
-  return globalObj[LENS_CONTEXT_KEY];
-}
-var LensContext = getOrCreateContext();
-function LensProvider({ client, children }) {
-  return /* @__PURE__ */ jsx(LensContext.Provider, {
-    value: client,
-    children
-  });
-}
-function useLensClient() {
-  const client = useContext(LensContext);
-  if (!client) {
-    throw new Error("useLensClient must be used within a <LensProvider>. " + "Make sure to wrap your app with <LensProvider client={client}>.");
-  }
-  return client;
-}
-// src/hooks.ts
-import {
-  useCallback as useCallback2,
-  useEffect as useEffect2,
-  useMemo as useMemo2,
-  useReducer as useReducer2,
-  useRef as useRef2,
-  useState as useState2
-} from "react";
-function queryReducer2(state, action) {
-  switch (action.type) {
-    case "RESET":
-      return { data: null, loading: false, error: null };
-    case "START":
-      return { ...state, loading: true, error: null };
-    case "SUCCESS":
-      return { data: action.data, loading: false, error: null };
-    case "ERROR":
-      return { ...state, loading: false, error: action.error };
-    case "LOADING_DONE":
-      return { ...state, loading: false };
-    default:
-      return state;
-  }
-}
-function useQuery(selector, paramsOrDeps, options) {
-  const client = useLensClient();
-  const isAccessorMode = Array.isArray(paramsOrDeps);
-  const paramsKey = !isAccessorMode ? JSON.stringify(paramsOrDeps) : null;
-  const selectorRef = useRef2(selector);
-  selectorRef.current = selector;
-  const query = useMemo2(() => {
-    if (options?.skip)
-      return null;
-    if (isAccessorMode) {
-      const querySelector = selectorRef.current;
-      return querySelector(client);
-    }
-    const routeSelector = selectorRef.current;
-    const route = routeSelector(client);
-    if (!route)
-      return null;
-    return route(paramsOrDeps);
-  }, isAccessorMode ? [client, options?.skip, ...paramsOrDeps] : [client, paramsKey, options?.skip]);
-  const selectRef = useRef2(options?.select);
-  selectRef.current = options?.select;
-  const initialState = {
-    data: null,
-    loading: query != null && !options?.skip,
-    error: null
-  };
-  const [state, dispatch] = useReducer2(queryReducer2, initialState);
-  const mountedRef = useRef2(true);
-  const queryRef = useRef2(query);
-  queryRef.current = query;
-  const transform = useCallback2((value) => {
-    return selectRef.current ? selectRef.current(value) : value;
-  }, []);
-  useEffect2(() => {
-    mountedRef.current = true;
-    if (query == null) {
-      dispatch({ type: "RESET" });
-      return;
-    }
-    dispatch({ type: "START" });
-    let hasReceivedData = false;
-    const unsubscribe = query.subscribe((value) => {
-      if (mountedRef.current) {
-        hasReceivedData = true;
-        dispatch({ type: "SUCCESS", data: transform(value) });
-      }
-    });
-    query.then((value) => {
-      if (mountedRef.current) {
-        if (!hasReceivedData) {
-          dispatch({ type: "SUCCESS", data: transform(value) });
-        } else {
-          dispatch({ type: "LOADING_DONE" });
-        }
-      }
-    }, (err) => {
-      if (mountedRef.current) {
-        dispatch({
-          type: "ERROR",
-          error: err instanceof Error ? err : new Error(String(err))
-        });
-      }
-    });
-    return () => {
-      mountedRef.current = false;
-      unsubscribe();
-    };
-  }, [query, transform]);
-  const refetch = useCallback2(() => {
-    const currentQuery = queryRef.current;
-    if (currentQuery == null)
-      return;
-    dispatch({ type: "START" });
-    currentQuery.then((value) => {
-      if (mountedRef.current) {
-        dispatch({ type: "SUCCESS", data: transform(value) });
-      }
-    }, (err) => {
-      if (mountedRef.current) {
-        dispatch({
-          type: "ERROR",
-          error: err instanceof Error ? err : new Error(String(err))
-        });
-      }
-    });
-  }, [transform]);
-  return { data: state.data, loading: state.loading, error: state.error, refetch };
-}
-function useMutation(selector) {
-  const client = useLensClient();
-  const mutationFn = selector(client);
-  const [loading, setLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const [data, setData] = useState2(null);
-  const mountedRef = useRef2(true);
-  const mutationRef = useRef2(mutationFn);
-  mutationRef.current = mutationFn;
-  useEffect2(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-  const mutate = useCallback2(async (input) => {
-    setLoading(true);
-    setError(null);
-    try {
-      const result = await mutationRef.current(input);
-      if (mountedRef.current) {
-        setData(result.data);
-      }
-      return result;
-    } catch (err) {
-      const mutationError = err instanceof Error ? err : new Error(String(err));
-      if (mountedRef.current) {
-        setError(mutationError);
-      }
-      throw mutationError;
-    } finally {
-      if (mountedRef.current) {
-        setLoading(false);
-      }
-    }
-  }, []);
-  const reset = useCallback2(() => {
-    setLoading(false);
-    setError(null);
-    setData(null);
-  }, []);
-  return { mutate, loading, error, data, reset };
-}
-function useLazyQuery(selector, paramsOrDeps, options) {
-  const client = useLensClient();
-  const [data, setData] = useState2(null);
-  const [loading, setLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const mountedRef = useRef2(true);
-  const isAccessorMode = Array.isArray(paramsOrDeps);
-  const selectorRef = useRef2(selector);
-  selectorRef.current = selector;
-  const paramsOrDepsRef = useRef2(paramsOrDeps);
-  paramsOrDepsRef.current = paramsOrDeps;
-  const selectRef = useRef2(options?.select);
-  selectRef.current = options?.select;
-  useEffect2(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
-  const execute = useCallback2(async () => {
-    let query;
-    if (isAccessorMode) {
-      const querySelector = selectorRef.current;
-      query = querySelector(client);
-    } else {
-      const routeSelector = selectorRef.current;
-      const route = routeSelector(client);
-      if (route) {
-        query = route(paramsOrDepsRef.current);
-      }
-    }
-    if (query == null) {
-      setData(null);
-      setLoading(false);
-      return null;
-    }
-    setLoading(true);
-    setError(null);
-    try {
-      const result = await query;
-      const selected = selectRef.current ? selectRef.current(result) : result;
-      if (mountedRef.current) {
-        setData(selected);
-      }
-      return selected;
-    } catch (err) {
-      const queryError = err instanceof Error ? err : new Error(String(err));
-      if (mountedRef.current) {
-        setError(queryError);
-      }
-      throw queryError;
-    } finally {
-      if (mountedRef.current) {
-        setLoading(false);
-      }
-    }
-  }, [client, isAccessorMode]);
-  const reset = useCallback2(() => {
-    setLoading(false);
-    setError(null);
-    setData(null);
-  }, []);
-  return { execute, data, loading, error, reset };
-}
 export {
-  useQuery,
-  useMutation,
-  useLensClient,
-  useLazyQuery,
-  createClient,
-  LensProvider
+  createClient
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-react",
-	"version": "2.5.13",
+	"version": "2.5.15",
 	"description": "React bindings for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -30,8 +30,8 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-client": "^2.7.8",
-		"@sylphx/lens-core": "^3.0.1"
+		"@sylphx/lens-client": "^3.0.1",
+		"@sylphx/lens-core": "^4.0.2"
 	},
 	"peerDependencies": {
 		"react": ">=18.0.0"

package/src/index.ts

@@ -25,10 +25,6 @@
  * ```
  */
 
-// =============================================================================
-// New API (v4) - Recommended
-// =============================================================================
-
 export {
 	createClient,
 	type MutationEndpoint,
@@ -39,25 +35,3 @@ export {
 	type QueryHookResult,
 	type TypedClient,
 } from "./create.js";
-
-// =============================================================================
-// Legacy API (v3) - Deprecated, will be removed in v3.0
-// =============================================================================
-
-export { LensProvider, type LensProviderProps, useLensClient } from "./context.js";
-
-export {
-	// Types
-	type MutationSelector,
-	type QuerySelector,
-	type RouteSelector,
-	type UseLazyQueryResult,
-	type UseMutationResult,
-	type UseQueryOptions,
-	type UseQueryResult,
-	// Query hooks
-	useLazyQuery,
-	// Mutation hook
-	useMutation,
-	useQuery,
-} from "./hooks.js";