api-core-lib 12.12.4 → 12.12.101

package/dist/client.cjs

@@ -0,0 +1,547 @@
+"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 _chunk25UFVV4Fcjs = require('./chunk-25UFVV4F.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,
+    // [REMOVE] لم نعد بحاجة لهذا الخيار
+    // encodeQuery = true, 
+    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, 
+    () => _chunk25UFVV4Fcjs.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 = _chunk25UFVV4Fcjs.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 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,
+    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, 
+    () => _chunk25UFVV4Fcjs.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: [],
+  validationErrors: [],
+  error: null,
+  loading: false,
+  success: false,
+  called: false,
+  isStale: false,
+  rawResponse: null
+});
+function useApiActionState(actionConfig, cacheKey, execute, input, enabled) {
+  const getClientSnapshot = () => _chunk25UFVV4Fcjs.globalStateManager.getSnapshot(cacheKey);
+  const getServerSnapshot = () => _chunk25UFVV4Fcjs.globalStateManager.getSnapshot(cacheKey);
+  const state = _react.useSyncExternalStore.call(void 0, 
+    (callback) => _chunk25UFVV4Fcjs.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) {
+      console.log(`[Cache Key Changed] from ${prevCacheKeyRef.current} to ${cacheKey}. Refetching...`);
+      refetch();
+    } else if (enabled && actionConfig.autoFetch && !state.called && !state.loading) {
+      console.log(`[Auto Fetch] for ${cacheKey}. Fetching...`);
+      refetch();
+    } else if (enabled && state.isStale && !state.loading) {
+      console.log(`[Stale State] for ${cacheKey}. Refetching...`);
+      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: modulePathParams,
+    enabled = true,
+    hydratedState,
+    extraContextData
+  } = options;
+  const pathParamsString = _react.useMemo.call(void 0, () => JSON.stringify(modulePathParams || {}), [modulePathParams]);
+  const [queryOptions, setQueryOptions] = _react.useState.call(void 0, {});
+  const savedCallbacks = _react.useRef.call(void 0, { onSuccess, onError });
+  _react.useEffect.call(void 0, () => {
+    savedCallbacks.current = { onSuccess, onError };
+  }, [onSuccess, onError]);
+  _react.useMemo.call(void 0, () => {
+    if (hydratedState) {
+      _chunk25UFVV4Fcjs.globalStateManager.rehydrate(hydratedState);
+    }
+  }, [hydratedState]);
+  _react.useEffect.call(void 0, () => {
+    savedCallbacks.current = { onSuccess, onError };
+  }, [onSuccess, onError]);
+  _react.useMemo.call(void 0, () => {
+    if (hydratedState) {
+      _chunk25UFVV4Fcjs.globalStateManager.rehydrate(hydratedState);
+    }
+  }, [hydratedState]);
+  const actions = _react.useMemo.call(void 0, () => {
+    return Object.keys(moduleConfig.actions).reduce((acc, actionName) => {
+      const actionConfig = moduleConfig.actions[actionName];
+      const shouldCache = actionConfig.cacheResponse !== false;
+      const execute = async (input, options2 = {}) => {
+        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
+        const cacheKey = shouldCache ? _chunk25UFVV4Fcjs.generateCacheKey.call(void 0, moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams }) : "";
+        let mutationContext;
+        try {
+          if (options2.onMutate && shouldCache) {
+            mutationContext = await options2.onMutate(input);
+          }
+          if (shouldCache) {
+            _chunk25UFVV4Fcjs.globalStateManager.setState(cacheKey, (prev) => ({ ...prev, loading: true, called: true, error: null, isStale: false }));
+          }
+          const result = await _chunk25UFVV4Fcjs.callDynamicApi.call(void 0, axiosInstance, moduleConfig.baseEndpoint, actionConfig, {
+            pathParams: finalPathParams,
+            body: input,
+            config: options2.config
+          });
+          console.log("[API Result execute]", result);
+          if (shouldCache) {
+            _chunk25UFVV4Fcjs.globalStateManager.setState(cacheKey, (prev) => ({
+              ...prev,
+              // احتفظ بالخصائص القديمة مثل 'called'
+              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
+              // isStale تم تعيينه إلى false في بداية execute، وسيظل كذلك
+            }));
+          }
+          if (result.success) {
+            _optionalChain([savedCallbacks, 'access', _6 => _6.current, 'access', _7 => _7.onSuccess, 'optionalCall', _8 => _8(actionName, result.message || "Action successful", result.data)]);
+            _optionalChain([options2, 'access', _9 => _9.onSuccess, 'optionalCall', _10 => _10(result.data, mutationContext)]);
+            _optionalChain([actionConfig, 'access', _11 => _11.invalidates, 'optionalAccess', _12 => _12.forEach, 'call', _13 => _13((keyToInvalidate) => {
+              const prefix = `${moduleConfig.baseEndpoint}/${keyToInvalidate}::`;
+              console.log(`[Invalidating] by prefix: ${prefix}`);
+              _chunk25UFVV4Fcjs.globalStateManager.invalidateByPrefix(prefix);
+            })]);
+          } else {
+            _optionalChain([savedCallbacks, 'access', _14 => _14.current, 'access', _15 => _15.onError, 'optionalCall', _16 => _16(actionName, result.message || "Action failed", _nullishCoalesce(result.error, () => ( void 0)))]);
+            _optionalChain([options2, 'access', _17 => _17.onError, 'optionalCall', _18 => _18(result.error, mutationContext)]);
+          }
+          return result;
+        } catch (error) {
+          const apiError = _optionalChain([error, 'access', _19 => _19.response, 'optionalAccess', _20 => _20.data]) || { status: 500, message: error.message };
+          if (shouldCache) {
+            _chunk25UFVV4Fcjs.globalStateManager.setState(cacheKey, (prev) => ({ ...prev, error: apiError, loading: false, success: false }));
+          }
+          _optionalChain([savedCallbacks, 'access', _21 => _21.current, 'access', _22 => _22.onError, 'optionalCall', _23 => _23(actionName, apiError.message, apiError)]);
+          _optionalChain([options2, 'access', _24 => _24.onError, 'optionalCall', _25 => _25(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 = _chunk25UFVV4Fcjs.generateCacheKey.call(void 0, moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
+          _chunk25UFVV4Fcjs.globalStateManager.setState(cacheKey, () => createInitialState());
+        }
+      };
+      acc[actionName] = { execute, reset };
+      return acc;
+    }, {});
+  }, [axiosInstance, moduleConfig, pathParamsString]);
+  const queries = _react.useMemo.call(void 0, () => {
+    const builtQueries = {};
+    for (const actionName in moduleConfig.actions) {
+      if (_optionalChain([moduleConfig, 'access', _26 => _26.actions, 'access', _27 => _27[actionName], 'optionalAccess', _28 => _28.hasQuery])) {
+        const setActionQueryOptions = (updater) => {
+          setQueryOptions((prev) => ({ ...prev, [actionName]: typeof updater === "function" ? updater(prev[actionName] || {}) : updater }));
+        };
+        builtQueries[actionName] = {
+          options: queryOptions[actionName] || {},
+          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({})
+        };
+      }
+    }
+    return builtQueries;
+  }, [queryOptions, moduleConfig.actions]);
+  const states = {};
+  function isActionWithQuery(key, actions2) {
+    return _optionalChain([actions2, 'access', _29 => _29[key], 'optionalAccess', _30 => _30.hasQuery]) === true;
+  }
+  for (const actionName in moduleConfig.actions) {
+    if (Object.prototype.hasOwnProperty.call(moduleConfig.actions, actionName)) {
+      const actionConfig = moduleConfig.actions[actionName];
+      if (actionConfig.cacheResponse !== false) {
+        let queryOptions2;
+        if (isActionWithQuery(actionName, moduleConfig.actions)) {
+          queryOptions2 = _optionalChain([queries, 'access', _31 => _31[actionName], 'optionalAccess', _32 => _32.options]);
+        }
+        const input = queryOptions2;
+        const pathParams = JSON.parse(pathParamsString);
+        const cacheKey = _chunk25UFVV4Fcjs.generateCacheKey.call(void 0, 
+          moduleConfig.baseEndpoint,
+          actionName,
+          input,
+          { pathParams }
+        );
+        states[actionName] = useApiActionState(
+          actionConfig,
+          cacheKey,
+          actions[actionName].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) {
+        const actionKeys = Object.keys(moduleConfig.actions);
+        for (const actionName of actionKeys) {
+          const state = states[actionName];
+          if (state && state.called && !state.loading) {
+            const prefix = `${moduleConfig.baseEndpoint}/${actionName}::`;
+            _chunk25UFVV4Fcjs.globalStateManager.invalidateByPrefix(prefix);
+          }
+        }
+      }
+    };
+    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.useMemo.call(void 0, () => {
+    return () => _chunk25UFVV4Fcjs.globalStateManager.dehydrate();
+  }, []);
+  const baseApiReturn = { actions, states, queries, dehydrate };
+  const finalApiReturn = _react.useMemo.call(void 0, () => ({
+    ...baseApiReturn,
+    ...extraContextData || {}
+  }), [baseApiReturn, 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 ActionConfigModule, a as ApiModuleConfig, b as UseApiModuleOptions, c as UseApiModuleReturn, M as ModuleStates, d as ModuleActions, e as ModuleQueries } from './apiModule.types-dbmnauAt.cjs';
+import { U as UseApiRecordConfig, a as UseApiRecordReturn } from './useApiRecord.types-HrabvzEQ.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<TActions extends Record<string, ActionConfigModule<any, any>>, TExtra extends object = {}>(axiosInstance: AxiosInstance, moduleConfig: ApiModuleConfig<TActions>, options?: UseApiModuleOptions<TExtra>): UseApiModuleReturn<TActions, 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 };

package/dist/client.d.ts

@@ -0,0 +1,50 @@
+import { AxiosInstance } from 'axios';
+import { U as UseApiConfig, A as ActionConfigModule, a as ApiModuleConfig, b as UseApiModuleOptions, c as UseApiModuleReturn, M as ModuleStates, d as ModuleActions, e as ModuleQueries } from './apiModule.types-dbmnauAt.js';
+import { U as UseApiRecordConfig, a as UseApiRecordReturn } from './useApiRecord.types-C06B5p4U.js';
+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<TActions extends Record<string, ActionConfigModule<any, any>>, TExtra extends object = {}>(axiosInstance: AxiosInstance, moduleConfig: ApiModuleConfig<TActions>, options?: UseApiModuleOptions<TExtra>): UseApiModuleReturn<TActions, 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 };