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

package/dist/index.d.ts

@@ -1,121 +1,83 @@
-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 { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceCallbacks, EnlaceOptions, WildcardClient, EnlaceClient } 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[];
+    /**
+     * Path parameters for dynamic URL segments.
+     * Used to replace :paramName placeholders in the URL path.
+     * @example
+     * // With path api.products[':id'].delete
+     * trigger({ pathParams: { id: '123' } }) // → DELETE /products/123
+     */
+    pathParams?: Record<string, string | number>;
 };
-type MethodDefinition = {
-    data: unknown;
-    error: unknown;
-    body?: unknown;
+/** Options for createEnlaceHookReact factory */
+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;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
+
 /**
- * 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>;
- *     };
- *   };
- * };
+ * Handler function called after successful mutations to trigger server-side revalidation.
+ * @param tags - Cache tags to revalidate
+ * @param paths - URL paths to revalidate
  */
-type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
-    data: TData;
-    error: TError;
-} : {
-    data: TData;
-    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 RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
+/** 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
+     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
+     * });
+     * ```
+     */
+    revalidator?: RevalidateHandler;
 };
-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>;
+/** Per-request options for Next.js fetch - extends React's base options */
+type NextRequestOptionsBase = ReactRequestOptionsBase & {
+    /** Time in seconds to revalidate, or false to disable */
+    revalidate?: number | false;
+    /**
+     * URL paths to revalidate after mutation
+     * This doesn't do anything on the client by itself - it's passed to the revalidator handler.
+     * You must implement the revalidation logic in the revalidator.
+     */
+    revalidatePaths?: string[];
+    /**
+     * Skip server-side revalidation for this request.
+     * Useful when autoRevalidateTags is enabled but you want to opt-out for specific mutations.
+     * You can still pass empty [] to revalidateTags to skip triggering revalidation.
+     * But this flag can be used if you want to revalidate client-side and skip server-side entirely.
+     * Eg. you don't fetch any data on server component and you might want to skip the overhead of revalidation.
+     */
+    skipRevalidator?: boolean;
 };
-type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
-    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
-    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
-};
-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 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.
- *
- * @example
- * // Typed mode - with schema
- * const api = createEnlace<MyApi>('https://api.example.com');
- *
- * // Untyped mode - no schema
- * const api = createEnlace('https://api.example.com');
- */
-declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
+declare function createEnlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
 
-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 NextOptions, type NextRequestOptionsBase, createEnlaceNext };

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,77 @@ 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
+  createEnlaceNext: () => createEnlaceNext
 });
 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 });
-  }
-  return url.toString();
-}
+// src/next/index.ts
+var import_enlace_core2 = require("enlace-core");
 
-// 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/next/fetch.ts
+var import_enlace_core = require("enlace-core");
 
-// 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/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
 }
 
-// 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
-  };
-  if (headers) {
-    fetchOptions.headers = headers;
-  }
-  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;
+// 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);
       }
-    } else {
-      fetchOptions.body = requestOptions.body;
     }
-  }
-  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 {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
+    onSuccess?.(payload);
   };
-}
-
-// 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);
-      }
-      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
+  const nextRequestOptions = { ...requestOptions };
+  if (isGet) {
+    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
+    const nextFetchOptions = {};
+    if (tags) {
+      nextFetchOptions.tags = tags;
     }
-  };
-  return new Proxy({}, handler);
+    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/core/index.ts
-function createEnlace(baseUrl, defaultOptions = {}) {
-  return createProxyHandler(baseUrl, defaultOptions);
+// src/next/index.ts
+function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return (0, import_enlace_core2.createProxyHandler)(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }

package/dist/index.mjs

@@ -1,104 +1,73 @@
-// src/utils/buildUrl.ts
-import qs from "query-string";
-function buildUrl(baseUrl, path, query) {
-  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-  const url = new URL(path.join("/"), normalizedBase);
-  if (query) {
-    url.search = qs.stringify(query, { skipNull: true, skipEmptyString: true });
-  }
-  return url.toString();
-}
+// src/index.ts
+export * from "enlace-core";
 
-// 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/next/index.ts
+import {
+  createProxyHandler
+} from "enlace-core";
 
-// 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/next/fetch.ts
+import {
+  executeFetch
+} from "enlace-core";
 
-// 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
-  };
-  if (headers) {
-    fetchOptions.headers = headers;
-  }
-  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;
-      }
-    } else {
-      fetchOptions.body = requestOptions.body;
-    }
-  }
-  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 {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
+// src/utils/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
 }
 
-// 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/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);
       }
-      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
     }
+    onSuccess?.(payload);
   };
-  return new Proxy({}, handler);
+  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 executeFetch(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
 }
 
-// src/core/index.ts
-function createEnlace(baseUrl, defaultOptions = {}) {
-  return createProxyHandler(baseUrl, defaultOptions);
+// src/next/index.ts
+function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return createProxyHandler(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 export {
-  createEnlace,
-  createProxyHandler,
-  executeFetch
+  createEnlaceNext
 };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "enlace",
-  "version": "0.0.0-alpha.4",
+  "version": "0.0.1-beta.10",
+  "license": "MIT",
   "files": [
     "dist"
   ],
@@ -10,37 +11,22 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
-    "./next": {
-      "types": "./dist/next/index.d.ts",
-      "import": "./dist/next/index.mjs",
-      "require": "./dist/next/index.js"
+    "./hook": {
+      "types": "./dist/hook/index.d.ts",
+      "import": "./dist/hook/index.mjs",
+      "require": "./dist/hook/index.js"
     }
   },
-  "license": "MIT",
-  "scripts": {
-    "dev": "tsup --watch",
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --max-warnings 0",
-    "prepublishOnly": "npm run build && npm run typecheck && npm run lint"
+  "dependencies": {
+    "enlace-core": "0.0.1-beta.8"
   },
   "peerDependencies": {
     "react": "^19"
   },
-  "devDependencies": {
-    "@eslint/js": "^9.39.1",
-    "@types/react": "^19.1.0",
-    "eslint": "^9.39.1",
-    "eslint-plugin-react": "^7.37.5",
-    "globals": "^16.5.0",
-    "jiti": "^2.6.1",
-    "prettier": "^3.7.4",
-    "tsup": "^8.5.1",
-    "tsx": "^4.21.0",
-    "typescript": "5.9.2",
-    "typescript-eslint": "^8.48.1"
-  },
-  "dependencies": {
-    "query-string": "^9.3.1"
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --max-warnings 0"
   }
-}
+}