@djangocfg/ui-core 2.1.101 → 2.1.103

package/dist/hooks.mjs

@@ -0,0 +1,675 @@
+import moment from 'moment';
+import * as React from 'react';
+import { useState, useEffect, useRef, useCallback, useDebugValue } from 'react';
+import { toast } from 'sonner';
+export { toast } from 'sonner';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var useCountdown = /* @__PURE__ */ __name((targetDate) => {
+  const [countdown, setCountdown] = useState({
+    days: 0,
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    isExpired: false,
+    totalSeconds: 0
+  });
+  useEffect(() => {
+    if (!targetDate) {
+      return;
+    }
+    const target = moment.utc(targetDate);
+    const updateCountdown = /* @__PURE__ */ __name(() => {
+      const now = moment.utc();
+      const diff = target.diff(now, "seconds");
+      if (diff <= 0) {
+        setCountdown({
+          days: 0,
+          hours: 0,
+          minutes: 0,
+          seconds: 0,
+          isExpired: true,
+          totalSeconds: 0
+        });
+        return;
+      }
+      const days = Math.floor(diff / (24 * 60 * 60));
+      const hours = Math.floor(diff % (24 * 60 * 60) / (60 * 60));
+      const minutes = Math.floor(diff % (60 * 60) / 60);
+      const seconds = diff % 60;
+      setCountdown({
+        days,
+        hours,
+        minutes,
+        seconds,
+        isExpired: false,
+        totalSeconds: diff
+      });
+    }, "updateCountdown");
+    updateCountdown();
+    const interval = setInterval(updateCountdown, 1e3);
+    return () => clearInterval(interval);
+  }, [targetDate]);
+  return countdown;
+}, "useCountdown");
+function useDebouncedCallback(callback, delay) {
+  const callbackRef = useRef(callback);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  const debouncedCallback = useCallback(
+    (...args) => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        callbackRef.current(...args);
+      }, delay);
+    },
+    [delay]
+  );
+  debouncedCallback.cancel = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  return debouncedCallback;
+}
+__name(useDebouncedCallback, "useDebouncedCallback");
+function useDebounce(value, delay = 300) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+__name(useDebounce, "useDebounce");
+function useDebugTools(values, prefix = "") {
+  if (values === null || values === void 0) {
+    useDebugValue(values, () => `${prefix}: ${values === null ? "null" : "undefined"}`);
+    return;
+  }
+  if (Array.isArray(values)) {
+    values.forEach((value, index) => {
+      useDebugValue(value, (v) => {
+        const label = prefix ? `${prefix}[${index}]` : `[${index}]`;
+        return `${label}: ${formatValue(v)}`;
+      });
+    });
+    return;
+  }
+  if (typeof values === "object") {
+    for (const [key, value] of Object.entries(values)) {
+      useDebugValue(value, (v) => {
+        const label = prefix ? `${prefix}.${key}` : key;
+        return `${label}: ${formatValue(v)}`;
+      });
+    }
+    return;
+  }
+  useDebugValue(values, (v) => `${prefix}: ${formatValue(v)}`);
+}
+__name(useDebugTools, "useDebugTools");
+function formatValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  try {
+    if (typeof value === "object") {
+      if (Array.isArray(value)) {
+        return `Array(${value.length})`;
+      }
+      return JSON.stringify(value);
+    }
+    return String(value);
+  } catch {
+    return "[Unserializable]";
+  }
+}
+__name(formatValue, "formatValue");
+var _EventBus = class _EventBus {
+  constructor() {
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+  }
+  publish(event) {
+    this.listeners.forEach((listener) => listener({
+      ...event,
+      timestamp: event.timestamp || Date.now()
+    }));
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+};
+__name(_EventBus, "EventBus");
+var EventBus = _EventBus;
+var events = new EventBus();
+function useEventListener(eventType, handler) {
+  const savedHandler = useRef(handler);
+  useEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+  useEffect(() => {
+    const listener = /* @__PURE__ */ __name((event) => {
+      if (event.type === eventType) {
+        savedHandler.current(event.payload);
+      }
+    }, "listener");
+    const unsubscribe = events.subscribe(listener);
+    return () => unsubscribe();
+  }, [eventType]);
+}
+__name(useEventListener, "useEventListener");
+var MOBILE_BREAKPOINT = 1024;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = React.useState(void 0);
+  React.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = /* @__PURE__ */ __name(() => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    }, "onChange");
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    return () => mql.removeEventListener("change", onChange);
+  }, []);
+  return !!isMobile;
+}
+__name(useIsMobile, "useIsMobile");
+function useMediaQuery(query) {
+  const [matches, setMatches] = useState(false);
+  useEffect(() => {
+    const mediaQuery = window.matchMedia(query);
+    setMatches(mediaQuery.matches);
+    const handler = /* @__PURE__ */ __name((event) => {
+      setMatches(event.matches);
+    }, "handler");
+    mediaQuery.addEventListener("change", handler);
+    return () => {
+      mediaQuery.removeEventListener("change", handler);
+    };
+  }, [query]);
+  return matches;
+}
+__name(useMediaQuery, "useMediaQuery");
+function useToast() {
+  return { toast, dismiss: toast.dismiss };
+}
+__name(useToast, "useToast");
+
+// src/hooks/useCopy.ts
+var useCopy = /* @__PURE__ */ __name((options = {}) => {
+  const { toast: toast3 } = useToast();
+  const {
+    successMessage = "Copied to clipboard",
+    errorMessage = "Failed to copy to clipboard"
+  } = options;
+  const copyToClipboard = useCallback(async (text, customSuccessMessage) => {
+    try {
+      await navigator.clipboard.writeText(text);
+      toast3.success(customSuccessMessage || successMessage);
+      return true;
+    } catch (error) {
+      console.error("Failed to copy:", error);
+      toast3.error(errorMessage);
+      return false;
+    }
+  }, [toast3, successMessage, errorMessage]);
+  return { copyToClipboard };
+}, "useCopy");
+var useImageLoader = /* @__PURE__ */ __name((src, callbacks) => {
+  const [state, setState] = useState({
+    isLoading: false,
+    isLoaded: false,
+    hasError: false
+  });
+  const handleLoad = useCallback((event) => {
+    setState({
+      isLoading: false,
+      isLoaded: true,
+      hasError: false
+    });
+    if (callbacks?.onLoad) {
+      callbacks.onLoad(event);
+    }
+  }, [callbacks?.onLoad]);
+  const handleError = useCallback((event) => {
+    setState({
+      isLoading: false,
+      isLoaded: false,
+      hasError: true
+    });
+    if (callbacks?.onError) {
+      callbacks.onError(event);
+    }
+  }, [callbacks?.onError]);
+  useEffect(() => {
+    if (!src) {
+      setState({
+        isLoading: false,
+        isLoaded: false,
+        hasError: true
+      });
+      return;
+    }
+    setState({
+      isLoading: true,
+      isLoaded: false,
+      hasError: false
+    });
+    if (callbacks?.onLoadStart) {
+      callbacks.onLoadStart();
+    }
+    const img = new Image();
+    img.addEventListener("load", handleLoad);
+    img.addEventListener("error", handleError);
+    img.src = src;
+    return () => {
+      img.removeEventListener("load", handleLoad);
+      img.removeEventListener("error", handleError);
+    };
+  }, [src, handleLoad, handleError, callbacks?.onLoadStart]);
+  return state;
+}, "useImageLoader");
+var useResolvedTheme = /* @__PURE__ */ __name(() => {
+  const [theme, setTheme] = useState("light");
+  useEffect(() => {
+    const checkTheme = /* @__PURE__ */ __name(() => {
+      if (document.documentElement.classList.contains("dark")) {
+        return "dark";
+      }
+      if (window.matchMedia("(prefers-color-scheme: dark)").matches) {
+        return "dark";
+      }
+      return "light";
+    }, "checkTheme");
+    setTheme(checkTheme());
+    const observer = new MutationObserver(() => {
+      setTheme(checkTheme());
+    });
+    observer.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["class"]
+    });
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleMediaChange = /* @__PURE__ */ __name(() => {
+      setTheme(checkTheme());
+    }, "handleMediaChange");
+    mediaQuery.addEventListener("change", handleMediaChange);
+    return () => {
+      observer.disconnect();
+      mediaQuery.removeEventListener("change", handleMediaChange);
+    };
+  }, []);
+  return theme;
+}, "useResolvedTheme");
+function isWrappedFormat(data) {
+  return data !== null && typeof data === "object" && "_meta" in data && "_value" in data && typeof data._meta === "object" && typeof data._meta.createdAt === "number";
+}
+__name(isWrappedFormat, "isWrappedFormat");
+function isExpired(wrapped) {
+  if (!wrapped._meta.ttl) return false;
+  const age = Date.now() - wrapped._meta.createdAt;
+  return age > wrapped._meta.ttl;
+}
+__name(isExpired, "isExpired");
+function useLocalStorage(key, initialValue, options) {
+  const ttl = options?.ttl;
+  const [storedValue, setStoredValue] = useState(initialValue);
+  const [isHydrated, setIsHydrated] = useState(false);
+  const isInitialized = useRef(false);
+  useEffect(() => {
+    if (isInitialized.current) return;
+    isInitialized.current = true;
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item !== null) {
+        try {
+          const parsed = JSON.parse(item);
+          if (isWrappedFormat(parsed)) {
+            if (isExpired(parsed)) {
+              window.localStorage.removeItem(key);
+            } else {
+              setStoredValue(parsed._value);
+            }
+          } else {
+            setStoredValue(parsed);
+          }
+        } catch {
+          setStoredValue(item);
+        }
+      }
+    } catch (error) {
+      console.error(`Error reading localStorage key "${key}":`, error);
+    }
+    setIsHydrated(true);
+  }, [key]);
+  const checkDataSize = /* @__PURE__ */ __name((data) => {
+    try {
+      const jsonString = JSON.stringify(data);
+      const sizeInBytes = new Blob([jsonString]).size;
+      const sizeInKB = sizeInBytes / 1024;
+      if (sizeInKB > 1024) {
+        console.warn(`Data size (${sizeInKB.toFixed(2)}KB) exceeds 1MB limit for key "${key}"`);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error(`Error checking data size for key "${key}":`, error);
+      return false;
+    }
+  }, "checkDataSize");
+  const clearOldData = /* @__PURE__ */ __name(() => {
+    try {
+      const keys = Object.keys(localStorage).filter((key2) => key2 && typeof key2 === "string");
+      if (keys.length > 50) {
+        const itemsToRemove = Math.ceil(keys.length * 0.2);
+        for (let i = 0; i < itemsToRemove; i++) {
+          try {
+            const key2 = keys[i];
+            if (key2) {
+              localStorage.removeItem(key2);
+            }
+          } catch {
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error clearing old localStorage data:", error);
+    }
+  }, "clearOldData");
+  const forceClearAll = /* @__PURE__ */ __name(() => {
+    try {
+      const keys = Object.keys(localStorage);
+      for (const key2 of keys) {
+        try {
+          localStorage.removeItem(key2);
+        } catch {
+        }
+      }
+    } catch (error) {
+      console.error("Error force clearing localStorage:", error);
+    }
+  }, "forceClearAll");
+  const prepareForStorage = /* @__PURE__ */ __name((value) => {
+    if (ttl) {
+      const wrapped = {
+        _meta: {
+          createdAt: Date.now(),
+          ttl
+        },
+        _value: value
+      };
+      return JSON.stringify(wrapped);
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }, "prepareForStorage");
+  const setValue = /* @__PURE__ */ __name((value) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      if (!checkDataSize(valueToStore)) {
+        console.warn(`Data size too large for key "${key}", removing key`);
+        try {
+          window.localStorage.removeItem(key);
+        } catch {
+        }
+        setStoredValue(valueToStore);
+        return;
+      }
+      setStoredValue(valueToStore);
+      if (typeof window !== "undefined") {
+        const dataToStore = prepareForStorage(valueToStore);
+        try {
+          window.localStorage.setItem(key, dataToStore);
+        } catch (storageError) {
+          if (storageError.name === "QuotaExceededError" || storageError.code === 22 || storageError.message?.includes("quota")) {
+            console.warn("localStorage quota exceeded, clearing old data...");
+            clearOldData();
+            try {
+              window.localStorage.setItem(key, dataToStore);
+            } catch (retryError) {
+              console.error(`Failed to set localStorage key "${key}" after clearing old data:`, retryError);
+              try {
+                forceClearAll();
+                window.localStorage.setItem(key, dataToStore);
+              } catch (finalError) {
+                console.error(`Failed to set localStorage key "${key}" after force clearing:`, finalError);
+                setStoredValue(valueToStore);
+              }
+            }
+          } else {
+            throw storageError;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error setting localStorage key "${key}":`, error);
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+    }
+  }, "setValue");
+  const removeValue = /* @__PURE__ */ __name(() => {
+    try {
+      setStoredValue(initialValue);
+      if (typeof window !== "undefined") {
+        try {
+          window.localStorage.removeItem(key);
+        } catch (removeError) {
+          if (removeError.name === "QuotaExceededError" || removeError.code === 22 || removeError.message?.includes("quota")) {
+            console.warn("localStorage quota exceeded during removal, clearing old data...");
+            clearOldData();
+            try {
+              window.localStorage.removeItem(key);
+            } catch (retryError) {
+              console.error(`Failed to remove localStorage key "${key}" after clearing:`, retryError);
+              forceClearAll();
+            }
+          } else {
+            throw removeError;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error removing localStorage key "${key}":`, error);
+    }
+  }, "removeValue");
+  return [storedValue, setValue, removeValue];
+}
+__name(useLocalStorage, "useLocalStorage");
+function isWrappedFormat2(data) {
+  return data !== null && typeof data === "object" && "_meta" in data && "_value" in data && typeof data._meta === "object" && typeof data._meta.createdAt === "number";
+}
+__name(isWrappedFormat2, "isWrappedFormat");
+function isExpired2(wrapped) {
+  if (!wrapped._meta.ttl) return false;
+  const age = Date.now() - wrapped._meta.createdAt;
+  return age > wrapped._meta.ttl;
+}
+__name(isExpired2, "isExpired");
+function useSessionStorage(key, initialValue, options) {
+  const ttl = options?.ttl;
+  const [storedValue, setStoredValue] = useState(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      if (item === null) return initialValue;
+      try {
+        const parsed = JSON.parse(item);
+        if (isWrappedFormat2(parsed)) {
+          if (isExpired2(parsed)) {
+            window.sessionStorage.removeItem(key);
+            return initialValue;
+          }
+          return parsed._value;
+        }
+        return parsed;
+      } catch {
+        return item;
+      }
+    } catch (error) {
+      console.error(`Error reading sessionStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+  const checkDataSize = /* @__PURE__ */ __name((data) => {
+    try {
+      const jsonString = JSON.stringify(data);
+      const sizeInBytes = new Blob([jsonString]).size;
+      const sizeInKB = sizeInBytes / 1024;
+      if (sizeInKB > 1024) {
+        console.warn(`Data size (${sizeInKB.toFixed(2)}KB) exceeds 1MB limit for key "${key}"`);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error(`Error checking data size for key "${key}":`, error);
+      return false;
+    }
+  }, "checkDataSize");
+  const clearOldData = /* @__PURE__ */ __name(() => {
+    try {
+      const keys = Object.keys(sessionStorage).filter((k) => k && typeof k === "string");
+      if (keys.length > 50) {
+        const itemsToRemove = Math.ceil(keys.length * 0.2);
+        for (let i = 0; i < itemsToRemove; i++) {
+          try {
+            const k = keys[i];
+            if (k) {
+              sessionStorage.removeItem(k);
+            }
+          } catch {
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error clearing old sessionStorage data:", error);
+    }
+  }, "clearOldData");
+  const forceClearAll = /* @__PURE__ */ __name(() => {
+    try {
+      const keys = Object.keys(sessionStorage);
+      for (const k of keys) {
+        try {
+          sessionStorage.removeItem(k);
+        } catch {
+        }
+      }
+    } catch (error) {
+      console.error("Error force clearing sessionStorage:", error);
+    }
+  }, "forceClearAll");
+  const prepareForStorage = /* @__PURE__ */ __name((value) => {
+    if (ttl) {
+      const wrapped = {
+        _meta: {
+          createdAt: Date.now(),
+          ttl
+        },
+        _value: value
+      };
+      return JSON.stringify(wrapped);
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }, "prepareForStorage");
+  const setValue = /* @__PURE__ */ __name((value) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      if (!checkDataSize(valueToStore)) {
+        console.warn(`Data size too large for key "${key}", removing key`);
+        try {
+          window.sessionStorage.removeItem(key);
+        } catch {
+        }
+        setStoredValue(valueToStore);
+        return;
+      }
+      setStoredValue(valueToStore);
+      if (typeof window !== "undefined") {
+        const dataToStore = prepareForStorage(valueToStore);
+        try {
+          window.sessionStorage.setItem(key, dataToStore);
+        } catch (storageError) {
+          if (storageError.name === "QuotaExceededError" || storageError.code === 22 || storageError.message?.includes("quota")) {
+            console.warn("sessionStorage quota exceeded, clearing old data...");
+            clearOldData();
+            try {
+              window.sessionStorage.setItem(key, dataToStore);
+            } catch (retryError) {
+              console.error(`Failed to set sessionStorage key "${key}" after clearing old data:`, retryError);
+              try {
+                forceClearAll();
+                window.sessionStorage.setItem(key, dataToStore);
+              } catch (finalError) {
+                console.error(`Failed to set sessionStorage key "${key}" after force clearing:`, finalError);
+                setStoredValue(valueToStore);
+              }
+            }
+          } else {
+            throw storageError;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error setting sessionStorage key "${key}":`, error);
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+    }
+  }, "setValue");
+  const removeValue = /* @__PURE__ */ __name(() => {
+    try {
+      setStoredValue(initialValue);
+      if (typeof window !== "undefined") {
+        try {
+          window.sessionStorage.removeItem(key);
+        } catch (removeError) {
+          if (removeError.name === "QuotaExceededError" || removeError.code === 22 || removeError.message?.includes("quota")) {
+            console.warn("sessionStorage quota exceeded during removal, clearing old data...");
+            clearOldData();
+            try {
+              window.sessionStorage.removeItem(key);
+            } catch (retryError) {
+              console.error(`Failed to remove sessionStorage key "${key}" after clearing:`, retryError);
+              forceClearAll();
+            }
+          } else {
+            throw removeError;
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error removing sessionStorage key "${key}":`, error);
+    }
+  }, "removeValue");
+  return [storedValue, setValue, removeValue];
+}
+__name(useSessionStorage, "useSessionStorage");
+
+export { events, useCopy, useCountdown, useDebounce, useDebouncedCallback, useDebugTools, useEventListener, useImageLoader, useIsMobile, useLocalStorage, useMediaQuery, useResolvedTheme, useSessionStorage, useToast };
+//# sourceMappingURL=hooks.mjs.map
+//# sourceMappingURL=hooks.mjs.map