enlace 0.0.1-beta.12 → 0.0.1-beta.14

package/README.md

@@ -11,7 +11,7 @@ npm install enlace
 ## Quick Start
 
 ```typescript
-import { createEnlaceHookReact } from "enlace/hook";
+import { enlaceHookReact } from "enlace/hook";
 import { Endpoint } from "enlace";
 
 // Define your API error type
@@ -30,7 +30,7 @@ type ApiSchema = {
 };
 
 // Pass global error type as second generic
-const useAPI = createEnlaceHookReact<ApiSchema, ApiError>(
+const useAPI = enlaceHookReact<ApiSchema, ApiError>(
   "https://api.example.com"
 );
 ```
@@ -41,13 +41,13 @@ Defining a schema is **recommended** for full type safety, but **optional**. You
 
 ```typescript
 // Without schema (untyped, but still works!)
-const useAPI = createEnlaceHookReact("https://api.example.com");
+const useAPI = enlaceHookReact("https://api.example.com");
 const { data } = useAPI((api) => api.any.path.you.want.get());
 ```
 
 ```typescript
 // With schema (recommended for type safety)
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com");
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com");
 ```
 
 ### Schema Structure
@@ -77,7 +77,7 @@ type ApiSchema = {
 };
 
 // Pass global error type - applies to all endpoints
-const api = createEnlace<ApiSchema, ApiError>("https://api.example.com");
+const api = enlace<ApiSchema, ApiError>("https://api.example.com");
 
 // Usage
 api.users.get(); // GET /users
@@ -197,9 +197,9 @@ type ApiSchema = {
 type ApiError = { message: string; code: number };
 
 // Second generic sets default error type for all endpoints
-const api = createEnlace<ApiSchema, ApiError>("https://api.example.com");
-// const useAPI = createEnlaceHookReact<ApiSchema, ApiError>("...");
-// const useAPI = createEnlaceHookNext<ApiSchema, ApiError>("...");
+const api = enlace<ApiSchema, ApiError>("https://api.example.com");
+// const useAPI = enlaceHookReact<ApiSchema, ApiError>("...");
+// const useAPI = enlaceHookNext<ApiSchema, ApiError>("...");
 ```
 
 ## React Hooks
@@ -269,6 +269,74 @@ function Post({ id }: { id: number }) {
 }
 ```
 
+### Polling
+
+Automatically refetch data at intervals using the `pollingInterval` option. Polling uses sequential timing — the interval starts counting **after** the previous request completes, preventing request pile-up:
+
+```typescript
+function Notifications() {
+  const { data } = useAPI(
+    (api) => api.notifications.get(),
+    { pollingInterval: 5000 } // Refetch every 5 seconds after previous request completes
+  );
+
+  return <NotificationList notifications={data} />;
+}
+```
+
+**Behavior:**
+
+- Polling starts after the initial fetch completes
+- Next poll is scheduled only after the current request finishes (success or error)
+- Continues polling even on errors (retry behavior)
+- Stops when component unmounts or `enabled` becomes `false`
+- Resets when component remounts
+
+**Dynamic polling with function:**
+
+Use a function to conditionally poll based on the response data or error:
+
+```typescript
+function OrderStatus({ orderId }: { orderId: string }) {
+  const { data } = useAPI(
+    (api) => api.orders[orderId].get(),
+    {
+      // Poll every 2s while pending, stop when completed
+      pollingInterval: (order) => order?.status === "pending" ? 2000 : false,
+    }
+  );
+
+  return <div>Status: {data?.status}</div>;
+}
+```
+
+The function receives `(data, error)` and should return:
+- `number`: Interval in milliseconds
+- `false`: Stop polling
+
+```typescript
+// Poll faster when there's an error (retry), slower otherwise
+{ pollingInterval: (data, error) => error ? 1000 : 10000 }
+
+// Stop polling once data meets a condition
+{ pollingInterval: (order) => order?.status === "completed" ? false : 3000 }
+```
+
+**Combined with conditional fetching:**
+
+```typescript
+function OrderStatus({ orderId }: { orderId: string | undefined }) {
+  const { data } = useAPI(
+    (api) => api.orders[orderId!].get(),
+    {
+      enabled: !!orderId,
+      pollingInterval: 10000, // Poll every 10 seconds
+    }
+  );
+  // Polling only runs when orderId is defined
+}
+```
+
 ### Request Deduplication
 
 Multiple components requesting the same data will share a single network request:
@@ -428,7 +496,7 @@ trigger({ body: { title: "New" } });
 Control how long cached data is considered fresh:
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {},
   {
@@ -459,7 +527,7 @@ trigger({
 ### Disable Auto-Revalidation
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {},
   {
@@ -472,7 +540,7 @@ const useAPI = createEnlaceHookReact<ApiSchema>(
 ## Hook Options
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {
     // Default fetch options
@@ -493,17 +561,17 @@ Headers can be provided as a static value, sync function, or async function. Thi
 
 ```typescript
 // Static headers
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: { Authorization: "Bearer token" },
 });
 
 // Sync function
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: () => ({ Authorization: `Bearer ${getToken()}` }),
 });
 
 // Async function
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: async () => {
     const token = await getTokenFromStorage();
     return { Authorization: `Bearer ${token}` };
@@ -529,7 +597,7 @@ const { data } = useAPI((api) =>
 You can set up global `onSuccess` and `onError` callbacks that are called for every request:
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {
     headers: { Authorization: "Bearer token" },
@@ -585,7 +653,18 @@ const result = useAPI((api) => api.posts.get());
 // With options
 const result = useAPI(
   (api) => api.posts.get(),
-  { enabled: true } // Skip fetching when false
+  {
+    enabled: true,        // Skip fetching when false
+    pollingInterval: 5000 // Refetch every 5s after previous request completes
+  }
+);
+
+// With dynamic polling
+const result = useAPI(
+  (api) => api.orders[id].get(),
+  {
+    pollingInterval: (order) => order?.status === "pending" ? 2000 : false
+  }
 );
 
 type UseEnlaceQueryResult<TData, TError> = {
@@ -608,6 +687,18 @@ type UseEnlaceSelectorResult<TMethod> = {
 };
 ```
 
+### Query Options
+
+```typescript
+type UseEnlaceQueryOptions<TData, TError> = {
+  enabled?: boolean; // Skip fetching when false (default: true)
+  pollingInterval?: // Refetch interval after request completes
+    | number // Fixed interval in ms
+    | false // Disable polling
+    | ((data: TData | undefined, error: TError | undefined) => number | false); // Dynamic
+};
+```
+
 ### Request Options
 
 ```typescript
@@ -628,14 +719,14 @@ type RequestOptions = {
 
 ### Server Components
 
-Use `createEnlaceNext` from `enlace` for server components:
+Use `enlaceNext` from `enlace` for server components:
 
 ```typescript
-import { createEnlaceNext } from "enlace";
+import { enlaceNext } from "enlace";
 
 type ApiError = { message: string };
 
-const api = createEnlaceNext<ApiSchema, ApiError>("https://api.example.com", {}, {
+const api = enlaceNext<ApiSchema, ApiError>("https://api.example.com", {}, {
   autoGenerateTags: true,
 });
 
@@ -650,16 +741,16 @@ export default async function Page() {
 
 ### Client Components
 
-Use `createEnlaceHookNext` from `enlace/hook` for client components:
+Use `enlaceHookNext` from `enlace/hook` for client components:
 
 ```typescript
 "use client";
 
-import { createEnlaceHookNext } from "enlace/hook";
+import { enlaceHookNext } from "enlace/hook";
 
 type ApiError = { message: string };
 
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+const useAPI = enlaceHookNext<ApiSchema, ApiError>(
   "https://api.example.com"
 );
 ```
@@ -686,12 +777,12 @@ export async function revalidateAction(tags: string[], paths: string[]) {
 
 ```typescript
 // useAPI.ts
-import { createEnlaceHookNext } from "enlace/hook";
+import { enlaceHookNext } from "enlace/hook";
 import { revalidateAction } from "./actions";
 
 type ApiError = { message: string };
 
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+const useAPI = enlaceHookNext<ApiSchema, ApiError>(
   "/api",
   {},
   {
@@ -721,7 +812,7 @@ function CreatePost() {
 For projects that primarily use client-side rendering with minimal SSR, you can disable server-side revalidation by default:
 
 ```typescript
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+const useAPI = enlaceHookNext<ApiSchema, ApiError>(
   "/api",
   {},
   {
@@ -767,26 +858,26 @@ Works with Next.js API routes:
 
 ```typescript
 // Client component calling /api/posts
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>("/api");
+const useAPI = enlaceHookNext<ApiSchema, ApiError>("/api");
 ```
 
 ---
 
 ## API Reference
 
-### `createEnlaceHookReact<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
+### `enlaceHookReact<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
 
 Creates a React hook for making API calls.
 
-### `createEnlaceHookNext<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
+### `enlaceHookNext<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
 
 Creates a Next.js hook with server revalidation support.
 
-### `createEnlace<TSchema, TDefaultError>(baseUrl, options?, callbacks?)`
+### `enlace<TSchema, TDefaultError>(baseUrl, options?, callbacks?)`
 
 Creates a typed API client (non-hook, for direct calls or server components).
 
-### `createEnlaceNext<TSchema, TDefaultError>(baseUrl, options?, nextOptions?)`
+### `enlaceNext<TSchema, TDefaultError>(baseUrl, options?, nextOptions?)`
 
 Creates a Next.js typed API client with caching support.
 

package/dist/hook/index.d.mts

@@ -19,14 +19,40 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
+/** Polling interval value: milliseconds to wait, or false to stop polling */
+type PollingIntervalValue = number | false;
+/** Function that determines polling interval based on current data/error state */
+type PollingIntervalFn<TData, TError> = (data: TData | undefined, error: TError | undefined) => PollingIntervalValue;
+/** Polling interval option: static value or dynamic function */
+type PollingInterval<TData = unknown, TError = unknown> = PollingIntervalValue | PollingIntervalFn<TData, TError>;
 /** Options for query mode hooks */
-type UseEnlaceQueryOptions = {
+type UseEnlaceQueryOptions<TData = unknown, TError = unknown> = {
     /**
      * Whether the query should execute.
      * Set to false to skip fetching (useful when ID is "new" or undefined).
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Polling interval in milliseconds, or a function that returns the interval.
+     * When set, the query will refetch after this interval AFTER the previous request completes.
+     * Uses sequential polling (setTimeout after fetch completes), not interval-based.
+     *
+     * Can be:
+     * - `number`: Fixed interval in milliseconds
+     * - `false`: Disable polling
+     * - `(data, error) => number | false`: Dynamic interval based on response
+     *
+     * @example
+     * // Fixed interval
+     * { pollingInterval: 5000 }
+     *
+     * // Conditional polling based on data
+     * { pollingInterval: (order) => order?.status === 'pending' ? 2000 : false }
+     *
+     * @default undefined (no polling)
+     */
+    pollingInterval?: PollingInterval<TData, TError>;
 };
 type ApiClient<TSchema, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TDefaultError, TOptions>;
 type QueryFn<TSchema, TData, TError, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
@@ -64,7 +90,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -81,10 +107,10 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-/** Hook type returned by createEnlaceHookReact */
+/** Hook type returned by enlaceHookReact */
 type EnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -92,7 +118,7 @@ type EnlaceHook<TSchema, TDefaultError = unknown> = {
  * Called at module level to create a reusable hook.
  *
  * @example
- * const useAPI = createEnlaceHookReact<ApiSchema>('https://api.com');
+ * const useAPI = enlaceHookReact<ApiSchema>('https://api.com');
  *
  * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
  * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
@@ -101,7 +127,7 @@ type EnlaceHook<TSchema, TDefaultError = unknown> = {
  * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
  * onClick={() => trigger({ body: { id: 1 } })}
  */
-declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -109,14 +135,14 @@ declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknow
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -130,7 +156,7 @@ type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateT
      */
     skipServerRevalidation?: boolean;
 };
-/** Next.js hook options (third argument for createEnlaceHookNext) - extends React's EnlaceHookOptions */
+/** Next.js hook options (third argument for enlaceHookNext) - extends React's EnlaceHookOptions */
 type NextHookOptions = EnlaceHookOptions & Pick<NextOptions, "serverRevalidator" | "skipServerRevalidation">;
 /** Per-request options for Next.js fetch - extends React's base options */
 type NextRequestOptionsBase = ReactRequestOptionsBase & {
@@ -151,10 +177,10 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
 };
 type NextQueryFn<TSchema, TData, TError, TDefaultError = unknown> = QueryFn<TSchema, TData, TError, TDefaultError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod, TDefaultError = unknown> = SelectorFn<TSchema, TMethod, TDefaultError, NextRequestOptionsBase>;
-/** Hook type returned by createEnlaceHookNext */
+/** Hook type returned by enlaceHookNext */
 type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -162,7 +188,7 @@ type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
  * Uses Next.js-specific features like serverRevalidator for server-side cache invalidation.
  *
  * @example
- * const useAPI = createEnlaceHookNext<ApiSchema>('https://api.com', {}, {
+ * const useAPI = enlaceHookNext<ApiSchema>('https://api.com', {}, {
  *   serverRevalidator: (tags) => revalidateTagsAction(tags),
  *   staleTime: 5000,
  * });
@@ -173,6 +199,6 @@ type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
  * // Selector mode - trigger for mutations
  * const { trigger } = useAPI((api) => api.posts.delete);
  */
-declare function createEnlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
 
-export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, createEnlaceHookNext, createEnlaceHookReact };
+export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type PollingInterval, type PollingIntervalFn, type PollingIntervalValue, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, enlaceHookNext, enlaceHookReact };

package/dist/hook/index.d.ts

@@ -19,14 +19,40 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
+/** Polling interval value: milliseconds to wait, or false to stop polling */
+type PollingIntervalValue = number | false;
+/** Function that determines polling interval based on current data/error state */
+type PollingIntervalFn<TData, TError> = (data: TData | undefined, error: TError | undefined) => PollingIntervalValue;
+/** Polling interval option: static value or dynamic function */
+type PollingInterval<TData = unknown, TError = unknown> = PollingIntervalValue | PollingIntervalFn<TData, TError>;
 /** Options for query mode hooks */
-type UseEnlaceQueryOptions = {
+type UseEnlaceQueryOptions<TData = unknown, TError = unknown> = {
     /**
      * Whether the query should execute.
      * Set to false to skip fetching (useful when ID is "new" or undefined).
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Polling interval in milliseconds, or a function that returns the interval.
+     * When set, the query will refetch after this interval AFTER the previous request completes.
+     * Uses sequential polling (setTimeout after fetch completes), not interval-based.
+     *
+     * Can be:
+     * - `number`: Fixed interval in milliseconds
+     * - `false`: Disable polling
+     * - `(data, error) => number | false`: Dynamic interval based on response
+     *
+     * @example
+     * // Fixed interval
+     * { pollingInterval: 5000 }
+     *
+     * // Conditional polling based on data
+     * { pollingInterval: (order) => order?.status === 'pending' ? 2000 : false }
+     *
+     * @default undefined (no polling)
+     */
+    pollingInterval?: PollingInterval<TData, TError>;
 };
 type ApiClient<TSchema, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TDefaultError, TOptions>;
 type QueryFn<TSchema, TData, TError, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
@@ -64,7 +90,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -81,10 +107,10 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-/** Hook type returned by createEnlaceHookReact */
+/** Hook type returned by enlaceHookReact */
 type EnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -92,7 +118,7 @@ type EnlaceHook<TSchema, TDefaultError = unknown> = {
  * Called at module level to create a reusable hook.
  *
  * @example
- * const useAPI = createEnlaceHookReact<ApiSchema>('https://api.com');
+ * const useAPI = enlaceHookReact<ApiSchema>('https://api.com');
  *
  * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
  * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
@@ -101,7 +127,7 @@ type EnlaceHook<TSchema, TDefaultError = unknown> = {
  * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
  * onClick={() => trigger({ body: { id: 1 } })}
  */
-declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -109,14 +135,14 @@ declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknow
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -130,7 +156,7 @@ type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateT
      */
     skipServerRevalidation?: boolean;
 };
-/** Next.js hook options (third argument for createEnlaceHookNext) - extends React's EnlaceHookOptions */
+/** Next.js hook options (third argument for enlaceHookNext) - extends React's EnlaceHookOptions */
 type NextHookOptions = EnlaceHookOptions & Pick<NextOptions, "serverRevalidator" | "skipServerRevalidation">;
 /** Per-request options for Next.js fetch - extends React's base options */
 type NextRequestOptionsBase = ReactRequestOptionsBase & {
@@ -151,10 +177,10 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
 };
 type NextQueryFn<TSchema, TData, TError, TDefaultError = unknown> = QueryFn<TSchema, TData, TError, TDefaultError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod, TDefaultError = unknown> = SelectorFn<TSchema, TMethod, TDefaultError, NextRequestOptionsBase>;
-/** Hook type returned by createEnlaceHookNext */
+/** Hook type returned by enlaceHookNext */
 type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -162,7 +188,7 @@ type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
  * Uses Next.js-specific features like serverRevalidator for server-side cache invalidation.
  *
  * @example
- * const useAPI = createEnlaceHookNext<ApiSchema>('https://api.com', {}, {
+ * const useAPI = enlaceHookNext<ApiSchema>('https://api.com', {}, {
  *   serverRevalidator: (tags) => revalidateTagsAction(tags),
  *   staleTime: 5000,
  * });
@@ -173,6 +199,6 @@ type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
  * // Selector mode - trigger for mutations
  * const { trigger } = useAPI((api) => api.posts.delete);
  */
-declare function createEnlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
 
-export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, createEnlaceHookNext, createEnlaceHookReact };
+export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type PollingInterval, type PollingIntervalFn, type PollingIntervalValue, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, enlaceHookNext, enlaceHookReact };

package/dist/hook/index.js

@@ -23,12 +23,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var hook_exports = {};
 __export(hook_exports, {
   HTTP_METHODS: () => HTTP_METHODS,
-  createEnlaceHookNext: () => createEnlaceHookNext,
-  createEnlaceHookReact: () => createEnlaceHookReact
+  enlaceHookNext: () => enlaceHookNext,
+  enlaceHookReact: () => enlaceHookReact
 });
 module.exports = __toCommonJS(hook_exports);
 
-// src/react/createEnlaceHookReact.ts
+// src/react/enlaceHookReact.ts
 var import_enlace_core = require("enlace-core");
 
 // src/react/useQueryMode.ts
@@ -52,6 +52,13 @@ function hookReducer(state, action) {
         fetching: true,
         error: void 0
       };
+    case "MUTATION_START":
+      return {
+        ...state,
+        loading: true,
+        fetching: true,
+        error: void 0
+      };
     case "FETCH_SUCCESS":
       return {
         loading: false,
@@ -193,7 +200,7 @@ function resolvePath(path, params) {
   });
 }
 function useQueryMode(api, trackedCall, options) {
-  const { autoGenerateTags, staleTime, enabled } = options;
+  const { autoGenerateTags, staleTime, enabled, pollingInterval } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
   const resolvedPath = resolvePath(trackedCall.path, requestOptions?.params);
@@ -218,15 +225,41 @@ function useQueryMode(api, trackedCall, options) {
   );
   const mountedRef = (0, import_react.useRef)(true);
   const fetchRef = (0, import_react.useRef)(null);
+  const pollingTimeoutRef = (0, import_react.useRef)(null);
+  const pollingIntervalRef = (0, import_react.useRef)(pollingInterval);
+  pollingIntervalRef.current = pollingInterval;
   (0, import_react.useEffect)(() => {
     mountedRef.current = true;
     if (!enabled) {
       dispatch({ type: "RESET" });
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
+    const scheduleNextPoll = () => {
+      const currentPollingInterval = pollingIntervalRef.current;
+      if (!mountedRef.current || !enabled || currentPollingInterval === void 0) {
+        return;
+      }
+      const cached2 = getCache(queryKey);
+      const interval = typeof currentPollingInterval === "function" ? currentPollingInterval(cached2?.data, cached2?.error) : currentPollingInterval;
+      if (interval === false || interval <= 0) {
+        return;
+      }
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+      }
+      pollingTimeoutRef.current = setTimeout(() => {
+        if (mountedRef.current && enabled && fetchRef.current) {
+          fetchRef.current();
+        }
+      }, interval);
+    };
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -239,23 +272,21 @@ function useQueryMode(api, trackedCall, options) {
       }
       const method = current[trackedCall.method];
       const fetchPromise = method(trackedCall.options).then((res) => {
-        if (mountedRef.current) {
-          setCache(queryKey, {
-            data: res.error ? void 0 : res.data,
-            error: res.error,
-            timestamp: Date.now(),
-            tags: queryTags
-          });
-        }
+        setCache(queryKey, {
+          data: res.error ? void 0 : res.data,
+          error: res.error,
+          timestamp: Date.now(),
+          tags: queryTags
+        });
       }).catch((err) => {
-        if (mountedRef.current) {
-          setCache(queryKey, {
-            data: void 0,
-            error: err,
-            timestamp: Date.now(),
-            tags: queryTags
-          });
-        }
+        setCache(queryKey, {
+          data: void 0,
+          error: err,
+          timestamp: Date.now(),
+          tags: queryTags
+        });
+      }).finally(() => {
+        scheduleNextPoll();
       });
       setCache(queryKey, {
         promise: fetchPromise,
@@ -266,6 +297,7 @@ function useQueryMode(api, trackedCall, options) {
     const cached = getCache(queryKey);
     if (cached?.data !== void 0 && !isStale(queryKey, staleTime)) {
       dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      scheduleNextPoll();
     } else {
       doFetch();
     }
@@ -277,6 +309,10 @@ function useQueryMode(api, trackedCall, options) {
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       unsubscribe();
     };
   }, [queryKey, enabled]);
@@ -359,7 +395,7 @@ function useSelectorMode(config) {
   autoRevalidateRef.current = autoRevalidateTags;
   if (!triggerRef.current) {
     triggerRef.current = (async (...args) => {
-      dispatch({ type: "FETCH_START" });
+      dispatch({ type: "MUTATION_START" });
       const options = args[0];
       const resolvedPath = resolvePath2(pathRef.current, options?.params);
       let res;
@@ -391,8 +427,8 @@ function useSelectorMode(config) {
   };
 }
 
-// src/react/createEnlaceHookReact.ts
-function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/react/enlaceHookReact.ts
+function enlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
@@ -400,7 +436,7 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     onSuccess,
     onError
   } = hookOptions;
-  const api = (0, import_enlace_core.createEnlace)(baseUrl, defaultOptions, {
+  const api = (0, import_enlace_core.enlace)(baseUrl, defaultOptions, {
     onSuccess,
     onError
   });
@@ -432,7 +468,12 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     return useQueryMode(
       api,
       trackingResult.trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;
@@ -489,7 +530,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return (0, import_enlace_core3.createProxyHandler)(
     baseUrl,
@@ -499,15 +540,15 @@ function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   );
 }
 
-// src/next/createEnlaceHookNext.ts
-function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/enlaceHookNext.ts
+function enlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlaceNext(
+  const api = enlaceNext(
     baseUrl,
     defaultOptions,
     {
@@ -544,7 +585,12 @@ function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
     return useQueryMode(
       api,
       trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;

package/dist/hook/index.mjs

@@ -1,9 +1,9 @@
 "use client";
 "use client";
 
-// src/react/createEnlaceHookReact.ts
+// src/react/enlaceHookReact.ts
 import {
-  createEnlace
+  enlace
 } from "enlace-core";
 
 // src/react/useQueryMode.ts
@@ -27,6 +27,13 @@ function hookReducer(state, action) {
         fetching: true,
         error: void 0
       };
+    case "MUTATION_START":
+      return {
+        ...state,
+        loading: true,
+        fetching: true,
+        error: void 0
+      };
     case "FETCH_SUCCESS":
       return {
         loading: false,
@@ -168,7 +175,7 @@ function resolvePath(path, params) {
   });
 }
 function useQueryMode(api, trackedCall, options) {
-  const { autoGenerateTags, staleTime, enabled } = options;
+  const { autoGenerateTags, staleTime, enabled, pollingInterval } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
   const resolvedPath = resolvePath(trackedCall.path, requestOptions?.params);
@@ -193,15 +200,41 @@ function useQueryMode(api, trackedCall, options) {
   );
   const mountedRef = useRef(true);
   const fetchRef = useRef(null);
+  const pollingTimeoutRef = useRef(null);
+  const pollingIntervalRef = useRef(pollingInterval);
+  pollingIntervalRef.current = pollingInterval;
   useEffect(() => {
     mountedRef.current = true;
     if (!enabled) {
       dispatch({ type: "RESET" });
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
+    const scheduleNextPoll = () => {
+      const currentPollingInterval = pollingIntervalRef.current;
+      if (!mountedRef.current || !enabled || currentPollingInterval === void 0) {
+        return;
+      }
+      const cached2 = getCache(queryKey);
+      const interval = typeof currentPollingInterval === "function" ? currentPollingInterval(cached2?.data, cached2?.error) : currentPollingInterval;
+      if (interval === false || interval <= 0) {
+        return;
+      }
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+      }
+      pollingTimeoutRef.current = setTimeout(() => {
+        if (mountedRef.current && enabled && fetchRef.current) {
+          fetchRef.current();
+        }
+      }, interval);
+    };
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -214,23 +247,21 @@ function useQueryMode(api, trackedCall, options) {
       }
       const method = current[trackedCall.method];
       const fetchPromise = method(trackedCall.options).then((res) => {
-        if (mountedRef.current) {
-          setCache(queryKey, {
-            data: res.error ? void 0 : res.data,
-            error: res.error,
-            timestamp: Date.now(),
-            tags: queryTags
-          });
-        }
+        setCache(queryKey, {
+          data: res.error ? void 0 : res.data,
+          error: res.error,
+          timestamp: Date.now(),
+          tags: queryTags
+        });
       }).catch((err) => {
-        if (mountedRef.current) {
-          setCache(queryKey, {
-            data: void 0,
-            error: err,
-            timestamp: Date.now(),
-            tags: queryTags
-          });
-        }
+        setCache(queryKey, {
+          data: void 0,
+          error: err,
+          timestamp: Date.now(),
+          tags: queryTags
+        });
+      }).finally(() => {
+        scheduleNextPoll();
       });
       setCache(queryKey, {
         promise: fetchPromise,
@@ -241,6 +272,7 @@ function useQueryMode(api, trackedCall, options) {
     const cached = getCache(queryKey);
     if (cached?.data !== void 0 && !isStale(queryKey, staleTime)) {
       dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      scheduleNextPoll();
     } else {
       doFetch();
     }
@@ -252,6 +284,10 @@ function useQueryMode(api, trackedCall, options) {
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       unsubscribe();
     };
   }, [queryKey, enabled]);
@@ -334,7 +370,7 @@ function useSelectorMode(config) {
   autoRevalidateRef.current = autoRevalidateTags;
   if (!triggerRef.current) {
     triggerRef.current = (async (...args) => {
-      dispatch({ type: "FETCH_START" });
+      dispatch({ type: "MUTATION_START" });
       const options = args[0];
       const resolvedPath = resolvePath2(pathRef.current, options?.params);
       let res;
@@ -366,8 +402,8 @@ function useSelectorMode(config) {
   };
 }
 
-// src/react/createEnlaceHookReact.ts
-function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/react/enlaceHookReact.ts
+function enlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
@@ -375,7 +411,7 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     onSuccess,
     onError
   } = hookOptions;
-  const api = createEnlace(baseUrl, defaultOptions, {
+  const api = enlace(baseUrl, defaultOptions, {
     onSuccess,
     onError
   });
@@ -407,7 +443,12 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     return useQueryMode(
       api,
       trackingResult.trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;
@@ -468,7 +509,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return createProxyHandler(
     baseUrl,
@@ -478,15 +519,15 @@ function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   );
 }
 
-// src/next/createEnlaceHookNext.ts
-function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/enlaceHookNext.ts
+function enlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlaceNext(
+  const api = enlaceNext(
     baseUrl,
     defaultOptions,
     {
@@ -523,13 +564,18 @@ function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
     return useQueryMode(
       api,
       trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;
 }
 export {
   HTTP_METHODS,
-  createEnlaceHookNext,
-  createEnlaceHookReact
+  enlaceHookNext,
+  enlaceHookReact
 };

package/dist/index.d.mts

@@ -20,7 +20,7 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -44,14 +44,14 @@ type EnlaceHookOptions = {
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -83,6 +83,6 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
     serverRevalidate?: boolean;
 };
 
-declare function createEnlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
+declare function enlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
 
-export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };
+export { type NextOptions, type NextRequestOptionsBase, enlaceNext };

package/dist/index.d.ts

@@ -20,7 +20,7 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -44,14 +44,14 @@ type EnlaceHookOptions = {
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -83,6 +83,6 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
     serverRevalidate?: boolean;
 };
 
-declare function createEnlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
+declare function enlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
 
-export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };
+export { type NextOptions, type NextRequestOptionsBase, enlaceNext };

package/dist/index.js

@@ -21,7 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  createEnlaceNext: () => createEnlaceNext
+  enlaceNext: () => enlaceNext
 });
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("enlace-core"), module.exports);
@@ -84,7 +84,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return (0, import_enlace_core2.createProxyHandler)(
     baseUrl,

package/dist/index.mjs

@@ -63,7 +63,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return createProxyHandler(
     baseUrl,
@@ -73,5 +73,5 @@ function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   );
 }
 export {
-  createEnlaceNext
+  enlaceNext
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enlace",
-  "version": "0.0.1-beta.12",
+  "version": "0.0.1-beta.14",
   "license": "MIT",
   "files": [
     "dist"
@@ -18,7 +18,7 @@
     }
   },
   "dependencies": {
-    "enlace-core": "0.0.1-beta.8"
+    "enlace-core": "0.0.1-beta.9"
   },
   "peerDependencies": {
     "react": "^19"