@exyconn/common 1.0.0

package/dist/client/index.js

@@ -0,0 +1,964 @@
+'use strict';
+
+var axios = require('axios');
+var react = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// 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"
+    }
+  });
+  instance.interceptors.request.use(
+    (config) => {
+      if (getAuthToken) {
+        const token = getAuthToken();
+        if (token && config.headers) {
+          config.headers.Authorization = `Bearer ${token}`;
+        }
+      }
+      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();
+        }
+        if (status >= 500 && onServerError) {
+          onServerError(error);
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return instance;
+};
+var withFormData = () => ({
+  headers: {
+    "Content-Type": "multipart/form-data"
+  }
+});
+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;
+  }
+  return null;
+};
+var parseFullResponse = (response) => {
+  return response.data;
+};
+var parseError = (error) => {
+  if (error.response?.data?.message) {
+    return error.response.data.message;
+  }
+  if (error.response?.data?.error) {
+    return error.response.data.error;
+  }
+  if (error.code === "ERR_NETWORK") {
+    return "Network error. Please check your connection.";
+  }
+  if (error.code === "ECONNABORTED") {
+    return "Request timed out. Please try again.";
+  }
+  return error.message || "An unexpected error occurred.";
+};
+var isSuccess = (response) => {
+  return response.data?.success === true;
+};
+var isStatusError = (error, statusCode) => {
+  return error.response?.status === statusCode;
+};
+var isUnauthorized = (error) => {
+  return isStatusError(error, 401);
+};
+var isForbidden = (error) => {
+  return isStatusError(error, 403);
+};
+var isNotFound = (error) => {
+  return isStatusError(error, 404);
+};
+var isServerError = (error) => {
+  const status = error.response?.status;
+  return status !== void 0 && status >= 500;
+};
+
+// src/client/logger/client-logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var ClientLogger = class {
+  constructor(config = {}) {
+    this.buffer = [];
+    this.config = {
+      enabled: config.enabled ?? process.env.NODE_ENV !== "production",
+      minLevel: config.minLevel ?? "debug",
+      prefix: config.prefix ?? "[App]",
+      includeTimestamp: config.includeTimestamp ?? true,
+      remoteLogging: config.remoteLogging
+    };
+    if (this.config.remoteLogging?.enabled) {
+      const interval = this.config.remoteLogging.flushInterval ?? 3e4;
+      this.flushTimer = setInterval(() => this.flush(), interval);
+    }
+  }
+  shouldLog(level) {
+    if (!this.config.enabled) return false;
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.config.minLevel];
+  }
+  formatMessage(level, message) {
+    const parts = [];
+    if (this.config.includeTimestamp) {
+      parts.push(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
+    }
+    parts.push(this.config.prefix);
+    parts.push(`[${level.toUpperCase()}]`);
+    parts.push(message);
+    return parts.join(" ");
+  }
+  log(level, message, data) {
+    if (!this.shouldLog(level)) return;
+    const formattedMessage = this.formatMessage(level, message);
+    const entry = {
+      level,
+      message,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      prefix: this.config.prefix
+    };
+    switch (level) {
+      case "debug":
+        console.debug(formattedMessage, data ?? "");
+        break;
+      case "info":
+        console.info(formattedMessage, data ?? "");
+        break;
+      case "warn":
+        console.warn(formattedMessage, data ?? "");
+        break;
+      case "error":
+        console.error(formattedMessage, data ?? "");
+        break;
+    }
+    if (this.config.remoteLogging?.enabled) {
+      this.buffer.push(entry);
+      const batchSize = this.config.remoteLogging.batchSize ?? 10;
+      if (this.buffer.length >= batchSize) {
+        this.flush();
+      }
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  /**
+   * Flush buffered logs to remote endpoint
+   */
+  async flush() {
+    if (!this.config.remoteLogging?.enabled || this.buffer.length === 0) return;
+    const logs = [...this.buffer];
+    this.buffer = [];
+    try {
+      await fetch(this.config.remoteLogging.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ logs })
+      });
+    } catch (error) {
+      this.buffer = [...logs, ...this.buffer].slice(0, 100);
+      console.error("Failed to send logs to remote endpoint", error);
+    }
+  }
+  /**
+   * Cleanup logger (clear intervals)
+   */
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flush();
+  }
+};
+var createClientLogger = (config) => {
+  return new ClientLogger(config);
+};
+var clientLogger = new ClientLogger();
+
+// src/client/utils/date.ts
+var formatDate = (date, locale = "en-US") => {
+  const dateObj = new Date(date);
+  return dateObj.toLocaleDateString(locale, {
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+};
+var formatDateTime = (date, locale = "en-US") => {
+  const dateObj = new Date(date);
+  return dateObj.toLocaleDateString(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+};
+var formatRelativeTime = (date) => {
+  const dateObj = new Date(date);
+  const now = /* @__PURE__ */ new Date();
+  const diffInSeconds = Math.floor((now.getTime() - dateObj.getTime()) / 1e3);
+  const intervals = [
+    { label: "year", seconds: 31536e3 },
+    { label: "month", seconds: 2592e3 },
+    { label: "week", seconds: 604800 },
+    { label: "day", seconds: 86400 },
+    { label: "hour", seconds: 3600 },
+    { label: "minute", seconds: 60 },
+    { label: "second", seconds: 1 }
+  ];
+  for (const interval of intervals) {
+    const count = Math.floor(diffInSeconds / interval.seconds);
+    if (count >= 1) {
+      return `${count} ${interval.label}${count !== 1 ? "s" : ""} ago`;
+    }
+  }
+  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) => {
+  try {
+    if (navigator.clipboard && window.isSecureContext) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    }
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.style.position = "fixed";
+    textArea.style.left = "-999999px";
+    textArea.style.top = "-999999px";
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    const success = document.execCommand("copy");
+    document.body.removeChild(textArea);
+    return success;
+  } catch (error) {
+    console.error("Failed to copy to clipboard:", error);
+    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) => {
+  return text.toString().toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w\-]+/g, "").replace(/\-\-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+};
+var slugifyUnique = (text) => {
+  const baseSlug = slugify(text);
+  const uniqueSuffix = Date.now().toString(36) + Math.random().toString(36).substring(2, 5);
+  return `${baseSlug}-${uniqueSuffix}`;
+};
+var unslugify = (slug) => {
+  return slug.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+};
+var truncate = (text, maxLength, suffix = "...") => {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength - suffix.length).trim() + suffix;
+};
+var truncateWords = (text, maxWords, suffix = "...") => {
+  const words = text.split(/\s+/);
+  if (words.length <= maxWords) return text;
+  return words.slice(0, maxWords).join(" ") + suffix;
+};
+var capitalizeWords = (text) => {
+  return text.replace(/\b\w/g, (char) => char.toUpperCase());
+};
+var capitalize = (text) => {
+  if (!text) return "";
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};
+var camelToKebab = (text) => {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+};
+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) => {
+  return response.success === true;
+};
+var isErrorResponse = (response) => {
+  return response.success === false;
+};
+var getResponseData = (response, defaultValue) => {
+  if (isSuccessResponse(response) && response.data !== void 0) {
+    return response.data;
+  }
+  return defaultValue;
+};
+var getErrorMessage = (response, defaultMessage = "An error occurred") => {
+  if (response.error) {
+    return response.error;
+  }
+  if (response.message) {
+    return response.message;
+  }
+  return defaultMessage;
+};
+var hasData = (response) => {
+  return response.data !== null && response.data !== void 0;
+};
+var hasMorePages = (response) => {
+  return response.pagination.hasNextPage;
+};
+var getNextPage = (response) => {
+  if (response.pagination.hasNextPage) {
+    return response.pagination.page + 1;
+  }
+  return null;
+};
+var getPrevPage = (response) => {
+  if (response.pagination.hasPrevPage) {
+    return response.pagination.page - 1;
+  }
+  return null;
+};
+var createEmptyPaginationMeta = () => ({
+  total: 0,
+  page: 1,
+  limit: 10,
+  totalPages: 0,
+  hasNextPage: false,
+  hasPrevPage: false
+});
+var createSuccessResponse = (data, message = "Success") => ({
+  success: true,
+  message,
+  data,
+  statusCode: 200
+});
+var createErrorResponse = (message, statusCode = 400, error) => ({
+  success: false,
+  message,
+  error,
+  statusCode
+});
+function useLocalStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    syncTabs = true,
+    debug = false
+  } = options;
+  const log = react.useCallback(
+    (...args) => {
+      if (debug) console.log(`[useLocalStorage:${key}]`, ...args);
+    },
+    [debug, key]
+  );
+  const readValue = react.useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) {
+        return initialValue;
+      }
+      const parsed = deserializer(item);
+      log("Read value:", parsed);
+      return parsed;
+    } catch (error) {
+      console.warn(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  }, [key, initialValue, deserializer, log]);
+  const [storedValue, setStoredValue] = react.useState(readValue);
+  const setValue = react.useCallback(
+    (value) => {
+      if (typeof window === "undefined") {
+        console.warn(`Cannot set localStorage key "${key}" in non-browser environment`);
+        return;
+      }
+      try {
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoredValue(valueToStore);
+        window.localStorage.setItem(key, serializer(valueToStore));
+        log("Set value:", valueToStore);
+        window.dispatchEvent(new StorageEvent("storage", { key, newValue: serializer(valueToStore) }));
+      } catch (error) {
+        console.warn(`Error setting localStorage key "${key}":`, error);
+      }
+    },
+    [key, storedValue, serializer, log]
+  );
+  const removeValue = react.useCallback(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    try {
+      window.localStorage.removeItem(key);
+      setStoredValue(initialValue);
+      log("Removed value");
+      window.dispatchEvent(new StorageEvent("storage", { key, newValue: null }));
+    } catch (error) {
+      console.warn(`Error removing localStorage key "${key}":`, error);
+    }
+  }, [key, initialValue, log]);
+  react.useEffect(() => {
+    if (!syncTabs || typeof window === "undefined") {
+      return;
+    }
+    const handleStorageChange = (event) => {
+      if (event.key !== key) {
+        return;
+      }
+      log("Storage event received:", event.newValue);
+      if (event.newValue === null) {
+        setStoredValue(initialValue);
+      } else {
+        try {
+          setStoredValue(deserializer(event.newValue));
+        } catch {
+          console.warn(`Error parsing localStorage change for key "${key}"`);
+        }
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [key, initialValue, syncTabs, deserializer, log]);
+  return [storedValue, setValue, removeValue];
+}
+var useLocalStorage_default = useLocalStorage;
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = react.useState(value);
+  react.useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+var useDebounce_default = useDebounce;
+function useCopyToClipboard(resetDelay = 2e3) {
+  const [copied, setCopied] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const reset = react.useCallback(() => {
+    setCopied(false);
+    setError(null);
+  }, []);
+  const copy = react.useCallback(
+    async (text) => {
+      if (!navigator?.clipboard) {
+        try {
+          const textarea = document.createElement("textarea");
+          textarea.value = text;
+          textarea.style.position = "fixed";
+          textarea.style.left = "-999999px";
+          textarea.style.top = "-999999px";
+          document.body.appendChild(textarea);
+          textarea.focus();
+          textarea.select();
+          const successful = document.execCommand("copy");
+          document.body.removeChild(textarea);
+          if (successful) {
+            setCopied(true);
+            setError(null);
+            setTimeout(reset, resetDelay);
+            return true;
+          } else {
+            throw new Error("execCommand failed");
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
+          setError(message);
+          setCopied(false);
+          return false;
+        }
+      }
+      try {
+        await navigator.clipboard.writeText(text);
+        setCopied(true);
+        setError(null);
+        setTimeout(reset, resetDelay);
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
+        setError(message);
+        setCopied(false);
+        return false;
+      }
+    },
+    [resetDelay, reset]
+  );
+  return { copy, copied, error, reset };
+}
+var useCopyToClipboard_default = useCopyToClipboard;
+function usePageTitle(title, options = {}) {
+  const { suffix, separator = " | ", restoreOnUnmount = true } = options;
+  react.useEffect(() => {
+    const originalTitle = document.title;
+    const newTitle = suffix ? `${title}${separator}${suffix}` : title;
+    document.title = newTitle;
+    return () => {
+      if (restoreOnUnmount) {
+        document.title = originalTitle;
+      }
+    };
+  }, [title, suffix, separator, restoreOnUnmount]);
+}
+var usePageTitle_default = usePageTitle;
+function useInterval(callback, delay) {
+  const savedCallback = react.useRef(callback);
+  react.useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  react.useEffect(() => {
+    if (delay === null) {
+      return;
+    }
+    const tick = () => savedCallback.current();
+    const id = setInterval(tick, delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+var useInterval_default = useInterval;
+function useThemeDetector() {
+  const getCurrentTheme = () => {
+    if (typeof window === "undefined") return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  };
+  const [theme, setTheme] = react.useState(getCurrentTheme);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (e) => {
+      setTheme(e.matches ? "dark" : "light");
+    };
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, []);
+  return theme;
+}
+var useThemeDetector_default = useThemeDetector;
+var DEFAULT_DURATION = 4e3;
+function useSnackbar(defaultDuration = DEFAULT_DURATION) {
+  const [state, setState] = react.useState({
+    open: false,
+    message: "",
+    severity: "info",
+    autoHideDuration: defaultDuration
+  });
+  const show = react.useCallback(
+    (message, severity = "info", duration) => {
+      setState({
+        open: true,
+        message,
+        severity,
+        autoHideDuration: duration ?? defaultDuration
+      });
+    },
+    [defaultDuration]
+  );
+  const success = react.useCallback(
+    (message, duration) => show(message, "success", duration),
+    [show]
+  );
+  const error = react.useCallback(
+    (message, duration) => show(message, "error", duration),
+    [show]
+  );
+  const warning = react.useCallback(
+    (message, duration) => show(message, "warning", duration),
+    [show]
+  );
+  const info = react.useCallback(
+    (message, duration) => show(message, "info", duration),
+    [show]
+  );
+  const close = react.useCallback(() => {
+    setState((prev) => ({ ...prev, open: false }));
+  }, []);
+  return { state, show, success, error, warning, info, close };
+}
+var useSnackbar_default = useSnackbar;
+function useMediaQuery(query) {
+  const getMatches = (query2) => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(query2).matches;
+  };
+  const [matches, setMatches] = react.useState(getMatches(query));
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia(query);
+    const handleChange = () => setMatches(mediaQuery.matches);
+    handleChange();
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, [query]);
+  return matches;
+}
+var useIsMobile = () => useMediaQuery("(max-width: 767px)");
+var useIsTablet = () => useMediaQuery("(min-width: 768px) and (max-width: 1023px)");
+var useIsDesktop = () => useMediaQuery("(min-width: 1024px)");
+var useIsMobileOrTablet = () => useMediaQuery("(max-width: 1023px)");
+var useMediaQuery_default = useMediaQuery;
+function useOnClickOutside(ref, handler, enabled = true) {
+  react.useEffect(() => {
+    if (!enabled) return;
+    const listener = (event) => {
+      const el = ref?.current;
+      if (!el || el.contains(event.target)) {
+        return;
+      }
+      handler(event);
+    };
+    document.addEventListener("mousedown", listener);
+    document.addEventListener("touchstart", listener);
+    return () => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, [ref, handler, enabled]);
+}
+var useOnClickOutside_default = useOnClickOutside;
+function useWindowSize(debounceMs = 100) {
+  const getSize = () => ({
+    width: typeof window !== "undefined" ? window.innerWidth : 0,
+    height: typeof window !== "undefined" ? window.innerHeight : 0
+  });
+  const [windowSize, setWindowSize] = react.useState(getSize);
+  react.useEffect(() => {
+    if (typeof window === "undefined") return;
+    let timeoutId;
+    const handleResize = () => {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        setWindowSize(getSize());
+      }, debounceMs);
+    };
+    setWindowSize(getSize());
+    window.addEventListener("resize", handleResize);
+    return () => {
+      clearTimeout(timeoutId);
+      window.removeEventListener("resize", handleResize);
+    };
+  }, [debounceMs]);
+  return windowSize;
+}
+var useWindowSize_default = useWindowSize;
+
+exports.ApiUrlBuilder = ApiUrlBuilder;
+exports.ClientLogger = ClientLogger;
+exports.EventEmitter = EventEmitter;
+exports.addDays = addDays;
+exports.appEvents = appEvents;
+exports.camelToKebab = camelToKebab;
+exports.capitalize = capitalize;
+exports.capitalizeWords = capitalizeWords;
+exports.clientLogger = clientLogger;
+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.createSuccessResponse = createSuccessResponse;
+exports.endOfDay = endOfDay;
+exports.formatDate = formatDate;
+exports.formatDateForInput = formatDateForInput;
+exports.formatDateTime = formatDateTime;
+exports.formatDateTimeForInput = formatDateTimeForInput;
+exports.formatRelativeTime = formatRelativeTime;
+exports.getErrorMessage = getErrorMessage;
+exports.getNextPage = getNextPage;
+exports.getPrevPage = getPrevPage;
+exports.getResponseData = getResponseData;
+exports.hasData = hasData;
+exports.hasMorePages = hasMorePages;
+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.kebabToCamel = kebabToCamel;
+exports.parseError = parseError;
+exports.parseFullResponse = parseFullResponse;
+exports.parseResponse = parseResponse;
+exports.readFromClipboard = readFromClipboard;
+exports.slugify = slugify;
+exports.slugifyUnique = slugifyUnique;
+exports.startOfDay = startOfDay;
+exports.truncate = truncate;
+exports.truncateWords = truncateWords;
+exports.unslugify = unslugify;
+exports.useCopyToClipboard = useCopyToClipboard_default;
+exports.useDebounce = useDebounce_default;
+exports.useInterval = useInterval_default;
+exports.useIsDesktop = useIsDesktop;
+exports.useIsMobile = useIsMobile;
+exports.useIsMobileOrTablet = useIsMobileOrTablet;
+exports.useIsTablet = useIsTablet;
+exports.useLocalStorage = useLocalStorage_default;
+exports.useMediaQuery = useMediaQuery_default;
+exports.useOnClickOutside = useOnClickOutside_default;
+exports.usePageTitle = usePageTitle_default;
+exports.useSnackbar = useSnackbar_default;
+exports.useThemeDetector = useThemeDetector_default;
+exports.useWindowSize = useWindowSize_default;
+exports.withAbortSignal = withAbortSignal;
+exports.withFormData = withFormData;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map