@exyconn/common 2.3.2 → 2.3.4

package/dist/client/index.js

@@ -29,108 +29,548 @@ function _interopNamespace(e) {
 var axios__default = /*#__PURE__*/_interopDefault(axios);
 var Yup__namespace = /*#__PURE__*/_interopNamespace(Yup);
 
-// src/client/http/axios-instance.ts
-var createHttpClient = (options) => {
-  const {
-    baseURL,
-    timeout = 3e4,
-    withCredentials = true,
-    getAuthToken,
-    onUnauthorized,
-    onServerError
-  } = options;
-  const instance = axios__default.default.create({
-    baseURL,
-    timeout,
-    withCredentials,
-    headers: {
-      "Content-Type": "application/json"
+// src/client/http/http.ts
+
+// src/client/http/logger.ts
+var Logger = class {
+  constructor() {
+    this.isDevelopment = typeof window !== "undefined" && window.location.hostname === "localhost";
+  }
+  /**
+   * Log informational messages
+   */
+  info(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.log(`${prefix} ${message}`, data ?? "");
     }
-  });
-  instance.interceptors.request.use(
-    (config) => {
-      if (getAuthToken) {
-        const token = getAuthToken();
-        if (token && config.headers) {
-          config.headers.Authorization = `Bearer ${token}`;
-        }
+  }
+  /**
+   * Log warning messages
+   */
+  warn(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.warn(`${prefix} ${message}`, data ?? "");
+    }
+  }
+  /**
+   * Log error messages
+   */
+  error(message, error, options) {
+    const prefix = options?.context ? `[${options.context}]` : "";
+    if (this.isDevelopment) {
+      console.error(`${prefix} ${message}`, error, options?.metadata || "");
+    }
+  }
+  /**
+   * Log debug messages (only in development)
+   */
+  debug(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.debug(`${prefix} ${message}`, data || "");
+    }
+  }
+  /**
+   * Log API errors with structured information
+   */
+  apiError(endpoint, error, metadata) {
+    this.error(`API Error: ${endpoint}`, error, {
+      context: "API",
+      metadata: {
+        endpoint,
+        ...metadata
       }
-      return config;
-    },
-    (error) => Promise.reject(error)
-  );
-  instance.interceptors.response.use(
-    (response) => response,
-    (error) => {
-      if (error.response) {
-        const status = error.response.status;
-        if (status === 401 && onUnauthorized) {
-          onUnauthorized();
+    });
+  }
+};
+var logger = new Logger();
+
+// src/client/http/response-parser.ts
+var STATUS_CODES = {
+  SUCCESS: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  ERROR: 500
+};
+var STATUS_MESSAGES = {
+  SUCCESS: "success",
+  CREATED: "created",
+  NO_CONTENT: "no_content",
+  BAD_REQUEST: "bad_request",
+  UNAUTHORIZED: "unauthorized",
+  FORBIDDEN: "forbidden",
+  NOT_FOUND: "not_found",
+  CONFLICT: "conflict",
+  ERROR: "error"
+};
+var SUCCESS_CODES = [200, 201, 204];
+var ERROR_CODES = [400, 401, 403, 404, 409, 500];
+var parseResponseData = (response, fallback = null) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("data" in resp) {
+      return resp["data"] ?? fallback;
+    }
+    return response;
+  } catch (error) {
+    logger.error("Error parsing response data", error);
+    return fallback;
+  }
+};
+var parseResponseMessage = (response, fallback = "") => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("message" in resp && typeof resp["message"] === "string") {
+      return resp["message"];
+    }
+    return fallback;
+  } catch (error) {
+    logger.error("Error parsing response message", error);
+    return fallback;
+  }
+};
+var parseResponseStatus = (response) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return null;
+    }
+    const resp = response;
+    if ("statusCode" in resp && typeof resp["statusCode"] === "number") {
+      return resp["statusCode"];
+    }
+    if ("status" in resp && typeof resp["status"] === "number") {
+      return resp["status"];
+    }
+    return null;
+  } catch (error) {
+    logger.error("Error parsing response status", error);
+    return null;
+  }
+};
+var parseResponseStatusMessage = (response, fallback = "") => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("status" in resp && typeof resp["status"] === "string") {
+      return resp["status"];
+    }
+    return fallback;
+  } catch (error) {
+    logger.error("Error parsing response status message", error);
+    return fallback;
+  }
+};
+var isSuccessResponse = (response) => {
+  try {
+    const statusCode = parseResponseStatus(response);
+    if (statusCode !== null) {
+      return SUCCESS_CODES.includes(statusCode);
+    }
+    const status = parseResponseStatusMessage(response);
+    return [STATUS_MESSAGES.SUCCESS, STATUS_MESSAGES.CREATED, STATUS_MESSAGES.NO_CONTENT].includes(
+      status
+    );
+  } catch (error) {
+    logger.error("Error checking response success", error);
+    return false;
+  }
+};
+var isErrorResponse = (response) => {
+  try {
+    const statusCode = parseResponseStatus(response);
+    if (statusCode !== null) {
+      return ERROR_CODES.includes(statusCode);
+    }
+    return false;
+  } catch (error) {
+    logger.error("Error checking response error", error);
+    return false;
+  }
+};
+var parsePaginatedResponse = (response) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return { items: [], total: 0, page: 1, limit: 10 };
+    }
+    const resp = response;
+    let items = [];
+    if ("data" in resp && Array.isArray(resp["data"])) {
+      items = resp["data"];
+    }
+    let total = items.length;
+    let page = 1;
+    let limit = 10;
+    let totalPages;
+    if ("paginationData" in resp && resp["paginationData"] && typeof resp["paginationData"] === "object") {
+      const paginationData = resp["paginationData"];
+      if ("total" in paginationData && typeof paginationData["total"] === "number") {
+        total = paginationData["total"];
+      }
+      if ("page" in paginationData && typeof paginationData["page"] === "number") {
+        page = paginationData["page"];
+      }
+      if ("limit" in paginationData && typeof paginationData["limit"] === "number") {
+        limit = paginationData["limit"];
+      }
+      if ("totalPages" in paginationData && typeof paginationData["totalPages"] === "number") {
+        totalPages = paginationData["totalPages"];
+      }
+    }
+    let columns;
+    if ("columns" in resp && Array.isArray(resp["columns"])) {
+      columns = resp["columns"];
+    }
+    return {
+      items,
+      total,
+      page,
+      limit,
+      ...totalPages !== void 0 && { totalPages },
+      ...columns !== void 0 && { columns }
+    };
+  } catch (error) {
+    logger.error("Error parsing paginated response", error);
+    return { items: [], total: 0, page: 1, limit: 10 };
+  }
+};
+var extractNestedData = (response, path, fallback = null) => {
+  try {
+    const keys = path.split(".");
+    let current = response;
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return fallback;
+      }
+    }
+    return current;
+  } catch (error) {
+    logger.error("Error extracting nested data", error);
+    return fallback;
+  }
+};
+var safeJsonParse = (json, fallback = null) => {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    logger.error("Error parsing JSON", error);
+    return fallback;
+  }
+};
+var parseAxiosErrorMessage = (error) => {
+  try {
+    if (!error || typeof error !== "object") {
+      return "An unexpected error occurred";
+    }
+    const err = error;
+    if ("response" in err && err["response"] && typeof err["response"] === "object") {
+      const response = err["response"];
+      if ("data" in response && response["data"] && typeof response["data"] === "object") {
+        const data = response["data"];
+        if ("data" in data && data["data"] && typeof data["data"] === "object") {
+          const nestedData = data["data"];
+          if ("message" in nestedData && typeof nestedData["message"] === "string") {
+            return nestedData["message"];
+          }
         }
-        if (status >= 500 && onServerError) {
-          onServerError(error);
+        if ("message" in data && typeof data["message"] === "string") {
+          return data["message"];
+        }
+        if ("error" in data && typeof data["error"] === "string") {
+          return data["error"];
         }
       }
-      return Promise.reject(error);
     }
-  );
-  return instance;
+    if ("message" in err && typeof err["message"] === "string") {
+      return err["message"];
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    return "An unexpected error occurred";
+  } catch (parseError2) {
+    logger.error("Error parsing axios error message", parseError2);
+    return "An unexpected error occurred";
+  }
+};
+var parseError = (error) => {
+  try {
+    if (!error || typeof error !== "object") {
+      return {
+        message: "An unexpected error occurred",
+        statusCode: null,
+        data: null
+      };
+    }
+    const err = error;
+    let statusCode = null;
+    let data = null;
+    let status;
+    if ("response" in err && err["response"] && typeof err["response"] === "object") {
+      const response = err["response"];
+      if ("status" in response && typeof response["status"] === "number") {
+        statusCode = response["status"];
+      }
+      if ("data" in response && response["data"] !== void 0) {
+        data = response["data"];
+        if (data && typeof data === "object" && "status" in data) {
+          const dataObj = data;
+          if (typeof dataObj["status"] === "string") {
+            status = dataObj["status"];
+          }
+        }
+      }
+    }
+    if (statusCode === null && "statusCode" in err && typeof err["statusCode"] === "number") {
+      statusCode = err["statusCode"];
+    }
+    if (data === null && "data" in err && err["data"] !== void 0) {
+      data = err["data"];
+    }
+    if (!status && "status" in err && typeof err["status"] === "string") {
+      status = err["status"];
+    }
+    return {
+      message: parseAxiosErrorMessage(error),
+      statusCode,
+      data,
+      ...status !== void 0 && { status }
+    };
+  } catch (err) {
+    logger.error("Error parsing error object", err);
+    return {
+      message: "An unexpected error occurred",
+      statusCode: null,
+      data: null
+    };
+  }
+};
+var simpleParseResponse = (response) => {
+  return response?.data?.data?.data;
+};
+var simpleMetaParseResponse = (response) => {
+  return response?.data?.data?.meta;
 };
-var withFormData = () => ({
+var simpleParseDualDataResponse = (response) => {
+  return response?.data?.data;
+};
+
+// src/client/http/http.ts
+var defaultConfig = {
+  baseUrl: typeof window !== "undefined" && window.location.hostname === "localhost" ? "http://localhost:4002" : "https://service-api.exyconn.com",
+  apiPrefix: "/v1/api",
+  timeout: 3e4,
+  defaultHeaders: {}
+};
+var currentConfig = { ...defaultConfig };
+var axiosInstance = axios__default.default.create({
+  baseURL: defaultConfig.baseUrl,
+  timeout: defaultConfig.timeout,
   headers: {
-    "Content-Type": "multipart/form-data"
+    "Content-Type": "application/json"
   }
 });
-var withTimeout = (ms) => ({
-  timeout: ms
-});
-var withAbortSignal = (signal) => ({
-  signal
-});
-
-// src/client/http/response-parser.ts
-var parseResponse = (response) => {
-  if (response.data?.success && response.data?.data !== void 0) {
-    return response.data.data;
+var getApiBaseUrl = () => {
+  return currentConfig.baseUrl || defaultConfig.baseUrl;
+};
+var setApiBaseUrl = (baseUrl) => {
+  currentConfig.baseUrl = baseUrl;
+  axiosInstance.defaults.baseURL = baseUrl;
+  logger.info(`API Base URL updated to: ${baseUrl}`);
+};
+var getApiPrefix = () => {
+  return currentConfig.apiPrefix || defaultConfig.apiPrefix;
+};
+var setApiPrefix = (prefix) => {
+  currentConfig.apiPrefix = prefix;
+  logger.info(`API Prefix updated to: ${prefix}`);
+};
+var getCustomHeaders = () => {
+  return { ...currentConfig.defaultHeaders };
+};
+var setCustomHeader = (key, value) => {
+  if (!currentConfig.defaultHeaders) {
+    currentConfig.defaultHeaders = {};
   }
-  return null;
+  currentConfig.defaultHeaders[key] = value;
+  axiosInstance.defaults.headers.common[key] = value;
+  logger.info(`Custom header added: ${key}`);
 };
-var parseFullResponse = (response) => {
-  return response.data;
+var removeCustomHeader = (key) => {
+  if (currentConfig.defaultHeaders) {
+    delete currentConfig.defaultHeaders[key];
+  }
+  delete axiosInstance.defaults.headers.common[key];
+  logger.info(`Custom header removed: ${key}`);
 };
-var parseError = (error) => {
-  if (error.response?.data?.message) {
-    return error.response.data.message;
+var setCustomHeaders = (headers) => {
+  currentConfig.defaultHeaders = { ...currentConfig.defaultHeaders, ...headers };
+  Object.entries(headers).forEach(([key, value]) => {
+    axiosInstance.defaults.headers.common[key] = value;
+  });
+  logger.info(`Multiple custom headers added: ${Object.keys(headers).join(", ")}`);
+};
+var clearCustomHeaders = () => {
+  if (currentConfig.defaultHeaders) {
+    Object.keys(currentConfig.defaultHeaders).forEach((key) => {
+      delete axiosInstance.defaults.headers.common[key];
+    });
+  }
+  currentConfig.defaultHeaders = {};
+  logger.info("All custom headers cleared");
+};
+var configureHttp = (config) => {
+  if (config.baseUrl) {
+    setApiBaseUrl(config.baseUrl);
   }
-  if (error.response?.data?.error) {
-    return error.response.data.error;
+  if (config.apiPrefix) {
+    setApiPrefix(config.apiPrefix);
   }
-  if (error.code === "ERR_NETWORK") {
-    return "Network error. Please check your connection.";
+  if (config.timeout !== void 0) {
+    currentConfig.timeout = config.timeout;
+    axiosInstance.defaults.timeout = config.timeout;
   }
-  if (error.code === "ECONNABORTED") {
-    return "Request timed out. Please try again.";
+  if (config.defaultHeaders) {
+    setCustomHeaders(config.defaultHeaders);
   }
-  return error.message || "An unexpected error occurred.";
+  logger.info("HTTP client configured successfully");
 };
-var isSuccess = (response) => {
-  return response.data?.success === true;
+var getHttpConfig = () => {
+  return { ...currentConfig };
 };
-var isStatusError = (error, statusCode) => {
-  return error.response?.status === statusCode;
+var resetHttpConfig = () => {
+  currentConfig = { ...defaultConfig };
+  axiosInstance.defaults.baseURL = defaultConfig.baseUrl;
+  axiosInstance.defaults.timeout = defaultConfig.timeout;
+  clearCustomHeaders();
+  logger.info("HTTP configuration reset to defaults");
 };
-var isUnauthorized = (error) => {
-  return isStatusError(error, 401);
+var API_BASE_URL = getApiBaseUrl();
+var API_PREFIX = getApiPrefix();
+axiosInstance.interceptors.request.use(
+  (config) => {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const selectedOrg = localStorage.getItem("selectedOrganization");
+        if (selectedOrg) {
+          const org = JSON.parse(selectedOrg);
+          if (org && org._id) {
+            config.headers["x-organization-id"] = org._id;
+          }
+        }
+      }
+    } catch (error) {
+      logger.warn("Failed to read organization from localStorage", error);
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+axiosInstance.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    const parsedError = parseError(error);
+    logger.error("API Error", parsedError);
+    return Promise.reject(parsedError);
+  }
+);
+var buildHeaders = (customHeaders) => {
+  const headers = {
+    "Content-Type": "application/json",
+    ...currentConfig.defaultHeaders,
+    // Add global custom headers
+    ...customHeaders
+    // Request-specific headers override global ones
+  };
+  return headers;
+};
+var buildConfig = (params, customHeaders) => {
+  const config = {
+    headers: buildHeaders(customHeaders)
+  };
+  if (params) {
+    config.params = params;
+  }
+  return config;
 };
-var isForbidden = (error) => {
-  return isStatusError(error, 403);
+var getRequest = async (url, params, customHeaders) => {
+  const config = buildConfig(params, customHeaders);
+  return axiosInstance.get(url, config);
 };
-var isNotFound = (error) => {
-  return isStatusError(error, 404);
+var postRequest = async (url, data, customHeaders) => {
+  const config = buildConfig(void 0, customHeaders);
+  return axiosInstance.post(url, data, config);
 };
-var isServerError = (error) => {
-  const status = error.response?.status;
-  return status !== void 0 && status >= 500;
+var putRequest = async (url, data, customHeaders) => {
+  const config = buildConfig(void 0, customHeaders);
+  return axiosInstance.put(url, data, config);
+};
+var patchRequest = async (url, data, customHeaders) => {
+  const config = buildConfig(void 0, customHeaders);
+  return axiosInstance.patch(url, data, config);
+};
+var deleteRequest = async (url, params, customHeaders) => {
+  const config = buildConfig(params, customHeaders);
+  return axiosInstance.delete(url, config);
+};
+var uploadFile = async (url, file, additionalData) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  if (additionalData) {
+    Object.entries(additionalData).forEach(([key, value]) => {
+      formData.append(key, String(value));
+    });
+  }
+  const config = {
+    headers: {
+      "Content-Type": "multipart/form-data"
+    }
+  };
+  return axiosInstance.post(url, formData, config);
+};
+var extractData = (response) => {
+  return parseResponseData(response.data);
+};
+var extractMessage = (response) => {
+  return parseResponseMessage(response, "");
+};
+var isSuccess = (response) => {
+  return response.status >= 200 && response.status < 300;
+};
+var extractPaginatedData = (response) => {
+  return parsePaginatedResponse(response.data);
+};
+
+// src/client/http/slug.ts
+var generateSlug = (text) => {
+  if (!text) return "";
+  return text.trim().replace(/[^\w\s]/g, "").replace(/\s+(.)/g, (_, char) => char.toUpperCase()).replace(/\s+/g, "").replace(/^(.)/, (_, char) => char.toLowerCase());
+};
+var generateUrlSlug = (text) => {
+  if (!text) return "";
+  return text.trim().toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+};
+var generateSnakeSlug = (text) => {
+  if (!text) return "";
+  return text.trim().toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
 };
 
 // src/client/logger/client-logger.ts
@@ -286,40 +726,6 @@ var formatRelativeTime = (date) => {
   }
   return "just now";
 };
-var formatDateForInput = (date) => {
-  const dateObj = new Date(date);
-  return dateObj.toISOString().split("T")[0];
-};
-var formatDateTimeForInput = (date) => {
-  const dateObj = new Date(date);
-  return dateObj.toISOString().slice(0, 16);
-};
-var isToday = (date) => {
-  const dateObj = new Date(date);
-  const today = /* @__PURE__ */ new Date();
-  return dateObj.getDate() === today.getDate() && dateObj.getMonth() === today.getMonth() && dateObj.getFullYear() === today.getFullYear();
-};
-var isPast = (date) => {
-  return new Date(date).getTime() < Date.now();
-};
-var isFuture = (date) => {
-  return new Date(date).getTime() > Date.now();
-};
-var addDays = (date, days) => {
-  const dateObj = new Date(date);
-  dateObj.setDate(dateObj.getDate() + days);
-  return dateObj;
-};
-var startOfDay = (date) => {
-  const dateObj = new Date(date);
-  dateObj.setHours(0, 0, 0, 0);
-  return dateObj;
-};
-var endOfDay = (date) => {
-  const dateObj = new Date(date);
-  dateObj.setHours(23, 59, 59, 999);
-  return dateObj;
-};
 
 // src/client/utils/clipboard.ts
 var copyToClipboard = async (text) => {
@@ -344,20 +750,6 @@ var copyToClipboard = async (text) => {
     return false;
   }
 };
-var readFromClipboard = async () => {
-  try {
-    if (navigator.clipboard && window.isSecureContext) {
-      return await navigator.clipboard.readText();
-    }
-    return null;
-  } catch (error) {
-    console.error("Failed to read from clipboard:", error);
-    return null;
-  }
-};
-var isClipboardAvailable = () => {
-  return !!(navigator.clipboard && window.isSecureContext);
-};
 
 // src/client/utils/slug.ts
 var slugify = (text) => {
@@ -394,165 +786,15 @@ var kebabToCamel = (text) => {
   return text.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
 };
 
-// src/client/utils/events.ts
-var EventEmitter = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Subscribe to an event
-   * @returns Unsubscribe function
-   */
-  on(event, handler) {
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(event).add(handler);
-    return () => this.off(event, handler);
-  }
-  /**
-   * Subscribe to an event once
-   */
-  once(event, handler) {
-    const wrappedHandler = (data) => {
-      this.off(event, wrappedHandler);
-      handler(data);
-    };
-    return this.on(event, wrappedHandler);
-  }
-  /**
-   * Unsubscribe from an event
-   */
-  off(event, handler) {
-    const eventHandlers = this.handlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.delete(handler);
-    }
-  }
-  /**
-   * Emit an event
-   */
-  emit(event, data) {
-    const eventHandlers = this.handlers.get(event);
-    if (eventHandlers) {
-      eventHandlers.forEach((handler) => {
-        try {
-          handler(data);
-        } catch (error) {
-          console.error(`Error in event handler for "${String(event)}":`, error);
-        }
-      });
-    }
-  }
-  /**
-   * Remove all handlers for an event (or all events)
-   */
-  removeAllListeners(event) {
-    if (event) {
-      this.handlers.delete(event);
-    } else {
-      this.handlers.clear();
-    }
-  }
-  /**
-   * Get count of listeners for an event
-   */
-  listenerCount(event) {
-    return this.handlers.get(event)?.size ?? 0;
-  }
-};
-var createEventEmitter = () => {
-  return new EventEmitter();
-};
-var appEvents = new EventEmitter();
-
-// src/client/utils/api-urls.ts
-var ApiUrlBuilder = class {
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.version = config.version || "";
-  }
-  /**
-   * Build full URL from path
-   */
-  build(path) {
-    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-    const versionPath = this.version ? `/${this.version}` : "";
-    return `${this.baseUrl}${versionPath}${normalizedPath}`;
-  }
-  /**
-   * Build URL with query parameters
-   */
-  buildWithParams(path, params) {
-    const url = this.build(path);
-    const filteredParams = Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
-    return filteredParams ? `${url}?${filteredParams}` : url;
-  }
-  /**
-   * Build URL with path parameters
-   */
-  buildWithPathParams(template, params) {
-    let path = template;
-    Object.entries(params).forEach(([key, value]) => {
-      path = path.replace(`:${key}`, String(value));
-      path = path.replace(`{${key}}`, String(value));
-    });
-    return this.build(path);
-  }
-  /**
-   * Get base URL
-   */
-  getBaseUrl() {
-    return this.baseUrl;
-  }
-  /**
-   * Set new base URL
-   */
-  setBaseUrl(baseUrl) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-  }
-};
-var createApiUrlBuilder = (config) => {
-  return new ApiUrlBuilder(config);
-};
-var createApiEndpoints = (builder) => ({
-  // Auth endpoints
-  auth: {
-    login: () => builder.build("/auth/login"),
-    register: () => builder.build("/auth/register"),
-    logout: () => builder.build("/auth/logout"),
-    refresh: () => builder.build("/auth/refresh"),
-    me: () => builder.build("/auth/me"),
-    forgotPassword: () => builder.build("/auth/forgot-password"),
-    resetPassword: () => builder.build("/auth/reset-password")
-  },
-  // User endpoints
-  users: {
-    list: () => builder.build("/users"),
-    get: (id) => builder.buildWithPathParams("/users/:id", { id }),
-    create: () => builder.build("/users"),
-    update: (id) => builder.buildWithPathParams("/users/:id", { id }),
-    delete: (id) => builder.buildWithPathParams("/users/:id", { id })
-  },
-  // Generic CRUD factory
-  crud: (resource) => ({
-    list: () => builder.build(`/${resource}`),
-    get: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id }),
-    create: () => builder.build(`/${resource}`),
-    update: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id }),
-    delete: (id) => builder.buildWithPathParams(`/${resource}/:id`, { id })
-  })
-});
-
 // src/client/utils/response-parser.ts
-var isSuccessResponse = (response) => {
+var isSuccessResponse2 = (response) => {
   return response.success === true;
 };
-var isErrorResponse = (response) => {
+var isErrorResponse2 = (response) => {
   return response.success === false;
 };
 var getResponseData = (response, defaultValue) => {
-  if (isSuccessResponse(response) && response.data !== void 0) {
+  if (isSuccessResponse2(response) && response.data !== void 0) {
     return response.data;
   }
   return defaultValue;
@@ -2793,18 +3035,18 @@ function useLogger(componentName, props, options = {}) {
   const {
     logProps = true,
     logLifecycle = true,
-    logger = console.log
+    logger: logger2 = console.log
   } = options;
   const previousProps = react.useRef(props);
   const renderCount = react.useRef(0);
   renderCount.current++;
   react.useEffect(() => {
     if (logLifecycle) {
-      logger(`[${componentName}] Mounted`);
+      logger2(`[${componentName}] Mounted`);
     }
     return () => {
       if (logLifecycle) {
-        logger(`[${componentName}] Unmounted (rendered ${renderCount.current} times)`);
+        logger2(`[${componentName}] Unmounted (rendered ${renderCount.current} times)`);
       }
     };
   }, []);
@@ -2836,12 +3078,12 @@ function useLogger(componentName, props, options = {}) {
       });
     }
     if (hasChanges) {
-      logger(`[${componentName}] Props changed:`, changedProps);
+      logger2(`[${componentName}] Props changed:`, changedProps);
     }
     previousProps.current = props;
-  }, [componentName, props, logProps, logger]);
+  }, [componentName, props, logProps, logger2]);
   if (process.env.NODE_ENV === "development") {
-    logger(`[${componentName}] Render #${renderCount.current}`);
+    logger2(`[${componentName}] Render #${renderCount.current}`);
   }
 }
 var useLogger_default = useLogger;
@@ -5628,34 +5870,34 @@ function RegisterForm({
   ) });
 }
 
-exports.ApiUrlBuilder = ApiUrlBuilder;
+exports.API_BASE_URL = API_BASE_URL;
+exports.API_PREFIX = API_PREFIX;
 exports.ClientLogger = ClientLogger;
 exports.ContactForm = ContactForm;
-exports.EventEmitter = EventEmitter;
+exports.ERROR_CODES = ERROR_CODES;
 exports.LoginForm = LoginForm;
 exports.NewsletterForm = NewsletterForm;
 exports.RegisterForm = RegisterForm;
+exports.STATUS_CODES = STATUS_CODES;
+exports.STATUS_MESSAGES = STATUS_MESSAGES;
+exports.SUCCESS_CODES = SUCCESS_CODES;
 exports.ThemeContext = ThemeContext;
 exports.ThemeProvider = ThemeProvider;
 exports.ThemeToggle = ThemeToggle;
 exports.VALIDATION_MESSAGES = VALIDATION_MESSAGES;
-exports.addDays = addDays;
 exports.adjustColor = adjustColor;
-exports.appEvents = appEvents;
+exports.axios = axiosInstance;
 exports.camelToKebab = camelToKebab;
 exports.capitalize = capitalize;
 exports.capitalizeWords = capitalizeWords;
-exports.checkPackage = checkPackage;
+exports.clearCustomHeaders = clearCustomHeaders;
 exports.clientLogger = clientLogger;
+exports.configureHttp = configureHttp;
 exports.contactFormSchema = contactFormSchema;
 exports.copyToClipboard = copyToClipboard;
-exports.createApiEndpoints = createApiEndpoints;
-exports.createApiUrlBuilder = createApiUrlBuilder;
 exports.createClientLogger = createClientLogger;
 exports.createEmptyPaginationMeta = createEmptyPaginationMeta;
 exports.createErrorResponse = createErrorResponse;
-exports.createEventEmitter = createEventEmitter;
-exports.createHttpClient = createHttpClient;
 exports.createRegisterFormSchema = createRegisterFormSchema;
 exports.createSuccessResponse = createSuccessResponse;
 exports.createTheme = createTheme;
@@ -5664,6 +5906,7 @@ exports.cssVar = cssVar;
 exports.deepMerge = deepMerge;
 exports.defaultDarkTheme = defaultDarkTheme;
 exports.defaultLightTheme = defaultLightTheme;
+exports.deleteRequest = deleteRequest;
 exports.dummyBannerData = dummyBannerData;
 exports.dummyFaqItems = dummyFaqItems;
 exports.dummyFeatures = dummyFeatures;
@@ -5672,59 +5915,76 @@ exports.dummyHeaderData = dummyHeaderData;
 exports.dummyImage = dummyImage;
 exports.dummyPricingPlans = dummyPricingPlans;
 exports.dummyTestimonials = dummyTestimonials;
-exports.endOfDay = endOfDay;
+exports.extractData = extractData;
+exports.extractMessage = extractMessage;
+exports.extractNestedData = extractNestedData;
+exports.extractPaginatedData = extractPaginatedData;
 exports.flattenToCssVars = flattenToCssVars;
 exports.formatDate = formatDate;
-exports.formatDateForInput = formatDateForInput;
 exports.formatDateTime = formatDateTime;
-exports.formatDateTimeForInput = formatDateTimeForInput;
-exports.formatPackageCheckResult = formatPackageCheckResult;
 exports.formatRelativeTime = formatRelativeTime;
 exports.generateCssVars = generateCssVars;
-exports.generateNcuCommand = generateNcuCommand;
+exports.generateSlug = generateSlug;
+exports.generateSnakeSlug = generateSnakeSlug;
+exports.generateUrlSlug = generateUrlSlug;
+exports.getApiBaseUrl = getApiBaseUrl;
+exports.getApiPrefix = getApiPrefix;
 exports.getContrastColor = getContrastColor;
+exports.getCustomHeaders = getCustomHeaders;
 exports.getErrorMessage = getErrorMessage;
+exports.getHttpConfig = getHttpConfig;
 exports.getNextPage = getNextPage;
 exports.getPrevPage = getPrevPage;
+exports.getRequest = getRequest;
 exports.getResponseData = getResponseData;
 exports.getSystemColorScheme = getSystemColorScheme;
 exports.hasData = hasData;
 exports.hasMorePages = hasMorePages;
 exports.hexToRgba = hexToRgba;
 exports.injectCssVars = injectCssVars;
-exports.isClipboardAvailable = isClipboardAvailable;
 exports.isErrorResponse = isErrorResponse;
-exports.isForbidden = isForbidden;
-exports.isFuture = isFuture;
-exports.isNotFound = isNotFound;
-exports.isPast = isPast;
-exports.isServerError = isServerError;
-exports.isStatusError = isStatusError;
 exports.isSuccess = isSuccess;
 exports.isSuccessResponse = isSuccessResponse;
-exports.isToday = isToday;
-exports.isUnauthorized = isUnauthorized;
+exports.isUtilErrorResponse = isErrorResponse2;
+exports.isUtilSuccessResponse = isSuccessResponse2;
 exports.kebabToCamel = kebabToCamel;
 exports.loadThemeFromUrl = loadThemeFromUrl;
 exports.loadThemeMode = loadThemeMode;
+exports.logger = logger;
 exports.loginFormSchema = loginFormSchema;
 exports.loremIpsum = loremIpsum;
 exports.newsletterFormSchema = newsletterFormSchema;
 exports.packageCheck = packageCheck;
+exports.parseAxiosErrorMessage = parseAxiosErrorMessage;
 exports.parseError = parseError;
-exports.parseFullResponse = parseFullResponse;
-exports.parseResponse = parseResponse;
-exports.readFromClipboard = readFromClipboard;
+exports.parsePaginatedResponse = parsePaginatedResponse;
+exports.parseResponseData = parseResponseData;
+exports.parseResponseMessage = parseResponseMessage;
+exports.parseResponseStatus = parseResponseStatus;
+exports.parseResponseStatusMessage = parseResponseStatusMessage;
+exports.patchRequest = patchRequest;
+exports.postRequest = postRequest;
+exports.putRequest = putRequest;
 exports.registerFormSchema = registerFormSchema;
 exports.removeCssVars = removeCssVars;
+exports.removeCustomHeader = removeCustomHeader;
+exports.resetHttpConfig = resetHttpConfig;
 exports.resolveThemeMode = resolveThemeMode;
+exports.safeJsonParse = safeJsonParse;
 exports.saveThemeMode = saveThemeMode;
+exports.setApiBaseUrl = setApiBaseUrl;
+exports.setApiPrefix = setApiPrefix;
+exports.setCustomHeader = setCustomHeader;
+exports.setCustomHeaders = setCustomHeaders;
+exports.simpleMetaParseResponse = simpleMetaParseResponse;
+exports.simpleParseDualDataResponse = simpleParseDualDataResponse;
+exports.simpleParseResponse = simpleParseResponse;
 exports.slugify = slugify;
 exports.slugifyUnique = slugifyUnique;
-exports.startOfDay = startOfDay;
 exports.truncate = truncate;
 exports.truncateWords = truncateWords;
 exports.unslugify = unslugify;
+exports.uploadFile = uploadFile;
 exports.useBattery = useBattery_default;
 exports.useClickAway = useClickAway_default;
 exports.useContinuousRetry = useContinuousRetry_default;
@@ -5785,8 +6045,5 @@ exports.useToggle = useToggle_default;
 exports.useVisibilityChange = useVisibilityChange_default;
 exports.useWindowScroll = useWindowScroll_default;
 exports.useWindowSize = useWindowSize_default;
-exports.withAbortSignal = withAbortSignal;
-exports.withFormData = withFormData;
-exports.withTimeout = withTimeout;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map