api-core-lib 16.2.0 → 16.12.133

package/dist/client.cjs

@@ -0,0 +1,631 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+
+
+
+
+
+var _chunkJAMEOM7Tcjs = require('./chunk-JAMEOM7T.cjs');
+
+// src/hooks/useApi.ts
+var _react = require('react');
+function buildDynamicPath(template, params) {
+  if (!params) return template;
+  let path = template;
+  for (const key in params) {
+    path = path.replace(new RegExp(`{${key}}`, "g"), String(params[key]));
+  }
+  return path;
+}
+function useApi(axiosInstance, config) {
+  const {
+    endpoint,
+    pathParams,
+    initialData,
+    initialQuery = {},
+    enabled = true,
+    refetchAfterChange = true,
+    requestConfig,
+    onSuccess,
+    onError
+  } = config;
+  const finalEndpoint = _react.useMemo.call(void 0, 
+    () => buildDynamicPath(endpoint, pathParams),
+    [endpoint, pathParams]
+  );
+  const [state, setState] = _react.useState.call(void 0, {
+    data: _nullishCoalesce(initialData, () => ( null)),
+    rawResponse: null,
+    loading: enabled,
+    error: null,
+    success: false,
+    message: void 0,
+    validationErrors: void 0
+  });
+  const [queryOptions, setQueryOptions] = _react.useState.call(void 0, initialQuery);
+  const apiServices = _react.useMemo.call(void 0, 
+    () => _chunkJAMEOM7Tcjs.createApiServices.call(void 0, axiosInstance, finalEndpoint),
+    [axiosInstance, finalEndpoint]
+  );
+  const savedOnSuccess = _react.useRef.call(void 0, onSuccess);
+  const savedOnError = _react.useRef.call(void 0, onError);
+  _react.useEffect.call(void 0, () => {
+    savedOnSuccess.current = onSuccess;
+    savedOnError.current = onError;
+  }, [onSuccess, onError]);
+  const fetchData = _react.useCallback.call(void 0, async (currentQueryOptions) => {
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const finalQuery = currentQueryOptions || queryOptions;
+      const hasQueryParams = Object.keys(finalQuery).length > 0;
+      const queryString = _chunkJAMEOM7Tcjs.buildPaginateQuery.call(void 0, finalQuery);
+      const result = hasQueryParams ? await apiServices.getWithQuery(queryString, requestConfig) : await apiServices.get(void 0, requestConfig);
+      setState(result);
+      if (result.success && savedOnSuccess.current) {
+        savedOnSuccess.current(result.message || "Fetch successful!", _nullishCoalesce(result.data, () => ( void 0)));
+      } else if (!result.success && savedOnError.current) {
+        savedOnError.current(result.message || "Fetch failed", _nullishCoalesce(result.error, () => ( void 0)));
+      }
+    } catch (e) {
+      const apiError = { status: 500, message: e.message || "An unexpected client-side error occurred." };
+      setState((prev) => ({ ...prev, loading: false, error: apiError, success: false }));
+      if (savedOnError.current) {
+        savedOnError.current(apiError.message, apiError);
+      }
+    }
+  }, [apiServices, queryOptions, requestConfig]);
+  _react.useEffect.call(void 0, () => {
+    if (enabled) {
+      fetchData();
+    }
+  }, [enabled, fetchData]);
+  const handleActionResult = _react.useCallback.call(void 0, async (actionPromise) => {
+    setState((prev) => ({ ...prev, loading: true }));
+    try {
+      const result = await actionPromise;
+      if (result.success) {
+        if (savedOnSuccess.current) {
+          savedOnSuccess.current(result.message || "Action successful!", _nullishCoalesce(result.data, () => ( void 0)));
+        }
+        if (refetchAfterChange) {
+          await fetchData(queryOptions);
+        } else {
+          setState((prev) => ({ ...prev, ...result, loading: false }));
+        }
+      } else {
+        if (savedOnError.current) {
+          savedOnError.current(result.message || "Action failed", _nullishCoalesce(result.error, () => ( void 0)));
+        }
+        setState((prev) => ({ ...prev, loading: false, error: result.error, success: false }));
+      }
+      return result;
+    } catch (e) {
+      const apiError = { status: 500, message: e.message || "An unexpected error occurred during action." };
+      setState((prev) => ({ ...prev, loading: false, error: apiError, success: false }));
+      if (savedOnError.current) {
+        savedOnError.current(apiError.message, apiError);
+      }
+      return { data: null, error: apiError, loading: false, success: false, rawResponse: e };
+    }
+  }, [refetchAfterChange, fetchData, queryOptions]);
+  const refetch = _react.useCallback.call(void 0, () => {
+    fetchData();
+  }, [fetchData]);
+  const actions = {
+    fetch: fetchData,
+    create: (newItem, options) => handleActionResult(apiServices.post(newItem, options)),
+    put: (id, item, options) => handleActionResult(apiServices.put(id, item, options)),
+    update: (id, updatedItem, options) => handleActionResult(apiServices.patch(id, updatedItem, options)),
+    remove: (id, options) => handleActionResult(apiServices.remove(id, options)),
+    bulkRemove: (ids, options) => handleActionResult(apiServices.bulkDelete(ids, options))
+  };
+  const query = {
+    options: queryOptions,
+    refetch,
+    setOptions: setQueryOptions,
+    setPage: (page) => setQueryOptions((prev) => ({ ...prev, page })),
+    setLimit: (limit) => setQueryOptions((prev) => ({ ...prev, page: 1, limit })),
+    setSearchTerm: (search) => setQueryOptions((prev) => ({ ...prev, page: 1, search })),
+    setSorting: (sortBy) => setQueryOptions((prev) => ({ ...prev, sortBy })),
+    setFilters: (filter) => setQueryOptions((prev) => ({ ...prev, page: 1, filter })),
+    setQueryParam: (key, value) => setQueryOptions((prev) => ({ ...prev, [key]: value, page: key !== "page" ? 1 : value })),
+    reset: () => setQueryOptions(initialQuery)
+  };
+  return { state, setState, actions, query };
+}
+
+// src/hooks/useApiRecord/index.ts
+
+function buildDynamicPath2(template, params) {
+  if (!params) return template;
+  let path = template;
+  for (const key in params) {
+    path = path.replace(new RegExp(`{${key}}`, "g"), String(params[key]));
+  }
+  return path;
+}
+function useApiRecord(axiosInstance, config) {
+  const {
+    endpoint,
+    pathParams,
+    recordId,
+    initialData,
+    enabled = true,
+    refetchAfterChange = true,
+    requestConfig,
+    onSuccess,
+    onError
+  } = config;
+  const finalEndpoint = _react.useMemo.call(void 0, 
+    () => buildDynamicPath2(endpoint, pathParams),
+    [endpoint, pathParams]
+  );
+  const initialState = _react.useMemo.call(void 0, () => ({
+    data: _nullishCoalesce(initialData, () => ( null)),
+    rawResponse: null,
+    error: null,
+    loading: enabled && !!recordId,
+    success: false,
+    message: void 0,
+    validationErrors: void 0
+  }), [initialData, enabled, recordId]);
+  const [state, setState] = _react.useState.call(void 0, initialState);
+  const savedOnSuccess = _react.useRef.call(void 0, onSuccess);
+  const savedOnError = _react.useRef.call(void 0, onError);
+  _react.useEffect.call(void 0, () => {
+    savedOnSuccess.current = onSuccess;
+    savedOnError.current = onError;
+  }, [onSuccess, onError]);
+  const apiServices = _react.useMemo.call(void 0, 
+    () => _chunkJAMEOM7Tcjs.createApiServices.call(void 0, axiosInstance, finalEndpoint),
+    [axiosInstance, finalEndpoint]
+  );
+  const fetchRecord = _react.useCallback.call(void 0, async () => {
+    if (!recordId) {
+      setState(initialState);
+      return;
+    }
+    setState((prev) => ({ ...prev, loading: true, error: null, success: false }));
+    try {
+      const result = await apiServices.get(recordId, requestConfig);
+      setState(result);
+      if (result.success && savedOnSuccess.current) {
+        savedOnSuccess.current(result.message || "Record fetched successfully!", _nullishCoalesce(result.data, () => ( void 0)));
+      } else if (!result.success && savedOnError.current) {
+        savedOnError.current(result.message || "Fetch failed", _nullishCoalesce(result.error, () => ( void 0)));
+      }
+    } catch (e) {
+      console.error("[useApiRecord Fetch Error]", e);
+      const apiError = {
+        status: _optionalChain([e, 'access', _ => _.response, 'optionalAccess', _2 => _2.status]) || 500,
+        message: e.message || "An unexpected client-side error occurred.",
+        code: e.code
+      };
+      setState((prev) => ({ ...prev, loading: false, success: false, error: apiError }));
+      if (savedOnError.current) {
+        savedOnError.current(apiError.message, apiError);
+      }
+    }
+  }, [apiServices, recordId, requestConfig, initialState]);
+  _react.useEffect.call(void 0, () => {
+    if (enabled) {
+      fetchRecord();
+    }
+  }, [enabled, fetchRecord]);
+  const handleActionResult = _react.useCallback.call(void 0, 
+    async (actionPromise, options) => {
+      setState((prev) => ({ ...prev, loading: true }));
+      try {
+        const result = await actionPromise;
+        if (result.success) {
+          if (savedOnSuccess.current) {
+            savedOnSuccess.current(result.message || "Action successful!", result.data);
+          }
+          const shouldRefetch = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.refetch]), () => ( refetchAfterChange));
+          if (shouldRefetch) {
+            await fetchRecord();
+          } else {
+            setState({ ...result, loading: false, data: result.data });
+          }
+        } else {
+          if (savedOnError.current) {
+            savedOnError.current(result.message || "Action failed", _nullishCoalesce(result.error, () => ( void 0)));
+          }
+          setState((prev) => ({ ...prev, ...result, loading: false }));
+        }
+        return result;
+      } catch (e) {
+        console.error("[useApiRecord Action Error]", e);
+        const apiError = {
+          status: _optionalChain([e, 'access', _4 => _4.response, 'optionalAccess', _5 => _5.status]) || 500,
+          message: e.message || "An unexpected error occurred during the action.",
+          code: e.code
+        };
+        const errorResponse = { ...initialState, loading: false, success: false, error: apiError, rawResponse: e, data: null };
+        setState(errorResponse);
+        if (savedOnError.current) {
+          savedOnError.current(apiError.message, apiError);
+        }
+        return errorResponse;
+      }
+    },
+    [refetchAfterChange, fetchRecord, initialState]
+  );
+  const actions = {
+    fetch: fetchRecord,
+    update: (updatedItem, options) => handleActionResult(apiServices.patch(recordId, updatedItem, { ...requestConfig, ...options }), options),
+    put: (item, options) => handleActionResult(apiServices.put(recordId, item, { ...requestConfig, ...options }), options),
+    remove: (options) => handleActionResult(apiServices.remove(recordId, { ...requestConfig, ...options }), options),
+    resetState: () => setState(initialState)
+  };
+  return { state, setState, actions };
+}
+
+// src/hooks/useDeepCompareEffect/index.ts
+
+var _fastdeepequal = require('fast-deep-equal'); var _fastdeepequal2 = _interopRequireDefault(_fastdeepequal);
+function useDeepCompareEffect(callback, dependencies) {
+  const currentDependenciesRef = _react.useRef.call(void 0, );
+  if (!_fastdeepequal2.default.call(void 0, currentDependenciesRef.current, dependencies)) {
+    currentDependenciesRef.current = dependencies;
+  }
+  _react.useEffect.call(void 0, callback, [currentDependenciesRef.current]);
+}
+
+// src/hooks/useApiModule/useApiModule.ts
+
+var ApiModuleContext = _react.createContext.call(void 0, null);
+var ApiModuleProvider = ApiModuleContext.Provider;
+var createInitialState = () => ({
+  data: null,
+  lastSuccessAt: void 0,
+  meta: void 0,
+  links: void 0,
+  validationErrors: [],
+  error: null,
+  loading: false,
+  success: false,
+  called: false,
+  isStale: false,
+  rawResponse: null
+});
+function useApiActionState(actionConfig, cacheKey, execute, input, enabled) {
+  const getClientSnapshot = () => _chunkJAMEOM7Tcjs.globalStateManager.getSnapshot(cacheKey);
+  const getServerSnapshot = () => _chunkJAMEOM7Tcjs.globalStateManager.getSnapshot(cacheKey);
+  const state = _react.useSyncExternalStore.call(void 0, 
+    (callback) => _chunkJAMEOM7Tcjs.globalStateManager.subscribe(cacheKey, callback),
+    getClientSnapshot,
+    getServerSnapshot
+  );
+  const inputRef = _react.useRef.call(void 0, input);
+  _react.useEffect.call(void 0, () => {
+    inputRef.current = input;
+  }, [input]);
+  const refetch = _react.useCallback.call(void 0, () => {
+    execute(inputRef.current);
+  }, [execute]);
+  const prevCacheKeyRef = _react.useRef.call(void 0, cacheKey);
+  _react.useEffect.call(void 0, () => {
+    if (prevCacheKeyRef.current !== cacheKey && enabled && state.called) {
+      refetch();
+    } else if (enabled && actionConfig.autoFetch && !state.called && !state.loading) {
+      refetch();
+    } else if (enabled && state.isStale && !state.loading) {
+      refetch();
+    }
+    prevCacheKeyRef.current = cacheKey;
+  }, [cacheKey, enabled, state.isStale, state.loading, state.called, actionConfig.autoFetch, refetch]);
+  return state;
+}
+function useApiModule(axiosInstance, moduleConfig, options = {}) {
+  const {
+    refetchOnWindowFocus = true,
+    onSuccess,
+    onError,
+    pathParams: globalPathParams,
+    enabled = true,
+    hydratedState,
+    extraContextData,
+    urlSync,
+    defaultQueryOptions,
+    initialActionsToExecute
+  } = options;
+  const pathParamsString = _react.useMemo.call(void 0, () => JSON.stringify(globalPathParams || {}), [globalPathParams]);
+  const [queryOptions, setQueryOptions] = _react.useState.call(void 0, () => {
+    const initialOptions = {};
+    for (const actionName in moduleConfig.actions) {
+      const actionConfig = moduleConfig.actions[actionName];
+      if (actionConfig._input) {
+        initialOptions[actionName] = { ...actionConfig._input };
+      }
+    }
+    if (defaultQueryOptions) {
+      for (const actionName in defaultQueryOptions) {
+        initialOptions[actionName] = {
+          ...initialOptions[actionName],
+          ...defaultQueryOptions[actionName]
+        };
+      }
+    }
+    return initialOptions;
+  });
+  const lastCallRef = _react.useRef.call(void 0, {});
+  const initialFetchRef = _react.useRef.call(void 0, false);
+  const stableActionsRef = _react.useRef.call(void 0, {});
+  const savedCallbacks = _react.useRef.call(void 0, { onSuccess, onError });
+  _react.useEffect.call(void 0, () => {
+    savedCallbacks.current = { onSuccess, onError };
+  }, [onSuccess, onError]);
+  _react.useEffect.call(void 0, () => {
+    if (hydratedState) {
+      _chunkJAMEOM7Tcjs.globalStateManager.rehydrate(hydratedState);
+    }
+  }, [hydratedState]);
+  _react.useEffect.call(void 0, () => {
+    if (!urlSync) return;
+    const { searchParams, actionsToSync, defaultSyncAction } = urlSync;
+    const params = new URLSearchParams(searchParams);
+    const queryFromUrl = {};
+    params.forEach((value, key) => {
+      const parts = key.split(".");
+      const hasPrefix = parts.length > 1;
+      const actionName = hasPrefix ? parts[0] : defaultSyncAction;
+      const paramKey = hasPrefix ? parts[1] : parts[0];
+      if (actionName && paramKey && actionsToSync.some((a) => a === actionName)) {
+        if (!queryFromUrl[actionName]) queryFromUrl[actionName] = {};
+        const isNum = !isNaN(Number(value)) && value.trim() !== "";
+        queryFromUrl[actionName][paramKey] = isNum ? Number(value) : value;
+      }
+    });
+    if (Object.keys(queryFromUrl).length > 0) {
+      setQueryOptions((prev) => {
+        const newState = { ...prev };
+        for (const actionName in queryFromUrl) {
+          newState[actionName] = { ...newState[actionName], ...queryFromUrl[actionName] };
+        }
+        return newState;
+      });
+    }
+  }, [urlSync]);
+  _react.useEffect.call(void 0, () => {
+    if (!urlSync) return;
+    const { searchParams, updateUrl, actionsToSync, defaultSyncAction } = urlSync;
+    const currentParams = new URLSearchParams(searchParams);
+    let hasChanged = false;
+    for (const actionName in queryOptions) {
+      if (actionsToSync.some((a) => a === actionName)) {
+        const params = queryOptions[actionName];
+        const isDefaultAction = actionName === defaultSyncAction;
+        for (const key in params) {
+          const fullKey = isDefaultAction ? key : `${actionName}.${key}`;
+          const value = params[key];
+          const stringValue = value !== void 0 && value !== null ? String(value) : "";
+          if (currentParams.get(fullKey) !== stringValue) {
+            if (stringValue) currentParams.set(fullKey, stringValue);
+            else currentParams.delete(fullKey);
+            hasChanged = true;
+          }
+        }
+      }
+    }
+    if (hasChanged) {
+      updateUrl(currentParams.toString());
+    }
+  }, [queryOptions, urlSync]);
+  _react.useMemo.call(void 0, () => {
+    for (const actionName in moduleConfig.actions) {
+      const actionConfig = moduleConfig.actions[actionName];
+      const shouldCache = actionConfig.cacheResponse !== false;
+      const execute = async (input, options2 = {}) => {
+        lastCallRef.current[actionName] = { input, options: options2 };
+        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
+        let bodyForCall = input;
+        let requestConfig = options2.config || {};
+        if (actionConfig.method === "GET") {
+          const currentQueryOptions = queryOptions[actionName];
+          bodyForCall = { ...actionConfig._input, ...currentQueryOptions, ..._optionalChain([options2, 'access', _6 => _6.config, 'optionalAccess', _7 => _7.params]), ...input };
+        } else if (actionConfig.upload && input) {
+          bodyForCall = new FormData();
+          for (const key in input) {
+            bodyForCall.append(key, input[key]);
+          }
+        }
+        const cacheKey = shouldCache ? _chunkJAMEOM7Tcjs.generateCacheKey.call(void 0, moduleConfig.baseEndpoint, actionName, bodyForCall, { pathParams: finalPathParams }) : "";
+        let mutationContext;
+        try {
+          if (options2.onMutate && shouldCache) {
+            mutationContext = await options2.onMutate(input);
+          }
+          if (shouldCache) {
+            _chunkJAMEOM7Tcjs.globalStateManager.setState(cacheKey, (prev) => ({ ...prev, loading: true, called: true, error: null, isStale: false }));
+          }
+          const result = await _chunkJAMEOM7Tcjs.callDynamicApi.call(void 0, axiosInstance, moduleConfig.baseEndpoint, actionConfig, {
+            pathParams: finalPathParams,
+            body: bodyForCall,
+            config: requestConfig
+          });
+          if (shouldCache) {
+            _chunkJAMEOM7Tcjs.globalStateManager.setState(cacheKey, (prev) => ({
+              ...prev,
+              loading: false,
+              success: result.success,
+              error: result.success ? null : result.error || prev.error,
+              data: result.data,
+              meta: result.meta,
+              links: result.links,
+              message: result.message,
+              validationErrors: result.validationErrors || [],
+              rawResponse: result.rawResponse,
+              lastSuccessAt: result.success ? Date.now() : prev.lastSuccessAt
+            }));
+          }
+          if (result.success) {
+            _optionalChain([savedCallbacks, 'access', _8 => _8.current, 'access', _9 => _9.onSuccess, 'optionalCall', _10 => _10(actionName, result.message || "Action successful", result.data)]);
+            _optionalChain([options2, 'access', _11 => _11.onSuccess, 'optionalCall', _12 => _12(result.data, mutationContext)]);
+            _optionalChain([actionConfig, 'access', _13 => _13.invalidates, 'optionalAccess', _14 => _14.forEach, 'call', _15 => _15((keyToInvalidate) => {
+              const prefix = `${moduleConfig.baseEndpoint}/${keyToInvalidate}::`;
+              _chunkJAMEOM7Tcjs.globalStateManager.invalidateByPrefix(prefix);
+            })]);
+          } else {
+            _optionalChain([savedCallbacks, 'access', _16 => _16.current, 'access', _17 => _17.onError, 'optionalCall', _18 => _18(actionName, result.message || "Action failed", _nullishCoalesce(result.error, () => ( void 0)))]);
+            _optionalChain([options2, 'access', _19 => _19.onError, 'optionalCall', _20 => _20(result.error, mutationContext)]);
+          }
+          return result;
+        } catch (error) {
+          const apiError = _optionalChain([error, 'access', _21 => _21.response, 'optionalAccess', _22 => _22.data]) || { status: 500, message: error.message };
+          if (shouldCache) {
+            _chunkJAMEOM7Tcjs.globalStateManager.setState(cacheKey, (prev) => ({ ...prev, error: apiError, loading: false, success: false }));
+          }
+          _optionalChain([savedCallbacks, 'access', _23 => _23.current, 'access', _24 => _24.onError, 'optionalCall', _25 => _25(actionName, apiError.message, apiError)]);
+          _optionalChain([options2, 'access', _26 => _26.onError, 'optionalCall', _27 => _27(apiError, mutationContext)]);
+          throw error;
+        } finally {
+          if (options2.onSettled) {
+            options2.onSettled();
+          }
+        }
+      };
+      const reset = (input, options2 = {}) => {
+        if (shouldCache) {
+          const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
+          const cacheKey = _chunkJAMEOM7Tcjs.generateCacheKey.call(void 0, moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
+          _chunkJAMEOM7Tcjs.globalStateManager.setState(cacheKey, () => createInitialState());
+        }
+      };
+      stableActionsRef.current[actionName] = { execute, reset };
+    }
+  }, [axiosInstance, moduleConfig, pathParamsString]);
+  const actions = _react.useMemo.call(void 0, () => stableActionsRef.current, []);
+  _react.useEffect.call(void 0, () => {
+    if (typeof window === "undefined" || initialFetchRef.current || !enabled) return;
+    const actionsToRun = initialActionsToExecute ? initialActionsToExecute.map(String) : Object.keys(moduleConfig.actions).filter(
+      (actionName) => moduleConfig.actions[actionName].autoFetch
+    );
+    actionsToRun.forEach((actionName) => {
+      const key = actionName;
+      const hydratedData = hydratedState ? JSON.parse(hydratedState) : {};
+      if (_optionalChain([hydratedData, 'access', _28 => _28[actionName], 'optionalAccess', _29 => _29.data])) {
+        return;
+      }
+      const actionConfig = moduleConfig.actions[key];
+      const executeAction = _optionalChain([actions, 'access', _30 => _30[key], 'optionalAccess', _31 => _31.execute]);
+      if (typeof executeAction === "function") {
+        const input = actionConfig.hasQuery ? queryOptions[actionName] : void 0;
+        executeAction(input);
+      }
+    });
+    initialFetchRef.current = true;
+  }, [actions, initialActionsToExecute, moduleConfig.actions, hydratedState, queryOptions, enabled]);
+  const queries = _react.useMemo.call(void 0, () => {
+    return Object.keys(moduleConfig.actions).reduce((acc, actionName) => {
+      const actionConfig = moduleConfig.actions[actionName];
+      if (_optionalChain([actionConfig, 'optionalAccess', _32 => _32.hasQuery])) {
+        const setActionQueryOptions = (updater) => {
+          const key = actionName;
+          setQueryOptions((prev) => ({ ...prev, [key]: typeof updater === "function" ? updater(prev[key] || {}) : updater }));
+        };
+        const refetch = () => {
+          const execute = actions[actionName].execute;
+          execute(queryOptions[actionName] || {});
+        };
+        acc[actionName] = {
+          options: queryOptions[actionName] || {},
+          refetch,
+          setOptions: setActionQueryOptions,
+          setPage: (page) => setActionQueryOptions((p) => ({ ...p, page })),
+          setLimit: (limit) => setActionQueryOptions((p) => ({ ...p, limit, page: 1 })),
+          setSearchTerm: (search) => setActionQueryOptions((p) => ({ ...p, search, page: 1 })),
+          setFilters: (filter) => setActionQueryOptions((p) => ({ ...p, filter, page: 1 })),
+          setSorting: (sortBy) => setActionQueryOptions((p) => ({ ...p, sortBy })),
+          setQueryParam: (key, value) => setActionQueryOptions((p) => ({ ...p, [key]: value, page: key !== "page" ? value : p.page })),
+          reset: () => setActionQueryOptions(actionConfig._input || {})
+        };
+      }
+      return acc;
+    }, {});
+  }, [actions, queryOptions, moduleConfig.actions]);
+  const states = {};
+  function isActionWithQuery(key, actions2) {
+    return _optionalChain([actions2, 'access', _33 => _33[key], 'optionalAccess', _34 => _34.hasQuery]) === true;
+  }
+  for (const actionName in moduleConfig.actions) {
+    if (Object.prototype.hasOwnProperty.call(moduleConfig.actions, actionName)) {
+      const key = actionName;
+      const actionConfig = moduleConfig.actions[key];
+      if (actionConfig.cacheResponse !== false) {
+        let currentQueryOptions;
+        if (isActionWithQuery(key, moduleConfig.actions)) {
+          currentQueryOptions = _optionalChain([queries, 'access', _35 => _35[key], 'optionalAccess', _36 => _36.options]);
+        }
+        const input = currentQueryOptions;
+        const pathParams = JSON.parse(pathParamsString);
+        const cacheKey = _chunkJAMEOM7Tcjs.generateCacheKey.call(void 0, moduleConfig.baseEndpoint, actionName, input, { pathParams });
+        states[actionName] = useApiActionState(actionConfig, cacheKey, actions[key].execute, input, enabled);
+      } else {
+        states[actionName] = createInitialState();
+      }
+    }
+  }
+  const lastBlurTimestamp = _react.useRef.call(void 0, Date.now());
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || !refetchOnWindowFocus) return;
+    const onFocus = () => {
+      if (Date.now() - lastBlurTimestamp.current > 1e4) {
+        for (const actionName of Object.keys(moduleConfig.actions)) {
+          const state = states[actionName];
+          if (state && state.called && !state.loading) {
+            _chunkJAMEOM7Tcjs.globalStateManager.invalidateByPrefix(`${moduleConfig.baseEndpoint}/${actionName}::`);
+          }
+        }
+      }
+    };
+    const onBlur = () => {
+      lastBlurTimestamp.current = Date.now();
+    };
+    window.addEventListener("focus", onFocus);
+    window.addEventListener("blur", onBlur);
+    return () => {
+      window.removeEventListener("focus", onFocus);
+      window.removeEventListener("blur", onBlur);
+    };
+  }, [enabled, refetchOnWindowFocus, moduleConfig, states]);
+  const dehydrate = _react.useCallback.call(void 0, () => _chunkJAMEOM7Tcjs.globalStateManager.dehydrate(), []);
+  const finalApiReturn = _react.useMemo.call(void 0, () => ({
+    actions,
+    states,
+    queries,
+    dehydrate,
+    ...extraContextData || {}
+  }), [actions, states, queries, dehydrate, extraContextData]);
+  return finalApiReturn;
+}
+
+// src/hooks/useApiModule/apiModuleContext.ts
+
+function createApiModuleContext() {
+  const Context = _react.createContext.call(void 0, null);
+  Context.displayName = "ApiModuleContext";
+  const Provider = ({ value, children }) => {
+    return _react.createElement.call(void 0, Context.Provider, { value }, children);
+  };
+  const useConsumer = () => {
+    const context = _react.useContext.call(void 0, Context);
+    if (!context) {
+      throw new Error("This component must be used within its corresponding ApiModuleProvider.");
+    }
+    return context;
+  };
+  return {
+    Context,
+    Provider,
+    useContext: useConsumer
+  };
+}
+
+
+
+
+
+
+
+exports.ApiModuleProvider = ApiModuleProvider; exports.createApiModuleContext = createApiModuleContext; exports.useApi = useApi; exports.useApiModule = useApiModule; exports.useApiRecord = useApiRecord; exports.useDeepCompareEffect = useDeepCompareEffect;

package/dist/client.d.cts

@@ -0,0 +1,50 @@
+import { AxiosInstance } from 'axios';
+import { U as UseApiConfig, A as ApiModuleConfig, a as UseApiModuleOptions, b as UseApiModuleReturn, M as ModuleStates, c as ModuleActions, d as ModuleQueries } from './apiModule.types-DEskFzOY.cjs';
+import { U as UseApiRecordConfig, a as UseApiRecordReturn } from './useApiRecord.types-mpeiDoxm.cjs';
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+declare function useApi<T>(axiosInstance: AxiosInstance, config: UseApiConfig<T>): any;
+
+/**
+ * A React hook for managing the lifecycle of a single API resource (a record).
+ * It handles fetching, updating, replacing, and deleting a record, while managing
+ * loading, error, and data states. It supports dynamic path parameters for flexible API routing.
+ *
+ * @template T The data type of the record being managed.
+ * @param {AxiosInstance} axiosInstance - The configured Axios instance for making API calls.
+ * @param {UseApiRecordConfig<T>} config - Configuration options for the hook.
+ * @returns {UseApiRecordReturn<T>} An object containing the state, actions, and setState function.
+ */
+declare function useApiRecord<T>(axiosInstance: AxiosInstance, config: UseApiRecordConfig<T>): UseApiRecordReturn<T>;
+
+type EffectCallback = () => (void | (() => void));
+type DependencyList = readonly any[];
+declare function useDeepCompareEffect(callback: EffectCallback, dependencies: DependencyList): void;
+
+declare const ApiModuleProvider: react.Provider<{
+    states: ModuleStates<any>;
+    actions: ModuleActions<any>;
+    queries: ModuleQueries<any>;
+    dehydrate: () => string;
+} | null>;
+declare function useApiModule<TModule extends ApiModuleConfig<any>, TExtra extends object = {}>(axiosInstance: AxiosInstance, moduleConfig: TModule, options?: UseApiModuleOptions<TModule, TExtra>): UseApiModuleReturn<TModule['actions'], TExtra>;
+
+/**
+ * Creates a strongly-typed React Context, Provider, and consumer hook for a specific API module.
+ * This pattern avoids the need for manual type assertions in consuming components.
+ *
+ * @template TActions - The shape of the actions in the API module.
+ * @template TExtra - The shape of any extra data passed via `extraContextData`.
+ * @returns An object containing the typed Context, Provider, and a `useContext` hook.
+ */
+declare function createApiModuleContext<TActions extends Record<string, any>, TExtra extends object = {}>(): {
+    Context: react.Context<UseApiModuleReturn<TActions, TExtra> | null>;
+    Provider: ({ value, children }: {
+        value: UseApiModuleReturn<TActions, TExtra>;
+        children: ReactNode;
+    }) => react.FunctionComponentElement<react.ProviderProps<UseApiModuleReturn<TActions, TExtra> | null>>;
+    useContext: () => UseApiModuleReturn<TActions, TExtra>;
+};
+
+export { ApiModuleProvider, createApiModuleContext, useApi, useApiModule, useApiRecord, useDeepCompareEffect };