@pelatform/ui 1.5.0

package/dist/chunk-3N75YA6Q.cjs

@@ -0,0 +1,60 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/hooks/use-copy-to-clipboard.ts
+var _react = require('react'); var React = _interopRequireWildcard(_react); var React2 = _interopRequireWildcard(_react);
+function useCopyToClipboard({ timeout = 2e3, onCopy } = {}) {
+  const [copied, setCopied] = React.useState(false);
+  const copy = React.useCallback(
+    (value) => {
+      if (typeof window === "undefined" || !_optionalChain([navigator, 'access', _ => _.clipboard, 'optionalAccess', _2 => _2.writeText])) {
+        console.warn("Clipboard API not supported in this environment");
+        return;
+      }
+      if (!value) {
+        console.warn("Cannot copy empty value to clipboard");
+        return;
+      }
+      navigator.clipboard.writeText(value).then(
+        () => {
+          setCopied(true);
+          if (onCopy) {
+            onCopy();
+          }
+          setTimeout(() => {
+            setCopied(false);
+          }, timeout);
+        },
+        (error) => {
+          console.error("Failed to copy text to clipboard:", error);
+        }
+      );
+    },
+    [timeout, onCopy]
+  );
+  return {
+    /** Whether text was recently copied (true for timeout duration) */
+    copied,
+    /** Function to copy text to clipboard */
+    copy
+  };
+}
+
+// src/hooks/use-mobile.ts
+
+var DEFAULT_MOBILE_BREAKPOINT = 1024;
+function useIsMobile(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
+  const [isMobile, setIsMobile] = React2.useState(void 0);
+  React2.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${breakpoint - 1}px)`);
+    const onChange = () => {
+      setIsMobile(window.innerWidth < breakpoint);
+    };
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < breakpoint);
+    return () => mql.removeEventListener("change", onChange);
+  }, [breakpoint]);
+  return !!isMobile;
+}
+
+
+
+
+exports.useCopyToClipboard = useCopyToClipboard; exports.useIsMobile = useIsMobile;

package/dist/chunk-CD2BCCQU.js

@@ -0,0 +1,180 @@
+import {
+  META_THEME_COLORS,
+  THEME_MODES
+} from "./chunk-HW52LCWN.js";
+
+// src/hooks/use-meta-color.ts
+import * as React from "react";
+import { useTheme } from "next-themes";
+function useMetaColor(defaultColors) {
+  const { resolvedTheme } = useTheme();
+  const isSystemDarkMode = React.useCallback(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia("(prefers-color-scheme: dark)").matches;
+  }, []);
+  const getEffectiveTheme = React.useCallback(
+    (theme) => {
+      if (theme === THEME_MODES.SYSTEM) {
+        return isSystemDarkMode() ? THEME_MODES.DARK : THEME_MODES.LIGHT;
+      }
+      return theme;
+    },
+    [isSystemDarkMode]
+  );
+  const metaColor = React.useMemo(() => {
+    const colorsToUse = defaultColors ?? META_THEME_COLORS;
+    const effectiveTheme = getEffectiveTheme(resolvedTheme);
+    if (effectiveTheme === THEME_MODES.DARK) {
+      return colorsToUse[THEME_MODES.DARK];
+    } else if (effectiveTheme === THEME_MODES.LIGHT) {
+      return colorsToUse[THEME_MODES.LIGHT];
+    }
+    return colorsToUse[THEME_MODES.LIGHT];
+  }, [resolvedTheme, defaultColors, getEffectiveTheme]);
+  const setMetaColor = React.useCallback((color) => {
+    const metaTag = document.querySelector('meta[name="theme-color"]');
+    if (metaTag) {
+      metaTag.setAttribute("content", color);
+    } else {
+      const newMetaTag = document.createElement("meta");
+      newMetaTag.name = "theme-color";
+      newMetaTag.content = color;
+      document.head.appendChild(newMetaTag);
+    }
+  }, []);
+  return {
+    /** Current meta theme color based on resolved theme */
+    metaColor,
+    /** Function to manually set meta theme color */
+    setMetaColor
+  };
+}
+
+// src/hooks/use-recaptcha-v2.ts
+import { useCallback as useCallback2, useEffect, useRef } from "react";
+var RECAPTCHA_SCRIPT_ID = "recaptcha-v2-script";
+var scriptLoadPromise = null;
+function loadRecaptchaScript() {
+  if (scriptLoadPromise) return scriptLoadPromise;
+  scriptLoadPromise = new Promise((resolve) => {
+    if (document.getElementById(RECAPTCHA_SCRIPT_ID) && window.grecaptcha) {
+      resolve();
+      return;
+    }
+    window.onRecaptchaLoaded = () => {
+      resolve();
+    };
+    const script = document.createElement("script");
+    script.id = RECAPTCHA_SCRIPT_ID;
+    script.src = `https://www.google.com/recaptcha/api.js?onload=onRecaptchaLoaded&render=explicit`;
+    script.async = true;
+    script.defer = true;
+    script.onerror = () => {
+      console.error("Failed to load reCAPTCHA script");
+      scriptLoadPromise = null;
+    };
+    document.head.appendChild(script);
+  });
+  return scriptLoadPromise;
+}
+function useRecaptchaV2(siteKey) {
+  const widgetId = useRef(null);
+  const containerRef = useRef(null);
+  const isRendered = useRef(false);
+  const isInitializing = useRef(false);
+  const initializeRecaptcha = useCallback2(async () => {
+    if (isInitializing.current) return;
+    if (!containerRef.current || !siteKey) return;
+    isInitializing.current = true;
+    try {
+      if (widgetId.current !== null) {
+        const grecaptcha2 = window.grecaptcha;
+        if (grecaptcha2) {
+          try {
+            grecaptcha2.reset(widgetId.current);
+          } catch (error) {
+            console.error("Error resetting reCAPTCHA:", error);
+          }
+        }
+        widgetId.current = null;
+        isRendered.current = false;
+      }
+      await loadRecaptchaScript();
+      const grecaptcha = window.grecaptcha;
+      if (!grecaptcha) {
+        throw new Error("reCAPTCHA failed to load");
+      }
+      await new Promise((resolve) => {
+        grecaptcha.ready(() => resolve());
+      });
+      if (containerRef.current && !isRendered.current) {
+        widgetId.current = grecaptcha.render(containerRef.current, {
+          sitekey: siteKey,
+          size: "normal",
+          // Can be 'normal', 'compact', or 'invisible'
+          theme: "light"
+          // Can be 'light' or 'dark'
+        });
+        isRendered.current = true;
+      }
+    } catch (error) {
+      console.error("Error initializing reCAPTCHA:", error);
+    } finally {
+      isInitializing.current = false;
+    }
+  }, [siteKey]);
+  useEffect(() => {
+    if (containerRef.current) {
+      initializeRecaptcha();
+    }
+    return () => {
+      if (widgetId.current !== null) {
+        const grecaptcha = window.grecaptcha;
+        if (grecaptcha) {
+          try {
+            grecaptcha.reset(widgetId.current);
+          } catch (error) {
+            console.error("Error resetting reCAPTCHA on cleanup:", error);
+          }
+        }
+        widgetId.current = null;
+        isRendered.current = false;
+      }
+    };
+  }, [initializeRecaptcha]);
+  const getToken = () => {
+    const grecaptcha = window.grecaptcha;
+    if (!grecaptcha || widgetId.current === null) {
+      throw new Error("reCAPTCHA not initialized");
+    }
+    const token = grecaptcha.getResponse(widgetId.current);
+    if (!token) {
+      throw new Error("reCAPTCHA not completed");
+    }
+    return token;
+  };
+  const resetCaptcha = () => {
+    const grecaptcha = window.grecaptcha;
+    if (!grecaptcha || widgetId.current === null) return;
+    try {
+      grecaptcha.reset(widgetId.current);
+    } catch (error) {
+      console.error("Error resetting reCAPTCHA:", error);
+    }
+  };
+  return {
+    /** Ref to attach to the container div where reCAPTCHA will be rendered */
+    containerRef,
+    /** Function to get the reCAPTCHA response token */
+    getToken,
+    /** Function to reset the reCAPTCHA widget */
+    resetCaptcha,
+    /** Function to manually initialize reCAPTCHA (usually not needed) */
+    initializeRecaptcha
+  };
+}
+
+export {
+  useMetaColor,
+  useRecaptchaV2
+};

package/dist/chunk-CJXIPSTG.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/lib/utils.ts
+var _clsx = require('clsx');
+var _tailwindmerge = require('tailwind-merge');
+function cn(...inputs) {
+  return _tailwindmerge.twMerge.call(void 0, _clsx.clsx.call(void 0, inputs));
+}
+
+
+
+exports.cn = cn;