enlace 0.0.0-alpha.4 → 0.0.1-beta.2

package/dist/index.d.ts

@@ -1,121 +1,97 @@
-type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-type SchemaMethod = "$get" | "$post" | "$put" | "$patch" | "$delete";
-type EnlaceResponse<TData, TError> = {
-    ok: true;
-    status: number;
-    data: TData;
-    error?: never;
-} | {
-    ok: false;
-    status: number;
-    data?: never;
-    error: TError;
-};
-type EnlaceOptions = Omit<RequestInit, "method" | "body">;
-type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
-type RequestOptions<TBody = never> = {
-    body?: TBody;
-    query?: Record<string, string | number | boolean | undefined>;
-    headers?: HeadersInit;
-    cache?: RequestCache;
+import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+export * from 'enlace-core';
+
+/** Per-request options for React hooks */
+type ReactRequestOptionsBase = {
+    /**
+     * Cache tags for caching (GET requests only)
+     * This will auto generate tags from the URL path if not provided and autoGenerateTags is enabled.
+     * But can be manually specified to override auto-generation.
+     * */
+    tags?: string[];
+    /** Tags to invalidate after mutation (triggers refetch in matching queries) */
+    revalidateTags?: string[];
 };
-type MethodDefinition = {
+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;
-    body?: unknown;
 };
-/**
- * Helper to define an endpoint with proper typing.
- * Provides cleaner syntax than writing { data, error, body } manually.
- *
- * @example
- * type MyApi = {
- *   posts: {
- *     $get: Endpoint<Post[], ApiError>;
- *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
- *     _: {
- *       $get: Endpoint<Post, NotFoundError>;
- *     };
- *   };
- * };
- */
-type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
-    data: TData;
-    error: TError;
-} : {
+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 */
+type HookResponseState<TData, TError> = {
+    ok: undefined;
+    data: undefined;
+    error: undefined;
+} | {
+    ok: true;
     data: TData;
+    error: undefined;
+} | {
+    ok: false;
+    data: undefined;
     error: TError;
-    body: TBody;
-};
-type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: infer M;
-} ? M extends MethodDefinition ? M : never : never;
-type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    data: infer D;
-} ? D : never;
-type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    error: infer E;
-} ? E : never;
-type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    body: infer B;
-} ? B : never;
-type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: MethodDefinition;
-} ? true : false;
-type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
-type IsSpecialKey<K> = K extends SchemaMethod | "_" ? true : false;
-type StaticPathKeys<TSchema> = {
-    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
 };
-type ExtractDynamicSchema<TSchema> = TSchema extends {
-    _: infer D;
-} ? D : never;
-type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
-type HttpMethods<TSchema, TRequestOptionsBase = object> = {
-    get: MethodOrPath<TSchema, "get", "$get", TRequestOptionsBase>;
-    post: MethodOrPath<TSchema, "post", "$post", TRequestOptionsBase>;
-    put: MethodOrPath<TSchema, "put", "$put", TRequestOptionsBase>;
-    patch: MethodOrPath<TSchema, "patch", "$patch", TRequestOptionsBase>;
-    delete: MethodOrPath<TSchema, "delete", "$delete", TRequestOptionsBase>;
-};
-type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
-    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
-    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+/** Result when hook is called with query function (auto-fetch mode) */
+type UseEnlaceQueryResult<TData, TError> = {
+    loading: boolean;
+    fetching: boolean;
+} & HookResponseState<TData, TError>;
+/** Result when hook is called with method selector (trigger mode) */
+type UseEnlaceSelectorResult<TMethod> = {
+    trigger: TMethod;
+    loading: boolean;
+    fetching: boolean;
+} & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
+
+type EnlaceHookOptions = {
+    /**
+     * Auto-generate cache tags from URL path for GET requests.
+     * e.g., `/posts/1` generates tags `['posts', 'posts/1']`
+     * @default true
+     */
+    autoGenerateTags?: boolean;
+    /** Auto-revalidate generated tags after successful mutations. @default true */
+    autoRevalidateTags?: boolean;
+    /** Time in ms before cached data is considered stale. @default 0 (always stale) */
+    staleTime?: number;
 };
-type MethodNameKeys = "get" | "post" | "put" | "patch" | "delete";
-type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
-    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+type EnlaceHook<TSchema> = {
+    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
-type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
 /**
- * Wildcard client type - allows any path access when no schema is provided.
- * All methods are available at every level and return unknown types.
- */
-type WildcardClient<TRequestOptionsBase = object> = {
-    get: WildcardMethodFn<TRequestOptionsBase>;
-    post: WildcardMethodFn<TRequestOptionsBase>;
-    put: WildcardMethodFn<TRequestOptionsBase>;
-    patch: WildcardMethodFn<TRequestOptionsBase>;
-    delete: WildcardMethodFn<TRequestOptionsBase>;
-} & {
-    [key: string]: WildcardClient<TRequestOptionsBase>;
-    [key: number]: WildcardClient<TRequestOptionsBase>;
-};
-
-declare function createProxyHandler<TSchema extends object, TOptions = EnlaceOptions>(baseUrl: string, defaultOptions: TOptions, path?: string[], fetchExecutor?: FetchExecutor<TOptions, RequestOptions<unknown>>): TSchema;
-
-declare function executeFetch<TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: EnlaceOptions, requestOptions?: RequestOptions<unknown>): Promise<EnlaceResponse<TData, TError>>;
-
-/**
- * Creates an API client.
+ * Creates a React hook for making API calls.
+ * Called at module level to create a reusable hook.
  *
  * @example
- * // Typed mode - with schema
- * const api = createEnlace<MyApi>('https://api.example.com');
+ * const useAPI = createEnlaceHook<ApiSchema>('https://api.com');
  *
- * // Untyped mode - no schema
- * const api = createEnlace('https://api.example.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 createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
+declare function createEnlaceHook<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
+
+type Listener = (tags: string[]) => void;
+declare function invalidateTags(tags: string[]): void;
+declare function onRevalidate(callback: Listener): () => void;
+
+declare function clearCache(key?: string): void;
 
-export { type Endpoint, type EnlaceClient, type EnlaceOptions, type EnlaceResponse, type FetchExecutor, type HttpMethod, type MethodDefinition, type RequestOptions, type SchemaMethod, type WildcardClient, createEnlace, createProxyHandler, executeFetch };
+export { type ApiClient, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,121 +15,355 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  createEnlace: () => createEnlace,
-  createProxyHandler: () => createProxyHandler,
-  executeFetch: () => executeFetch
+  HTTP_METHODS: () => HTTP_METHODS,
+  clearCache: () => clearCache,
+  createEnlaceHook: () => createEnlaceHook,
+  invalidateTags: () => invalidateTags,
+  onRevalidate: () => onRevalidate
 });
 module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("enlace-core"), module.exports);
 
-// src/utils/buildUrl.ts
-var import_query_string = __toESM(require("query-string"));
-function buildUrl(baseUrl, path, query) {
-  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-  const url = new URL(path.join("/"), normalizedBase);
-  if (query) {
-    url.search = import_query_string.default.stringify(query, { skipNull: true, skipEmptyString: true });
+// src/react/createEnlaceHook.ts
+var import_enlace_core = require("enlace-core");
+
+// src/react/useQueryMode.ts
+var import_react = require("react");
+
+// src/react/reducer.ts
+var initialState = {
+  loading: false,
+  fetching: false,
+  ok: void 0,
+  data: void 0,
+  error: void 0
+};
+function hookReducer(state, action) {
+  switch (action.type) {
+    case "RESET":
+      return action.state;
+    case "FETCH_START":
+      return {
+        ...state,
+        loading: state.data === void 0,
+        fetching: true
+      };
+    case "FETCH_SUCCESS":
+      return {
+        loading: false,
+        fetching: false,
+        ok: true,
+        data: action.data,
+        error: void 0
+      };
+    case "FETCH_ERROR":
+      return {
+        loading: false,
+        fetching: false,
+        ok: false,
+        data: void 0,
+        error: action.error
+      };
+    case "SYNC_CACHE":
+      return action.state;
+    default:
+      return state;
   }
-  return url.toString();
 }
 
-// src/utils/isJsonBody.ts
-function isJsonBody(body) {
-  if (body === null || body === void 0) return false;
-  if (body instanceof FormData) return false;
-  if (body instanceof Blob) return false;
-  if (body instanceof ArrayBuffer) return false;
-  if (body instanceof URLSearchParams) return false;
-  if (body instanceof ReadableStream) return false;
-  if (typeof body === "string") return false;
-  return typeof body === "object";
+// src/utils/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
 }
 
-// src/utils/mergeHeaders.ts
-function mergeHeaders(defaultHeaders, requestHeaders) {
-  if (!defaultHeaders && !requestHeaders) return void 0;
-  if (!defaultHeaders) return requestHeaders;
-  if (!requestHeaders) return defaultHeaders;
-  return {
-    ...Object.fromEntries(new Headers(defaultHeaders)),
-    ...Object.fromEntries(new Headers(requestHeaders))
-  };
+// src/utils/sortObjectKeys.ts
+function sortObjectKeys(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(sortObjectKeys);
+  return Object.keys(obj).sort().reduce(
+    (sorted, key) => {
+      sorted[key] = sortObjectKeys(obj[key]);
+      return sorted;
+    },
+    {}
+  );
 }
 
-// src/core/fetch.ts
-async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const fetchOptions = {
-    ...defaultOptions,
-    method
+// src/react/cache.ts
+var cache = /* @__PURE__ */ new Map();
+function createQueryKey(tracked) {
+  return JSON.stringify(
+    sortObjectKeys({
+      path: tracked.path,
+      method: tracked.method,
+      options: tracked.options
+    })
+  );
+}
+function getCache(key) {
+  return cache.get(key);
+}
+function setCache(key, entry) {
+  const existing = cache.get(key);
+  if (existing) {
+    if ("ok" in entry) {
+      delete existing.promise;
+    }
+    Object.assign(existing, entry);
+    existing.subscribers.forEach((cb) => cb());
+  } else {
+    cache.set(key, {
+      data: void 0,
+      error: void 0,
+      ok: void 0,
+      timestamp: 0,
+      tags: [],
+      subscribers: /* @__PURE__ */ new Set(),
+      ...entry
+    });
+  }
+}
+function subscribeCache(key, callback) {
+  let entry = cache.get(key);
+  if (!entry) {
+    cache.set(key, {
+      data: void 0,
+      error: void 0,
+      ok: void 0,
+      timestamp: 0,
+      tags: [],
+      subscribers: /* @__PURE__ */ new Set()
+    });
+    entry = cache.get(key);
+  }
+  entry.subscribers.add(callback);
+  return () => {
+    entry.subscribers.delete(callback);
   };
-  if (headers) {
-    fetchOptions.headers = headers;
+}
+function isStale(key, staleTime) {
+  const entry = cache.get(key);
+  if (!entry) return true;
+  return Date.now() - entry.timestamp > staleTime;
+}
+function clearCache(key) {
+  if (key) {
+    cache.delete(key);
+  } else {
+    cache.clear();
   }
-  if (requestOptions?.body !== void 0) {
-    if (isJsonBody(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
-      if (headers) {
-        fetchOptions.headers = headers;
+}
+function clearCacheByTags(tags) {
+  cache.forEach((entry) => {
+    const hasMatch = entry.tags.some((tag) => tags.includes(tag));
+    if (hasMatch) {
+      entry.data = void 0;
+      entry.error = void 0;
+      entry.ok = void 0;
+      entry.timestamp = 0;
+      delete entry.promise;
+    }
+  });
+}
+
+// src/react/revalidator.ts
+var listeners = /* @__PURE__ */ new Set();
+function invalidateTags(tags) {
+  clearCacheByTags(tags);
+  listeners.forEach((listener) => listener(tags));
+}
+function onRevalidate(callback) {
+  listeners.add(callback);
+  return () => listeners.delete(callback);
+}
+
+// src/react/useQueryMode.ts
+function useQueryMode(api, trackedCall, options) {
+  const { autoGenerateTags, staleTime } = options;
+  const queryKey = createQueryKey(trackedCall);
+  const requestOptions = trackedCall.options;
+  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(trackedCall.path) : []);
+  const getCacheState = (includeNeedsFetch = false) => {
+    const cached = getCache(queryKey);
+    const hasCachedData = cached?.data !== void 0;
+    const isFetching = !!cached?.promise;
+    const needsFetch = includeNeedsFetch && (!hasCachedData || isStale(queryKey, staleTime));
+    return {
+      loading: !hasCachedData && (isFetching || needsFetch),
+      fetching: isFetching || needsFetch,
+      ok: cached?.ok,
+      data: cached?.data,
+      error: cached?.error
+    };
+  };
+  const [state, dispatch] = (0, import_react.useReducer)(hookReducer, null, () => getCacheState(true));
+  const mountedRef = (0, import_react.useRef)(true);
+  const fetchRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    mountedRef.current = true;
+    dispatch({ type: "RESET", state: getCacheState(true) });
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
+    const doFetch = () => {
+      const cached2 = getCache(queryKey);
+      if (cached2?.promise) {
+        return;
       }
+      dispatch({ type: "FETCH_START" });
+      let current = api;
+      for (const segment of trackedCall.path) {
+        current = current[segment];
+      }
+      const method = current[trackedCall.method];
+      const fetchPromise = method(trackedCall.options).then((res) => {
+        if (mountedRef.current) {
+          setCache(queryKey, {
+            data: res.ok ? res.data : void 0,
+            error: res.ok ? void 0 : res.error,
+            ok: res.ok,
+            timestamp: Date.now(),
+            tags: queryTags
+          });
+        }
+      });
+      setCache(queryKey, {
+        promise: fetchPromise,
+        tags: queryTags
+      });
+    };
+    fetchRef.current = doFetch;
+    const cached = getCache(queryKey);
+    if (cached?.data !== void 0 && !isStale(queryKey, staleTime)) {
+      dispatch({ type: "SYNC_CACHE", state: getCacheState() });
     } else {
-      fetchOptions.body = requestOptions.body;
+      doFetch();
     }
-  }
-  const response = await fetch(url, fetchOptions);
-  const contentType = response.headers.get("content-type");
-  const isJson = contentType?.includes("application/json");
-  if (response.ok) {
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
+    return () => {
+      mountedRef.current = false;
+      fetchRef.current = null;
+      unsubscribe();
     };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
+  }, [queryKey]);
+  (0, import_react.useEffect)(() => {
+    if (queryTags.length === 0) return;
+    return onRevalidate((invalidatedTags) => {
+      const hasMatch = invalidatedTags.some((tag) => queryTags.includes(tag));
+      if (hasMatch && mountedRef.current && fetchRef.current) {
+        fetchRef.current();
+      }
+    });
+  }, [JSON.stringify(queryTags)]);
+  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/core/proxy.ts
-var HTTP_METHODS = {
-  get: "GET",
-  post: "POST",
-  put: "PUT",
-  patch: "PATCH",
-  delete: "DELETE"
-};
-function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
-  const handler = {
-    get(_target, prop) {
-      if (typeof prop === "symbol") return void 0;
-      const method = HTTP_METHODS[prop];
-      if (method) {
-        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
+// src/react/useSelectorMode.ts
+var import_react2 = require("react");
+function useSelectorMode(method, path, autoRevalidateTags) {
+  const [state, dispatch] = (0, import_react2.useReducer)(hookReducer, initialState);
+  const methodRef = (0, import_react2.useRef)(method);
+  const triggerRef = (0, import_react2.useRef)(null);
+  const pathRef = (0, import_react2.useRef)(path);
+  const autoRevalidateRef = (0, import_react2.useRef)(autoRevalidateTags);
+  methodRef.current = method;
+  pathRef.current = path;
+  autoRevalidateRef.current = autoRevalidateTags;
+  if (!triggerRef.current) {
+    triggerRef.current = (async (...args) => {
+      dispatch({ type: "FETCH_START" });
+      const res = await methodRef.current(...args);
+      if (res.ok) {
+        dispatch({ type: "FETCH_SUCCESS", data: res.data });
+        const options = args[0];
+        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(pathRef.current) : []);
+        if (tagsToInvalidate.length > 0) {
+          invalidateTags(tagsToInvalidate);
+        }
+      } else {
+        dispatch({ type: "FETCH_ERROR", error: res.error });
       }
-      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
-    }
+      return res;
+    });
+  }
+  return {
+    trigger: triggerRef.current,
+    ...state
   };
-  return new Proxy({}, handler);
 }
 
-// src/core/index.ts
-function createEnlace(baseUrl, defaultOptions = {}) {
-  return createProxyHandler(baseUrl, defaultOptions);
+// src/react/createEnlaceHook.ts
+function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
+  const api = (0, import_enlace_core.createEnlace)(baseUrl, defaultOptions);
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    staleTime = 0
+  } = hookOptions;
+  function useEnlaceHook(selectorOrQuery) {
+    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(
+        actualResult,
+        trackingResult.selectorPath ?? [],
+        autoRevalidateTags
+      );
+    }
+    return useQueryMode(
+      api,
+      trackingResult.trackedCall,
+      { autoGenerateTags, staleTime }
+    );
+  }
+  return useEnlaceHook;
 }