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

package/dist/hook/index.js

@@ -0,0 +1,516 @@
+"use client";
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hook/index.ts
+var hook_exports = {};
+__export(hook_exports, {
+  HTTP_METHODS: () => HTTP_METHODS,
+  createEnlaceHookNext: () => createEnlaceHookNext,
+  createEnlaceHookReact: () => createEnlaceHookReact
+});
+module.exports = __toCommonJS(hook_exports);
+
+// src/react/createEnlaceHookReact.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,
+  data: void 0,
+  error: void 0
+};
+function hookReducer(state, action) {
+  switch (action.type) {
+    case "RESET":
+      return action.state ?? initialState;
+    case "FETCH_START":
+      return {
+        ...state,
+        loading: state.data === void 0,
+        fetching: true
+      };
+    case "FETCH_SUCCESS":
+      return {
+        loading: false,
+        fetching: false,
+        data: action.data,
+        error: void 0
+      };
+    case "FETCH_ERROR":
+      return {
+        loading: false,
+        fetching: false,
+        data: void 0,
+        error: action.error
+      };
+    case "SYNC_CACHE":
+      return action.state;
+    default:
+      return state;
+  }
+}
+
+// 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;
+  if (Array.isArray(obj)) return obj.map(sortObjectKeys);
+  return Object.keys(obj).sort().reduce(
+    (sorted, key) => {
+      sorted[key] = sortObjectKeys(obj[key]);
+      return sorted;
+    },
+    {}
+  );
+}
+
+// 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 ("data" in entry || "error" in entry) {
+      delete existing.promise;
+    }
+    Object.assign(existing, entry);
+    existing.subscribers.forEach((cb) => cb());
+  } else {
+    cache.set(key, {
+      data: void 0,
+      error: 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,
+      timestamp: 0,
+      tags: [],
+      subscribers: /* @__PURE__ */ new Set()
+    });
+    entry = cache.get(key);
+  }
+  entry.subscribers.add(callback);
+  return () => {
+    entry.subscribers.delete(callback);
+  };
+}
+function isStale(key, staleTime) {
+  const entry = cache.get(key);
+  if (!entry) return true;
+  return Date.now() - entry.timestamp > staleTime;
+}
+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.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 resolvePath(path, pathParams) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
+function useQueryMode(api, trackedCall, options) {
+  const { autoGenerateTags, staleTime, enabled } = options;
+  const queryKey = createQueryKey(trackedCall);
+  const requestOptions = trackedCall.options;
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
+  const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
+  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,
+      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;
+    if (!enabled) {
+      dispatch({ type: "RESET" });
+      return () => {
+        mountedRef.current = false;
+      };
+    }
+    dispatch({ type: "RESET", state: getCacheState(true) });
+    const doFetch = () => {
+      const cached2 = getCache(queryKey);
+      if (cached2?.promise) {
+        return;
+      }
+      dispatch({ type: "FETCH_START" });
+      let current = api;
+      for (const segment of resolvedPath) {
+        current = current[segment];
+      }
+      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, {
+        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 {
+      doFetch();
+    }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
+    return () => {
+      mountedRef.current = false;
+      fetchRef.current = null;
+      unsubscribe();
+    };
+  }, [queryKey, enabled]);
+  (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({ status: 200, data: void 0, error: 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) {
+  if (!pathParams) return path;
+  return path.map((segment) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      const value = pathParams[paramName];
+      if (value === void 0) {
+        throw new Error(`Missing path parameter: ${paramName}`);
+      }
+      return String(value);
+    }
+    return segment;
+  });
+}
+function hasPathParams(path) {
+  return path.some((segment) => segment.startsWith(":"));
+}
+function useSelectorMode(config) {
+  const { method, api, path, methodName, autoRevalidateTags } = config;
+  const [state, dispatch] = (0, import_react2.useReducer)(hookReducer, initialState);
+  const methodRef = (0, import_react2.useRef)(method);
+  const apiRef = (0, import_react2.useRef)(api);
+  const triggerRef = (0, import_react2.useRef)(null);
+  const pathRef = (0, import_react2.useRef)(path);
+  const methodNameRef = (0, import_react2.useRef)(methodName);
+  const autoRevalidateRef = (0, import_react2.useRef)(autoRevalidateTags);
+  methodRef.current = method;
+  apiRef.current = api;
+  pathRef.current = path;
+  methodNameRef.current = methodName;
+  autoRevalidateRef.current = autoRevalidateTags;
+  if (!triggerRef.current) {
+    triggerRef.current = (async (...args) => {
+      dispatch({ type: "FETCH_START" });
+      const options = args[0];
+      const resolvedPath = resolvePath2(pathRef.current, options?.pathParams);
+      let res;
+      if (hasPathParams(pathRef.current)) {
+        let current = apiRef.current;
+        for (const segment of resolvedPath) {
+          current = current[segment];
+        }
+        const resolvedMethod = current[methodNameRef.current];
+        res = await resolvedMethod(...args);
+      } else {
+        res = await methodRef.current(...args);
+      }
+      if (!res.error) {
+        dispatch({ type: "FETCH_SUCCESS", data: res.data });
+        const tagsToInvalidate = options?.revalidateTags ?? (autoRevalidateRef.current ? generateTags(resolvedPath) : []);
+        if (tagsToInvalidate.length > 0) {
+          invalidateTags(tagsToInvalidate);
+        }
+      } else {
+        dispatch({ type: "FETCH_ERROR", error: res.error });
+      }
+      return res;
+    });
+  }
+  return {
+    trigger: triggerRef.current,
+    ...state
+  };
+}
+
+// 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/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);
+  };
+  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/createEnlaceHookNext.ts
+function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    staleTime = 0,
+    ...nextOptions
+  } = hookOptions;
+  const api = createEnlaceNext(baseUrl, defaultOptions, {
+    autoGenerateTags,
+    autoRevalidateTags,
+    ...nextOptions
+  });
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
+    let trackedCall = null;
+    let selectorPath = null;
+    let selectorMethod = null;
+    const trackingProxy = createTrackingProxy((result2) => {
+      trackedCall = result2.trackedCall;
+      selectorPath = result2.selectorPath;
+      selectorMethod = result2.selectorMethod;
+    });
+    const result = selectorOrQuery(trackingProxy);
+    if (typeof result === "function") {
+      const actualResult = selectorOrQuery(api);
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: selectorPath ?? [],
+        methodName: selectorMethod ?? "",
+        autoRevalidateTags
+      });
+    }
+    return useQueryMode(
+      api,
+      trackedCall,
+      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+    );
+  }
+  return useEnlaceHook;
+}