api-core-lib 12.0.10 → 12.0.12

package/dist/client.cjs

@@ -0,0 +1,869 @@
+"use strict";
+"use client";
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  ApiModuleProvider: () => ApiModuleProvider,
+  useApi: () => useApi,
+  useApiModule: () => useApiModule,
+  useApiRecord: () => useApiRecord,
+  useDeepCompareEffect: () => useDeepCompareEffect,
+  useModuleContext: () => useModuleContext
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/hooks/useApi.ts
+var import_react = require("react");
+
+// src/core/processor.ts
+var import_axios2 = __toESM(require("axios"), 1);
+
+// src/core/utils.ts
+var import_axios = __toESM(require("axios"), 1);
+function isAxiosResponse(obj) {
+  return obj && obj.data !== void 0 && obj.status !== void 0 && obj.config !== void 0;
+}
+function buildPaginateQuery(options) {
+  const params = new URLSearchParams();
+  for (const key in options) {
+    const value = options[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (key === "filter" && typeof value === "object" && !Array.isArray(value)) {
+      for (const filterKey in value) {
+        const filterValue = value[filterKey];
+        if (filterValue !== null && filterValue !== void 0) {
+          params.append(`filter[${filterKey}]`, String(filterValue));
+        }
+      }
+    } else if (key === "sortBy" && Array.isArray(value)) {
+      value.forEach((sortItem) => {
+        if (sortItem && sortItem.key && sortItem.direction) {
+          params.append("sortBy[]", `${sortItem.key}:${sortItem.direction}`);
+        }
+      });
+    } else {
+      params.append(key, String(value));
+    }
+  }
+  return params.toString();
+}
+function isServerError(error) {
+  return import_axios.default.isAxiosError(error) && error.response !== void 0;
+}
+function isNetworkError(error) {
+  return import_axios.default.isAxiosError(error) && error.response === void 0 && error.request !== void 0;
+}
+
+// src/core/processor.ts
+var processResponse = (responseOrError) => {
+  if (isAxiosResponse(responseOrError)) {
+    const response = responseOrError;
+    const rawData = response.data;
+    const isStandardApiResponse = rawData && typeof rawData.success === "boolean" && rawData.data !== void 0;
+    return {
+      data: isStandardApiResponse ? rawData.data : rawData,
+      links: isStandardApiResponse ? rawData.links : void 0,
+      meta: isStandardApiResponse ? rawData.meta : void 0,
+      rawResponse: rawData,
+      loading: false,
+      success: true,
+      error: null,
+      message: isStandardApiResponse ? rawData.message : "Request successful.",
+      validationErrors: []
+    };
+  }
+  if (isServerError(responseOrError)) {
+    const error = responseOrError;
+    const responseData = error.response.data;
+    const status = error.response.status;
+    let defaultMessage = "An unexpected server error occurred.";
+    switch (status) {
+      case 400:
+        defaultMessage = "Bad Request";
+        break;
+      case 401:
+        defaultMessage = "Unauthorized";
+        break;
+      case 403:
+        defaultMessage = "Forbidden";
+        break;
+      case 404:
+        defaultMessage = "Not Found";
+        break;
+      case 422:
+        defaultMessage = "Validation Failed";
+        break;
+      case 500:
+        defaultMessage = "Internal Server Error";
+        break;
+      case 503:
+        defaultMessage = "Service Unavailable";
+        break;
+      default:
+        defaultMessage = `Server Error (${status})`;
+    }
+    const finalApiError = {
+      message: responseData?.message || defaultMessage,
+      status,
+      code: responseData?.code || error.code,
+      errors: responseData?.errors || []
+    };
+    return {
+      data: null,
+      rawResponse: responseData,
+      error: finalApiError,
+      validationErrors: finalApiError.errors,
+      success: false,
+      loading: false,
+      message: finalApiError.message
+    };
+  }
+  if (isNetworkError(responseOrError)) {
+    const error = responseOrError;
+    return {
+      data: null,
+      rawResponse: error.request,
+      error: { message: "Network Error: Unable to connect.", status: 0, code: error.code },
+      success: false,
+      loading: false,
+      message: "Network Error."
+    };
+  }
+  if (import_axios2.default.isCancel(responseOrError)) {
+    return {
+      data: null,
+      rawResponse: null,
+      error: { message: "Request Canceled.", status: 499 },
+      success: false,
+      loading: false,
+      message: "Request Canceled."
+    };
+  }
+  return {
+    data: null,
+    rawResponse: responseOrError,
+    error: { message: "An unknown error occurred.", status: -1 },
+    success: false,
+    loading: false,
+    message: "An unknown error occurred."
+  };
+};
+
+// src/core/buildDynamicUrl.ts
+function buildDynamicUrl(template, params) {
+  if (!params) {
+    return template;
+  }
+  return template.replace(/\{(\w+)\}/g, (placeholder, key) => {
+    return params.hasOwnProperty(key) ? String(params[key]) : placeholder;
+  });
+}
+
+// src/services/crud.ts
+function createApiServices(axiosInstance, baseEndpoint) {
+  const resolveUrl = (config = {}, id) => {
+    const endpointTemplate = config.endpoint || (id != null ? `${baseEndpoint}/{id}` : baseEndpoint);
+    const params = id != null ? { id, tenant: id, tenantId: id, recordId: id } : {};
+    return buildDynamicUrl(endpointTemplate, params);
+  };
+  const get = async (id, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.get(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const getWithQuery = async (query, config) => {
+    const url = `${baseEndpoint}?${query}`;
+    try {
+      const response = await axiosInstance.get(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const post = async (data, config) => {
+    const url = resolveUrl(config);
+    try {
+      const response = await axiosInstance.post(url, data, config);
+      console.log("[lib] response POST: ", response);
+      console.log("[lib] response processResponse POST: ", processResponse(response));
+      return processResponse(response);
+    } catch (error) {
+      console.log("[lib] response error POST: ", processResponse(error));
+      return processResponse(error);
+    }
+  };
+  const put = async (id, data, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.put(url, data, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const patch = async (id, data, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.patch(url, data, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const remove = async (id, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.delete(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const bulkDelete = async (ids, config) => {
+    const url = resolveUrl(config);
+    try {
+      const response = await axiosInstance.delete(url, { data: { ids }, ...config });
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const upload = async (file, additionalData, config) => {
+    const url = resolveUrl(config);
+    const formData = new FormData();
+    formData.append("file", file);
+    if (additionalData) {
+      Object.keys(additionalData).forEach((key) => formData.append(key, String(additionalData[key])));
+    }
+    try {
+      const response = await axiosInstance.post(url, formData, {
+        ...config,
+        headers: { ...config?.headers, "Content-Type": "multipart/form-data" }
+      });
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  return { get, getWithQuery, post, put, patch, remove, bulkDelete, upload };
+}
+async function callDynamicApi(axiosInstance, baseEndpoint, actionConfig, params) {
+  const { pathParams, body, config } = params;
+  const urlTemplate = `${baseEndpoint}${actionConfig.path}`;
+  const finalUrl = buildDynamicUrl(urlTemplate, pathParams || {});
+  try {
+    const { method } = actionConfig;
+    let response;
+    if (method === "POST" || method === "PUT" || method === "PATCH") {
+      response = await axiosInstance[method.toLowerCase()](finalUrl, body, config);
+    } else if (method === "DELETE") {
+      response = await axiosInstance.delete(finalUrl, { data: body, ...config });
+    } else {
+      response = await axiosInstance.get(finalUrl, { params: body, ...config });
+    }
+    return processResponse(response);
+  } catch (error) {
+    return processResponse(error);
+  }
+}
+
+// src/hooks/useApi.ts
+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 = (0, import_react.useMemo)(
+    () => buildDynamicPath(endpoint, pathParams),
+    [endpoint, pathParams]
+  );
+  const [state, setState] = (0, import_react.useState)({
+    data: initialData ?? null,
+    rawResponse: null,
+    loading: enabled,
+    error: null,
+    success: false,
+    message: void 0,
+    validationErrors: void 0
+  });
+  const [queryOptions, setQueryOptions] = (0, import_react.useState)(initialQuery);
+  const apiServices = (0, import_react.useMemo)(
+    () => createApiServices(axiosInstance, finalEndpoint),
+    [axiosInstance, finalEndpoint]
+  );
+  const savedOnSuccess = (0, import_react.useRef)(onSuccess);
+  const savedOnError = (0, import_react.useRef)(onError);
+  (0, import_react.useEffect)(() => {
+    savedOnSuccess.current = onSuccess;
+    savedOnError.current = onError;
+  }, [onSuccess, onError]);
+  const fetchData = (0, import_react.useCallback)(async (currentQueryOptions) => {
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const finalQuery = currentQueryOptions || queryOptions;
+      const hasQueryParams = Object.keys(finalQuery).length > 0;
+      const queryString = buildPaginateQuery(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!", result.data ?? void 0);
+      } else if (!result.success && savedOnError.current) {
+        savedOnError.current(result.message || "Fetch failed", 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]);
+  (0, import_react.useEffect)(() => {
+    if (enabled) {
+      fetchData();
+    }
+  }, [enabled, fetchData]);
+  const handleActionResult = (0, import_react.useCallback)(async (actionPromise) => {
+    setState((prev) => ({ ...prev, loading: true }));
+    try {
+      const result = await actionPromise;
+      if (result.success) {
+        if (savedOnSuccess.current) {
+          savedOnSuccess.current(result.message || "Action successful!", 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", 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
+var import_react2 = require("react");
+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 = (0, import_react2.useMemo)(
+    () => buildDynamicPath2(endpoint, pathParams),
+    [endpoint, pathParams]
+  );
+  const initialState = (0, import_react2.useMemo)(() => ({
+    data: initialData ?? null,
+    rawResponse: null,
+    error: null,
+    loading: enabled && !!recordId,
+    success: false,
+    message: void 0,
+    validationErrors: void 0
+  }), [initialData, enabled, recordId]);
+  const [state, setState] = (0, import_react2.useState)(initialState);
+  const savedOnSuccess = (0, import_react2.useRef)(onSuccess);
+  const savedOnError = (0, import_react2.useRef)(onError);
+  (0, import_react2.useEffect)(() => {
+    savedOnSuccess.current = onSuccess;
+    savedOnError.current = onError;
+  }, [onSuccess, onError]);
+  const apiServices = (0, import_react2.useMemo)(
+    () => createApiServices(axiosInstance, finalEndpoint),
+    [axiosInstance, finalEndpoint]
+  );
+  const fetchRecord = (0, import_react2.useCallback)(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!", result.data ?? void 0);
+      } else if (!result.success && savedOnError.current) {
+        savedOnError.current(result.message || "Fetch failed", result.error ?? void 0);
+      }
+    } catch (e) {
+      console.error("[useApiRecord Fetch Error]", e);
+      const apiError = {
+        status: e.response?.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]);
+  (0, import_react2.useEffect)(() => {
+    if (enabled) {
+      fetchRecord();
+    }
+  }, [enabled, fetchRecord]);
+  const handleActionResult = (0, import_react2.useCallback)(
+    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 = options?.refetch ?? refetchAfterChange;
+          if (shouldRefetch) {
+            await fetchRecord();
+          } else {
+            setState({ ...result, loading: false, data: result.data });
+          }
+        } else {
+          if (savedOnError.current) {
+            savedOnError.current(result.message || "Action failed", result.error ?? void 0);
+          }
+          setState((prev) => ({ ...prev, ...result, loading: false }));
+        }
+        return result;
+      } catch (e) {
+        console.error("[useApiRecord Action Error]", e);
+        const apiError = {
+          status: e.response?.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 import_react3 = require("react");
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
+function useDeepCompareEffect(callback, dependencies) {
+  const currentDependenciesRef = (0, import_react3.useRef)();
+  if (!(0, import_fast_deep_equal.default)(currentDependenciesRef.current, dependencies)) {
+    currentDependenciesRef.current = dependencies;
+  }
+  (0, import_react3.useEffect)(callback, [currentDependenciesRef.current]);
+}
+
+// src/hooks/useApiModule/useApiModule.ts
+var import_react4 = require("react");
+
+// src/core/globalStateManager.ts
+var createInitialState = () => ({
+  data: null,
+  links: void 0,
+  meta: void 0,
+  error: null,
+  loading: false,
+  success: false,
+  called: false,
+  isStale: false,
+  message: void 0,
+  validationErrors: [],
+  rawResponse: null
+});
+var GlobalStateManager = class {
+  constructor() {
+    __publicField(this, "store", /* @__PURE__ */ new Map());
+  }
+  /**
+   * يحصل على لقطة (snapshot) للحالة الحالية لمفتاح معين.
+   */
+  getSnapshot(key) {
+    return this.store.get(key)?.state ?? createInitialState();
+  }
+  /**
+   * يسجل دالة callback للاستماع إلى التغييرات على مفتاح معين.
+   * @returns دالة لإلغاء الاشتراك.
+   */
+  subscribe(key, callback) {
+    if (!this.store.has(key)) {
+      this.store.set(key, { state: createInitialState(), listeners: /* @__PURE__ */ new Set() });
+    }
+    const item = this.store.get(key);
+    item.listeners.add(callback);
+    return () => {
+      item.listeners.delete(callback);
+    };
+  }
+  /**
+   * يحدّث الحالة لمفتاح معين ويقوم بإعلام جميع المشتركين.
+   */
+  setState(key, updater) {
+    const currentState = this.getSnapshot(key);
+    const newState = updater(currentState);
+    if (!this.store.has(key)) {
+      this.store.set(key, { state: newState, listeners: /* @__PURE__ */ new Set() });
+    } else {
+      this.store.get(key).state = newState;
+    }
+    this.store.get(key).listeners.forEach((listener) => listener());
+  }
+  /**
+   * يجعل البيانات المرتبطة بمفتاح معين "قديمة" (stale).
+   */
+  invalidate(key) {
+    const state = this.getSnapshot(key);
+    if (state.called) {
+      this.setState(key, (prev) => ({ ...prev, isStale: true }));
+    }
+  }
+  /**
+  * [نسخة محدثة وأكثر قوة]
+  * يجعل كل البيانات التي تبدأ بمفتاح معين "قديمة" (stale).
+  * @example invalidateByPrefix('myModule/list::') سيبطل كل صفحات القائمة.
+  */
+  invalidateByPrefix(prefix) {
+    this.store.forEach((value, key) => {
+      if (key.startsWith(prefix)) {
+        const state = this.getSnapshot(key);
+        if (state.called) {
+          this.setState(key, (prev) => ({ ...prev, isStale: true }));
+        }
+      }
+    });
+  }
+  /**
+  * Serializes the current state of the query store into a JSON string.
+  * This is used on the server to pass the initial state to the client.
+  * @returns A JSON string representing the dehydrated state.
+  */
+  dehydrate() {
+    const stateToPersist = {};
+    this.store.forEach((value, key) => {
+      if (value.state.called) {
+        stateToPersist[key] = value.state;
+      }
+    });
+    return JSON.stringify(stateToPersist);
+  }
+  /**
+   * Merges a dehydrated state object into the current store.
+   * This is used on the client to hydrate the state received from the server.
+   * @param hydratedState - A JSON string from the `dehydrate` method.
+   */
+  rehydrate(hydratedState) {
+    try {
+      const parsedState = JSON.parse(hydratedState);
+      for (const key in parsedState) {
+        this.setState(key, () => parsedState[key]);
+      }
+    } catch (e) {
+      console.error("[api-core-lib] Failed to rehydrate state:", e);
+    }
+  }
+};
+var globalStateManager = new GlobalStateManager();
+
+// src/hooks/useApiModule/useApiModule.ts
+var ApiModuleContext = (0, import_react4.createContext)(null);
+var ApiModuleProvider = ApiModuleContext.Provider;
+function useApiActionState(actionConfig, cacheKey, actionExecutor, enabled) {
+  const state = (0, import_react4.useSyncExternalStore)(
+    (callback) => globalStateManager.subscribe(cacheKey, callback),
+    () => globalStateManager.getSnapshot(cacheKey)
+  );
+  const input = actionConfig.hasQuery ? state.options : void 0;
+  (0, import_react4.useEffect)(() => {
+    if (enabled && actionConfig.autoFetch && !state.called && !state.loading) {
+      actionExecutor(input);
+    } else if (enabled && state.isStale && !state.loading) {
+      actionExecutor(input);
+    }
+  }, [enabled, state.isStale, state.loading, state.called, actionConfig.autoFetch, actionExecutor, input]);
+  return state;
+}
+function useModuleContext() {
+  const context = (0, import_react4.useContext)(ApiModuleContext);
+  if (!context) {
+    throw new Error("useModuleContext must be used within an ApiModuleProvider");
+  }
+  return context;
+}
+var generateCacheKey = (moduleName, actionName, input, callOptions = {}) => {
+  const params = { path: callOptions.pathParams, body: input };
+  try {
+    return `${moduleName}/${actionName}::${JSON.stringify(params)}`;
+  } catch (error) {
+    return `${moduleName}/${actionName}::${Date.now()}`;
+  }
+};
+function useApiModule(axiosInstance, moduleConfig, options = {}) {
+  const { refetchOnWindowFocus = true, onSuccess, onError, pathParams: modulePathParams, enabled = true, hydratedState } = options;
+  const pathParamsString = (0, import_react4.useMemo)(() => JSON.stringify(modulePathParams || {}), [modulePathParams]);
+  const [queryOptions, setQueryOptions] = (0, import_react4.useState)({});
+  const savedCallbacks = (0, import_react4.useRef)({ onSuccess, onError });
+  (0, import_react4.useEffect)(() => {
+    savedCallbacks.current = { onSuccess, onError };
+  }, [onSuccess, onError]);
+  (0, import_react4.useMemo)(() => {
+    if (hydratedState) {
+      globalStateManager.rehydrate(hydratedState);
+    }
+  }, [hydratedState]);
+  const actions = (0, import_react4.useMemo)(() => {
+    return Object.keys(moduleConfig.actions).reduce((acc, actionName) => {
+      const actionConfig = moduleConfig.actions[actionName];
+      const execute = async (input, options2 = {}) => {
+        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
+        const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
+        let mutationContext;
+        try {
+          if (options2.onMutate) {
+            mutationContext = await options2.onMutate(input);
+          }
+          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, loading: true, called: true, error: null, isStale: false }));
+          const result = await callDynamicApi(axiosInstance, moduleConfig.baseEndpoint, actionConfig, {
+            pathParams: finalPathParams,
+            body: input,
+            config: options2.config
+          });
+          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, ...result, loading: false }));
+          if (result.success) {
+            savedCallbacks.current.onSuccess?.(actionName, result.message || "Action successful", result.data);
+            options2.onSuccess?.(result.data, mutationContext);
+            actionConfig.invalidates?.forEach((keyToInvalidate) => {
+              const prefix = `${moduleConfig.baseEndpoint}/${keyToInvalidate}::`;
+              globalStateManager.invalidateByPrefix(prefix);
+            });
+          } else {
+            savedCallbacks.current.onError?.(actionName, result.message || "Action failed", result.error ?? void 0);
+            options2.onError?.(result.error, mutationContext);
+          }
+          return result;
+        } catch (error) {
+          const apiError = { status: 500, message: error.message };
+          const errorResult = { data: null, error: apiError, loading: false, success: false, rawResponse: error };
+          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, ...errorResult, loading: false }));
+          savedCallbacks.current.onError?.(actionName, apiError.message, apiError);
+          options2.onError?.(apiError, mutationContext);
+          return errorResult;
+        }
+      };
+      const reset = (input, options2 = {}) => {
+        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
+        const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
+        globalStateManager.setState(cacheKey, () => ({
+          data: null,
+          error: null,
+          loading: false,
+          success: false,
+          called: false,
+          isStale: false,
+          rawResponse: null
+        }));
+      };
+      acc[actionName] = { execute, reset };
+      return acc;
+    }, {});
+  }, [axiosInstance, moduleConfig, pathParamsString]);
+  const queries = (0, import_react4.useMemo)(() => {
+    const builtQueries = {};
+    for (const actionName in moduleConfig.actions) {
+      if (moduleConfig.actions[actionName]?.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 = {};
+  for (const actionName in moduleConfig.actions) {
+    if (Object.prototype.hasOwnProperty.call(moduleConfig.actions, actionName)) {
+      const actionConfig = moduleConfig.actions[actionName];
+      const query = queries[actionName]?.options;
+      const input = actionConfig.hasQuery ? query : void 0;
+      const pathParams = JSON.parse(pathParamsString);
+      const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams });
+      states[actionName] = useApiActionState(
+        actionConfig,
+        cacheKey,
+        actions[actionName].execute,
+        enabled
+      );
+    }
+  }
+  (0, import_react4.useEffect)(() => {
+    if (!enabled) return;
+    const actionKeys = Object.keys(moduleConfig.actions);
+    for (const actionName of actionKeys) {
+      const state = states[actionName];
+      const actionConfig = moduleConfig.actions[actionName];
+      if (actionConfig.autoFetch && state && !state.called && !state.loading) {
+        const query = queries[actionName]?.options;
+        const input = actionConfig.hasQuery ? query : void 0;
+        actions[actionName].execute(input);
+      }
+    }
+  }, [enabled, moduleConfig, actions, states, queries]);
+  const lastBlurTimestamp = (0, import_react4.useRef)(Date.now());
+  (0, import_react4.useEffect)(() => {
+    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}::`;
+            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 = (0, import_react4.useMemo)(() => {
+    return () => globalStateManager.dehydrate();
+  }, []);
+  return { actions, states, queries, dehydrate };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiModuleProvider,
+  useApi,
+  useApiModule,
+  useApiRecord,
+  useDeepCompareEffect,
+  useModuleContext
+});