enlace 0.0.1-beta.5 → 0.0.1-beta.6

package/README.md

@@ -11,7 +11,8 @@ npm install enlace
 ## Quick Start
 
 ```typescript
-import { createEnlaceHook, Endpoint } from "enlace";
+import { createEnlaceHookReact } from "enlace/hook";
+import { Endpoint } from "enlace";
 
 type ApiSchema = {
   posts: {
@@ -24,7 +25,7 @@ type ApiSchema = {
   };
 };
 
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com");
+const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com");
 ```
 
 ## Schema Conventions
@@ -33,13 +34,13 @@ Defining a schema is **recommended** for full type safety, but **optional**. You
 
 ```typescript
 // Without schema (untyped, but still works!)
-const useAPI = createEnlaceHook("https://api.example.com");
+const useAPI = createEnlaceHookReact("https://api.example.com");
 const { data } = useAPI((api) => api.any.path.you.want.get());
 ```
 
 ```typescript
 // With schema (recommended for type safety)
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com");
+const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com");
 ```
 
 ### Schema Structure
@@ -310,7 +311,7 @@ trigger({ body: { title: "New" } });
 Control how long cached data is considered fresh:
 
 ```typescript
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {}, {
+const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {}, {
   staleTime: 5000, // 5 seconds
 });
 ```
@@ -337,7 +338,7 @@ trigger({
 ### Disable Auto-Revalidation
 
 ```typescript
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {}, {
+const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {}, {
   autoGenerateTags: false,     // Disable auto tag generation
   autoRevalidateTags: false,   // Disable auto revalidation
 });
@@ -346,7 +347,7 @@ const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {}, {
 ## Hook Options
 
 ```typescript
-const useAPI = createEnlaceHook<ApiSchema>(
+const useAPI = createEnlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {
     // Default fetch options
@@ -367,17 +368,17 @@ Headers can be provided as a static value, sync function, or async function. Thi
 
 ```typescript
 // Static headers
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {
+const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: { Authorization: "Bearer token" },
 });
 
 // Sync function
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {
+const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: () => ({ Authorization: `Bearer ${getToken()}` }),
 });
 
 // Async function
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com", {
+const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: async () => {
     const token = await getTokenFromStorage();
     return { Authorization: `Bearer ${token}` };
@@ -403,7 +404,7 @@ const { data } = useAPI((api) =>
 You can set up global `onSuccess` and `onError` callbacks that are called for every request:
 
 ```typescript
-const useAPI = createEnlaceHook<ApiSchema>(
+const useAPI = createEnlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {
     headers: { Authorization: "Bearer token" },
@@ -502,12 +503,12 @@ type RequestOptions = {
 
 ### Server Components
 
-Use `createEnlace` from `enlace/next` for server components:
+Use `createEnlaceNext` from `enlace` for server components:
 
 ```typescript
-import { createEnlace } from "enlace/next";
+import { createEnlaceNext } from "enlace";
 
-const api = createEnlace<ApiSchema>("https://api.example.com", {}, {
+const api = createEnlaceNext<ApiSchema>("https://api.example.com", {}, {
   autoGenerateTags: true,
 });
 
@@ -522,14 +523,14 @@ export default async function Page() {
 
 ### Client Components
 
-Use `createEnlaceHook` from `enlace/next/hook` for client components:
+Use `createEnlaceHookNext` from `enlace/hook` for client components:
 
 ```typescript
 "use client";
 
-import { createEnlaceHook } from "enlace/next/hook";
+import { createEnlaceHookNext } from "enlace/hook";
 
-const useAPI = createEnlaceHook<ApiSchema>("https://api.example.com");
+const useAPI = createEnlaceHookNext<ApiSchema>("https://api.example.com");
 ```
 
 ### Server-Side Revalidation
@@ -554,10 +555,10 @@ export async function revalidateAction(tags: string[], paths: string[]) {
 
 ```typescript
 // useAPI.ts
-import { createEnlaceHook } from "enlace/next/hook";
+import { createEnlaceHookNext } from "enlace/hook";
 import { revalidateAction } from "./actions";
 
-const useAPI = createEnlaceHook<ApiSchema>("/api", {}, {
+const useAPI = createEnlaceHookNext<ApiSchema>("/api", {}, {
   revalidator: revalidateAction,
 });
 ```
@@ -596,17 +597,21 @@ Works with Next.js API routes:
 
 ```typescript
 // Client component calling /api/posts
-const useAPI = createEnlaceHook<ApiSchema>("/api");
+const useAPI = createEnlaceHookNext<ApiSchema>("/api");
 ```
 
 ---
 
 ## API Reference
 
-### `createEnlaceHook<TSchema>(baseUrl, options?, hookOptions?)`
+### `createEnlaceHookReact<TSchema>(baseUrl, options?, hookOptions?)`
 
 Creates a React hook for making API calls.
 
+### `createEnlaceHookNext<TSchema>(baseUrl, options?, hookOptions?)`
+
+Creates a Next.js hook with server revalidation support.
+
 **Parameters:**
 - `baseUrl` — Base URL for requests
 - `options` — Default fetch options (headers, cache, etc.)

package/dist/{next/hook → hook}/index.d.mts

@@ -1,4 +1,4 @@
-import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceResponse, WildcardClient, EnlaceClient, EnlaceOptions, EnlaceCallbacks } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -31,6 +31,19 @@ type UseEnlaceQueryOptions = {
 type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
 type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
 type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
+type HookState = {
+    loading: boolean;
+    fetching: boolean;
+    ok: boolean | undefined;
+    data: unknown;
+    error: unknown;
+};
+type TrackedCall = {
+    path: string[];
+    method: string;
+    options: unknown;
+};
+declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
 type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
 type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
 /** Discriminated union for hook response state - enables type narrowing on ok check */
@@ -58,7 +71,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHook factory */
+/** Options for createEnlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -75,6 +88,27 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
+/** Hook type returned by createEnlaceHookReact */
+type EnlaceHook<TSchema> = {
+    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+};
+
+/**
+ * Creates a React hook for making API calls.
+ * Called at module level to create a reusable hook.
+ *
+ * @example
+ * const useAPI = createEnlaceHookReact<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 } }));
+ *
+ * // Selector mode - typed trigger for lazy calls
+ * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
+ * onClick={() => trigger({ body: { id: 1 } })}
+ */
+declare function createEnlaceHookReact<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -82,21 +116,21 @@ type EnlaceHookOptions = {
  * @param paths - URL paths to revalidate
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlace) */
+/** Next.js-specific options (third argument for createEnlaceNext) */
 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
-     * createEnlace("http://localhost:3000/api/", {}, {
+     * createEnlaceNext("http://localhost:3000/api/", {}, {
      *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
      */
     revalidator?: RevalidateHandler;
 };
-/** Next.js hook options (third argument for createEnlaceHook) - extends React's EnlaceHookOptions */
+/** Next.js hook options (third argument for createEnlaceHookNext) - extends React's EnlaceHookOptions */
 type NextHookOptions = EnlaceHookOptions & Pick<NextOptions, "revalidator">;
 /** Per-request options for Next.js fetch - extends React's base options */
 type NextRequestOptionsBase = ReactRequestOptionsBase & {
@@ -119,7 +153,7 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
 };
 type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
-/** Hook type returned by Next.js createEnlaceHook */
+/** Hook type returned by createEnlaceHookNext */
 type NextEnlaceHook<TSchema> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
     <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
@@ -130,7 +164,7 @@ type NextEnlaceHook<TSchema> = {
  * Uses Next.js-specific features like revalidator for server-side cache invalidation.
  *
  * @example
- * const useAPI = createEnlaceHook<ApiSchema>('https://api.com', {}, {
+ * const useAPI = createEnlaceHookNext<ApiSchema>('https://api.com', {}, {
  *   revalidator: (tags) => revalidateTagsAction(tags),
  *   staleTime: 5000,
  * });
@@ -141,6 +175,6 @@ type NextEnlaceHook<TSchema> = {
  * // Selector mode - trigger for mutations
  * const { trigger } = useAPI((api) => api.posts.delete);
  */
-declare function createEnlaceHook<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema>;
+declare function createEnlaceHookNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema>;
 
-export { createEnlaceHook };
+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 };

package/dist/{next/hook → hook}/index.d.ts

@@ -1,4 +1,4 @@
-import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, WildcardClient, EnlaceClient, EnlaceResponse, EnlaceCallbacks, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceResponse, WildcardClient, EnlaceClient, EnlaceOptions, EnlaceCallbacks } from 'enlace-core';
 
 /** Per-request options for React hooks */
 type ReactRequestOptionsBase = {
@@ -31,6 +31,19 @@ type UseEnlaceQueryOptions = {
 type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
 type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
 type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
+type HookState = {
+    loading: boolean;
+    fetching: boolean;
+    ok: boolean | undefined;
+    data: unknown;
+    error: unknown;
+};
+type TrackedCall = {
+    path: string[];
+    method: string;
+    options: unknown;
+};
+declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
 type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
 type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
 /** Discriminated union for hook response state - enables type narrowing on ok check */
@@ -58,7 +71,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHook factory */
+/** Options for createEnlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -75,6 +88,27 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
+/** Hook type returned by createEnlaceHookReact */
+type EnlaceHook<TSchema> = {
+    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+};
+
+/**
+ * Creates a React hook for making API calls.
+ * Called at module level to create a reusable hook.
+ *
+ * @example
+ * const useAPI = createEnlaceHookReact<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 } }));
+ *
+ * // Selector mode - typed trigger for lazy calls
+ * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
+ * onClick={() => trigger({ body: { id: 1 } })}
+ */
+declare function createEnlaceHookReact<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -82,21 +116,21 @@ type EnlaceHookOptions = {
  * @param paths - URL paths to revalidate
  */
 type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlace) */
+/** Next.js-specific options (third argument for createEnlaceNext) */
 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
-     * createEnlace("http://localhost:3000/api/", {}, {
+     * createEnlaceNext("http://localhost:3000/api/", {}, {
      *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
      */
     revalidator?: RevalidateHandler;
 };
-/** Next.js hook options (third argument for createEnlaceHook) - extends React's EnlaceHookOptions */
+/** Next.js hook options (third argument for createEnlaceHookNext) - extends React's EnlaceHookOptions */
 type NextHookOptions = EnlaceHookOptions & Pick<NextOptions, "revalidator">;
 /** Per-request options for Next.js fetch - extends React's base options */
 type NextRequestOptionsBase = ReactRequestOptionsBase & {
@@ -119,7 +153,7 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
 };
 type NextQueryFn<TSchema, TData, TError> = QueryFn<TSchema, TData, TError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod> = SelectorFn<TSchema, TMethod, NextRequestOptionsBase>;
-/** Hook type returned by Next.js createEnlaceHook */
+/** Hook type returned by createEnlaceHookNext */
 type NextEnlaceHook<TSchema> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
     <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
@@ -130,7 +164,7 @@ type NextEnlaceHook<TSchema> = {
  * Uses Next.js-specific features like revalidator for server-side cache invalidation.
  *
  * @example
- * const useAPI = createEnlaceHook<ApiSchema>('https://api.com', {}, {
+ * const useAPI = createEnlaceHookNext<ApiSchema>('https://api.com', {}, {
  *   revalidator: (tags) => revalidateTagsAction(tags),
  *   staleTime: 5000,
  * });
@@ -141,6 +175,6 @@ type NextEnlaceHook<TSchema> = {
  * // Selector mode - trigger for mutations
  * const { trigger } = useAPI((api) => api.posts.delete);
  */
-declare function createEnlaceHook<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema>;
+declare function createEnlaceHookNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema>;
 
-export { createEnlaceHook };
+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 };

package/dist/{next/hook → hook}/index.js

@@ -17,85 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/next/createEnlaceHook.ts
-var createEnlaceHook_exports = {};
-__export(createEnlaceHook_exports, {
-  createEnlaceHook: () => createEnlaceHook
+// src/hook/index.ts
+var hook_exports = {};
+__export(hook_exports, {
+  HTTP_METHODS: () => HTTP_METHODS,
+  createEnlaceHookNext: () => createEnlaceHookNext,
+  createEnlaceHookReact: () => createEnlaceHookReact
 });
-module.exports = __toCommonJS(createEnlaceHook_exports);
+module.exports = __toCommonJS(hook_exports);
 
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createEnlace: () => createEnlace
-});
-var import_enlace_core2 = require("enlace-core");
-
-// src/next/fetch.ts
+// src/react/createEnlaceHookReact.ts
 var import_enlace_core = require("enlace-core");
 
-// src/utils/generateTags.ts
-function generateTags(path) {
-  return path.map((_, i) => path.slice(0, i + 1).join("/"));
-}
-
-// src/next/fetch.ts
-async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
-  const {
-    autoGenerateTags = true,
-    autoRevalidateTags = true,
-    revalidator,
-    onSuccess,
-    ...coreOptions
-  } = combinedOptions;
-  const isGet = method === "GET";
-  const autoTags = generateTags(path);
-  const nextOnSuccess = (payload) => {
-    if (!isGet && !requestOptions?.skipRevalidator) {
-      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
-      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
-      if (revalidateTags.length || revalidatePaths.length) {
-        revalidator?.(revalidateTags, revalidatePaths);
-      }
-    }
-    onSuccess?.(payload);
-  };
-  const nextRequestOptions = { ...requestOptions };
-  if (isGet) {
-    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
-    const nextFetchOptions = {};
-    if (tags) {
-      nextFetchOptions.tags = tags;
-    }
-    if (requestOptions?.revalidate !== void 0) {
-      nextFetchOptions.revalidate = requestOptions.revalidate;
-    }
-    nextRequestOptions.next = nextFetchOptions;
-  }
-  return (0, import_enlace_core.executeFetch)(
-    baseUrl,
-    path,
-    method,
-    { ...coreOptions, onSuccess: nextOnSuccess },
-    nextRequestOptions
-  );
-}
-
-// src/next/index.ts
-__reExport(next_exports, require("enlace-core"));
-function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
-  const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return (0, import_enlace_core2.createProxyHandler)(
-    baseUrl,
-    combinedOptions,
-    [],
-    executeNextFetch
-  );
-}
-
 // src/react/useQueryMode.ts
 var import_react = require("react");
 
@@ -140,6 +75,11 @@ function hookReducer(state, action) {
   }
 }
 
+// src/utils/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
+}
+
 // src/utils/sortObjectKeys.ts
 function sortObjectKeys(obj) {
   if (obj === null || typeof obj !== "object") return obj;
@@ -344,6 +284,38 @@ function useQueryMode(api, trackedCall, options) {
   return state;
 }
 
+// src/react/types.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+
+// src/react/trackingProxy.ts
+function createTrackingProxy(onTrack) {
+  const createProxy = (path = []) => {
+    return new Proxy(() => {
+    }, {
+      get(_, prop) {
+        if (HTTP_METHODS.includes(prop)) {
+          const methodFn = (options) => {
+            onTrack({
+              trackedCall: { path, method: prop, options },
+              selectorPath: null,
+              selectorMethod: null
+            });
+            return Promise.resolve({ ok: true, data: void 0 });
+          };
+          onTrack({
+            trackedCall: null,
+            selectorPath: path,
+            selectorMethod: prop
+          });
+          return methodFn;
+        }
+        return createProxy([...path, prop]);
+      }
+    });
+  };
+  return createProxy();
+}
+
 // src/react/useSelectorMode.ts
 var import_react2 = require("react");
 function resolvePath2(path, pathParams) {
@@ -411,47 +383,113 @@ function useSelectorMode(config) {
   };
 }
 
-// src/react/types.ts
-var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+// src/react/createEnlaceHookReact.ts
+function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    staleTime = 0,
+    onSuccess,
+    onError
+  } = hookOptions;
+  const api = (0, import_enlace_core.createEnlace)(baseUrl, defaultOptions, { onSuccess, onError });
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
+    let trackingResult = {
+      trackedCall: null,
+      selectorPath: null,
+      selectorMethod: null
+    };
+    const trackingProxy = createTrackingProxy((result2) => {
+      trackingResult = result2;
+    });
+    const result = selectorOrQuery(
+      trackingProxy
+    );
+    if (typeof result === "function") {
+      const actualResult = selectorOrQuery(api);
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: trackingResult.selectorPath ?? [],
+        methodName: trackingResult.selectorMethod ?? "",
+        autoRevalidateTags
+      });
+    }
+    return useQueryMode(
+      api,
+      trackingResult.trackedCall,
+      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+    );
+  }
+  return useEnlaceHook;
+}
 
-// src/react/trackingProxy.ts
-function createTrackingProxy(onTrack) {
-  const createProxy = (path = []) => {
-    return new Proxy(() => {
-    }, {
-      get(_, prop) {
-        if (HTTP_METHODS.includes(prop)) {
-          const methodFn = (options) => {
-            onTrack({
-              trackedCall: { path, method: prop, options },
-              selectorPath: null,
-              selectorMethod: null
-            });
-            return Promise.resolve({ ok: true, data: void 0 });
-          };
-          onTrack({
-            trackedCall: null,
-            selectorPath: path,
-            selectorMethod: prop
-          });
-          return methodFn;
-        }
-        return createProxy([...path, prop]);
+// src/next/index.ts
+var import_enlace_core3 = require("enlace-core");
+
+// src/next/fetch.ts
+var import_enlace_core2 = require("enlace-core");
+async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    revalidator,
+    onSuccess,
+    ...coreOptions
+  } = combinedOptions;
+  const isGet = method === "GET";
+  const autoTags = generateTags(path);
+  const nextOnSuccess = (payload) => {
+    if (!isGet && !requestOptions?.skipRevalidator) {
+      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+      if (revalidateTags.length || revalidatePaths.length) {
+        revalidator?.(revalidateTags, revalidatePaths);
       }
-    });
+    }
+    onSuccess?.(payload);
   };
-  return createProxy();
+  const nextRequestOptions = { ...requestOptions };
+  if (isGet) {
+    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
+    const nextFetchOptions = {};
+    if (tags) {
+      nextFetchOptions.tags = tags;
+    }
+    if (requestOptions?.revalidate !== void 0) {
+      nextFetchOptions.revalidate = requestOptions.revalidate;
+    }
+    nextRequestOptions.next = nextFetchOptions;
+  }
+  return (0, import_enlace_core2.executeFetch)(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
+}
+
+// src/next/index.ts
+function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return (0, import_enlace_core3.createProxyHandler)(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 
-// src/next/createEnlaceHook.ts
-function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/createEnlaceHookNext.ts
+function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlace(baseUrl, defaultOptions, {
+  const api = createEnlaceNext(baseUrl, defaultOptions, {
     autoGenerateTags,
     autoRevalidateTags,
     ...nextOptions