strapi-plugin-magic-link-v5 5.5.8 → 6.0.0

package/dist/admin/LicenseGuard-BgLA9go3.mjs

@@ -0,0 +1,495 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import { Typography } from "@strapi/design-system";
+import * as strapiAdmin from "@strapi/strapi/admin";
+import { Page, useNotification } from "@strapi/strapi/admin";
+import styled, { css } from "styled-components";
+import { g as getTranslation, p as pluginPermissions } from "./index-k240ls6p.mjs";
+import { useCallback, useMemo, useContext, useState, createContext } from "react";
+import { useIntl, IntlContext, IntlProvider } from "react-intl";
+import enTranslations from "./en-HqDOFBCc.mjs";
+import deTranslations from "./de-B1FNErPH.mjs";
+import frTranslations from "./fr-BseH1wrr.mjs";
+import esTranslations from "./es-jb94jqPR.mjs";
+import ptTranslations from "./pt-DhlSCJn2.mjs";
+const useMagicLinkIntl = () => {
+  const intl = useIntl();
+  const t = useCallback(
+    (key, defaultMessage, values) => intl.formatMessage({ id: getTranslation(key), defaultMessage }, values),
+    [intl]
+  );
+  return { t, formatMessage: intl.formatMessage, locale: intl.locale };
+};
+const PluginPageTitle = ({ children }) => {
+  const { t } = useMagicLinkIntl();
+  return /* @__PURE__ */ jsx(Page.Title, { children: t("common.pageTitle", "{page} | Magic Link", { page: children }) });
+};
+styled(Typography).attrs((props) => ({
+  tag: props.tag ?? "h2",
+  variant: props.variant ?? "delta",
+  textColor: props.textColor ?? "neutral800"
+}))``;
+const SubsectionHeading = styled(Typography).attrs((props) => ({
+  tag: props.tag ?? "h3",
+  variant: props.variant ?? "omega",
+  fontWeight: props.fontWeight ?? "bold",
+  textColor: props.textColor ?? "neutral800"
+}))``;
+const PLUGIN_CAPABILITIES = [...pluginPermissions.read, ...pluginPermissions.manage];
+const SETTINGS_CAPABILITIES = [
+  ...pluginPermissions.settingsRead,
+  ...pluginPermissions.settingsUpdate
+];
+const grantedActions = (permissions) => new Set(
+  (Array.isArray(permissions) ? permissions : []).filter(
+    (permission) => typeof permission?.action === "string" && (!Array.isArray(permission.conditions) || permission.conditions.length === 0)
+  ).map((permission) => permission.action)
+);
+const resolveCapabilities = (plugin = {}, settings = {}, auth = {}) => {
+  const isLoading = Boolean(plugin.isLoading || settings.isLoading || auth.isLoading);
+  const error = plugin.error ?? settings.error;
+  const settled = !isLoading && !error;
+  const granted = grantedActions(auth.permissions);
+  const allowed = (result, key, uid) => settled && (result.allowedActions?.[key] === true || granted.has(uid));
+  const canRead = allowed(plugin, "canRead", "plugin::magic-link.read");
+  const canManage = allowed(plugin, "canManage", "plugin::magic-link.manage");
+  const canReadSettings = allowed(settings, "canRead", "plugin::magic-link.settings.read");
+  const canUpdateSettings = allowed(settings, "canUpdate", "plugin::magic-link.settings.update");
+  return {
+    canRead,
+    canManage,
+    canReadSettings,
+    canUpdateSettings,
+    isReadOnly: canRead && !canManage,
+    isSettingsReadOnly: canReadSettings && !canUpdateSettings,
+    isLoading,
+    error
+  };
+};
+const useAdminPermissions = typeof strapiAdmin.useAuth === "function" ? () => {
+  const permissions = strapiAdmin.useAuth("MagicLinkRBAC", (state) => state.permissions);
+  const isLoading = strapiAdmin.useAuth("MagicLinkRBAC", (state) => state.isLoading);
+  return { permissions, isLoading };
+} : () => EMPTY_AUTH;
+const EMPTY_AUTH = Object.freeze({});
+const useMagicLinkRBAC = () => {
+  const plugin = strapiAdmin.useRBAC(PLUGIN_CAPABILITIES) ?? {};
+  const settings = strapiAdmin.useRBAC(SETTINGS_CAPABILITIES) ?? {};
+  const auth = useAdminPermissions();
+  return { ...resolveCapabilities(plugin, settings, auth), permissions: pluginPermissions };
+};
+const LIGHT_FALLBACK_COLORS = Object.freeze({
+  alternative100: "#f6ecfc",
+  alternative200: "#e0c1f4",
+  alternative500: "#ac73e6",
+  alternative600: "#9736e8",
+  alternative700: "#8312d1",
+  neutral0: "#ffffff",
+  neutral100: "#f6f6f9",
+  neutral150: "#eaeaef",
+  neutral200: "#dcdce4",
+  neutral300: "#c0c0cf",
+  neutral400: "#a5a5ba",
+  neutral500: "#8e8ea9",
+  neutral600: "#666687",
+  neutral700: "#4a4a6a",
+  neutral800: "#32324d",
+  neutral900: "#212134",
+  neutral1000: "#181826",
+  primary100: "#f0f0ff",
+  primary200: "#d9d8ff",
+  primary500: "#7b79ff",
+  primary600: "#4945ff",
+  primary700: "#271fe0",
+  secondary100: "#eaf5ff",
+  secondary200: "#b8e1ff",
+  secondary500: "#66b7f1",
+  secondary600: "#0c75af",
+  secondary700: "#006096",
+  success100: "#eafbe7",
+  success200: "#c6f0c2",
+  success500: "#5cb176",
+  success600: "#328048",
+  success700: "#2f6846",
+  warning100: "#fdf4dc",
+  warning200: "#fae7b9",
+  warning500: "#f29d41",
+  warning600: "#d9822f",
+  warning700: "#be5d01",
+  danger100: "#fcecea",
+  danger200: "#f5c0b8",
+  danger500: "#ee5e52",
+  danger600: "#d02b20",
+  danger700: "#b72b1a"
+});
+const FONT_SIZE_FALLBACK = Object.freeze([
+  "1.1rem",
+  // 0 -> 11px (sigma, uppercase table headers only)
+  "1.2rem",
+  // 1 -> 12px (pi, the minimum for helper text)
+  "1.4rem",
+  // 2 -> 14px (omega, body)
+  "1.6rem",
+  // 3 -> 16px
+  "1.8rem",
+  // 4 -> 18px
+  "2rem",
+  //   5 -> 20px
+  "2.8rem",
+  // 6 -> 28px
+  "3.2rem"
+  // 7 -> 32px
+]);
+const SPACE_FALLBACK = Object.freeze([
+  "0px",
+  "4px",
+  "8px",
+  "12px",
+  "16px",
+  "20px",
+  "24px",
+  "32px",
+  "40px",
+  "48px",
+  "56px",
+  "64px"
+]);
+const color = (token) => (props) => props?.theme?.colors?.[token] ?? LIGHT_FALLBACK_COLORS[token];
+const fontSize = (step) => (props) => props?.theme?.fontSizes?.[step] ?? FONT_SIZE_FALLBACK[step];
+const space = (step) => (props) => props?.theme?.spaces?.[step] ?? SPACE_FALLBACK[step];
+const isDarkTheme = (themeObject) => themeObject?.colorScheme === "dark";
+const byScheme = (light, dark) => (props) => isDarkTheme(props?.theme) ? dark : light;
+const brand = Object.freeze({
+  primary: "#0369A1",
+  primaryHover: "#075985",
+  secondary: "#9333EA",
+  secondaryHover: "#7E22CE",
+  success: "#15803D",
+  successHover: "#166534",
+  warning: "#B45309",
+  warningHover: "#92400E",
+  danger: "#DC2626",
+  dangerHover: "#B91C1C",
+  gradient: "linear-gradient(135deg, #0369A1 0%, #9333EA 100%)",
+  gradientHover: "linear-gradient(135deg, #075985 0%, #7E22CE 100%)",
+  successGradient: "linear-gradient(135deg, #15803D 0%, #166534 100%)",
+  violetGradient: "linear-gradient(135deg, #667EEA 0%, #764BA2 100%)",
+  violetHeroGradient: "linear-gradient(rgba(15, 23, 42, 0.25), rgba(15, 23, 42, 0.25)), linear-gradient(135deg, #667EEA 0%, #764BA2 100%)",
+  onFill: "#FFFFFF"
+});
+const ACCENT_VALUES = Object.freeze({
+  primary: ["#0369A1", "#7DD3FC"],
+  secondary: ["#7E22CE", "#D8B4FE"],
+  success: ["#15803D", "#86EFAC"],
+  warning: ["#B45309", "#FCD34D"],
+  danger: ["#B91C1C", "#FCA5A5"]
+});
+const accent = Object.freeze(
+  Object.fromEntries(
+    Object.entries(ACCENT_VALUES).map(([name, [light, dark]]) => [name, byScheme(light, dark)])
+  )
+);
+const TINT_VALUES = Object.freeze({
+  primary: { bg: ["#F0F9FF", "rgba(14, 165, 233, 0.12)"], border: ["#BAE6FD", "#0C4A6E"] },
+  success: { bg: ["#F0FDF4", "rgba(34, 197, 94, 0.12)"], border: ["#BBF7D0", "#14532D"] },
+  warning: { bg: ["#FFFBEB", "rgba(245, 158, 11, 0.12)"], border: ["#FDE68A", "#78350F"] },
+  danger: { bg: ["#FEF2F2", "rgba(239, 68, 68, 0.12)"], border: ["#FECACA", "#7F1D1D"] }
+});
+const tint = Object.freeze(
+  Object.fromEntries(
+    Object.entries(TINT_VALUES).map(([name, values]) => [
+      name,
+      Object.freeze({
+        bg: byScheme(...values.bg),
+        border: byScheme(...values.border),
+        fg: accent[name]
+      })
+    ])
+  )
+);
+const breakpoints = Object.freeze({
+  mobile: "768px",
+  tablet: "1024px",
+  statsThreeTwo: "960px",
+  tableCompact: "1199px",
+  compact: "520px"
+});
+const theme = Object.freeze({
+  spacing: Object.freeze({
+    xs: "4px",
+    sm: "8px",
+    smd: "12px",
+    md: "16px",
+    lg: "24px",
+    xl: "32px",
+    "2xl": "48px"
+  }),
+  borderRadius: Object.freeze({ sm: "4px", md: "8px", lg: "12px", xl: "16px", full: "9999px" }),
+  shadows: Object.freeze({
+    sm: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)",
+    md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+    lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+    xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)"
+  }),
+  transitions: Object.freeze({
+    fast: "150ms cubic-bezier(0.4, 0, 0.2, 1)",
+    normal: "300ms cubic-bezier(0.4, 0, 0.2, 1)"
+  }),
+  /**
+   * DS 2.2.4 button heights at >= 768px (theme.sizes.button). Below 768px DS
+   * grows them to 40/44/48px. Use one size per row and match custom controls
+   * to it.
+   */
+  controlHeight: Object.freeze({ S: "32px", M: "36px", L: "40px" })
+});
+const reducedMotion = css`
+  @media (prefers-reduced-motion: reduce) {
+    animation: none !important;
+    transition: none !important;
+
+    &::before,
+    &::after {
+      animation: none !important;
+      transition: none !important;
+    }
+
+    &:hover,
+    &:active,
+    &:focus-visible {
+      transform: none !important;
+    }
+  }
+`;
+const motionSafe = (block) => css`
+  @media (prefers-reduced-motion: no-preference) {
+    ${block}
+  }
+`;
+const EMPTY_VALUE = "-";
+const DATE_TIME_FORMAT = Object.freeze({ dateStyle: "medium", timeStyle: "short" });
+const DATE_FORMAT = Object.freeze({ dateStyle: "medium" });
+const toValidDate = (value) => {
+  if (value === null || value === void 0 || value === "") return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+};
+const createFormatters = (intl) => {
+  const formatDateTime = (value, options = DATE_TIME_FORMAT, fallback = EMPTY_VALUE) => {
+    const date = toValidDate(value);
+    return date ? intl.formatDate(date, options) : fallback;
+  };
+  const formatDateOnly = (value, options = DATE_FORMAT, fallback = EMPTY_VALUE) => {
+    const date = toValidDate(value);
+    return date ? intl.formatDate(date, options) : fallback;
+  };
+  const formatCount = (value, options, fallback = EMPTY_VALUE) => {
+    const number = typeof value === "number" ? value : Number(value);
+    return value === null || value === void 0 || value === "" || !Number.isFinite(number) ? fallback : intl.formatNumber(number, options);
+  };
+  const formatPercent = (value, fractionDigits = 1, fallback = EMPTY_VALUE) => {
+    if (value === null || value === void 0 || value === "") return fallback;
+    const number = Number(value);
+    return Number.isFinite(number) ? intl.formatNumber(number / 100, { style: "percent", maximumFractionDigits: fractionDigits }) : fallback;
+  };
+  const formatRelative = (value, now = /* @__PURE__ */ new Date(), fallback = EMPTY_VALUE) => {
+    const date = toValidDate(value);
+    if (!date || typeof intl.formatRelativeTime !== "function") {
+      return date ? formatDateTime(date) : fallback;
+    }
+    const seconds = Math.round((date.getTime() - now.getTime()) / 1e3);
+    const abs = Math.abs(seconds);
+    if (abs < 60) return intl.formatRelativeTime(seconds, "second", { numeric: "auto" });
+    if (abs < 3600)
+      return intl.formatRelativeTime(Math.round(seconds / 60), "minute", { numeric: "auto" });
+    if (abs < 86400)
+      return intl.formatRelativeTime(Math.round(seconds / 3600), "hour", { numeric: "auto" });
+    if (abs < 86400 * 30)
+      return intl.formatRelativeTime(Math.round(seconds / 86400), "day", { numeric: "auto" });
+    return formatDateOnly(date);
+  };
+  return {
+    formatDateTime,
+    formatDate: formatDateOnly,
+    formatNumber: formatCount,
+    formatPercent,
+    formatRelative
+  };
+};
+const useFormatters = () => {
+  const intl = useIntl();
+  return useMemo(() => createFormatters(intl), [intl]);
+};
+const copyToClipboard = async (text, env = {}) => {
+  if (typeof text !== "string" || text.length === 0) return false;
+  const win = env.window ?? (typeof window === "undefined" ? void 0 : window);
+  const nav = env.navigator ?? win?.navigator ?? (typeof navigator === "undefined" ? void 0 : navigator);
+  const doc = env.document ?? win?.document ?? (typeof document === "undefined" ? void 0 : document);
+  const secure = win?.isSecureContext !== false;
+  if (secure && typeof nav?.clipboard?.writeText === "function") {
+    try {
+      await nav.clipboard.writeText(text);
+      return true;
+    } catch {
+    }
+  }
+  return legacyCopy(text, doc);
+};
+const legacyCopy = (text, doc) => {
+  if (!doc?.body || typeof doc.createElement !== "function" || typeof doc.execCommand !== "function") {
+    return false;
+  }
+  const textarea = doc.createElement("textarea");
+  textarea.value = text;
+  textarea.setAttribute("readonly", "");
+  textarea.setAttribute("aria-hidden", "true");
+  textarea.style.position = "fixed";
+  textarea.style.top = "0";
+  textarea.style.left = "-9999px";
+  textarea.style.opacity = "0";
+  const activeElement = doc.activeElement;
+  doc.body.appendChild(textarea);
+  try {
+    textarea.select();
+    return doc.execCommand("copy") === true;
+  } catch {
+    return false;
+  } finally {
+    doc.body.removeChild(textarea);
+    if (activeElement && typeof activeElement.focus === "function") {
+      try {
+        activeElement.focus();
+      } catch {
+      }
+    }
+  }
+};
+const useCopyToClipboard = () => {
+  const { toggleNotification } = useNotification();
+  const { t } = useMagicLinkIntl();
+  return useCallback(
+    async (text, messages = {}) => {
+      const copied = await copyToClipboard(text);
+      toggleNotification({
+        type: copied ? "success" : "warning",
+        message: copied ? messages.success ?? t("common.clipboard.copied", "Copied to clipboard") : messages.failure ?? t("common.clipboard.failed", "Copy failed. Select the text and copy it manually.")
+      });
+      return copied;
+    },
+    [t, toggleNotification]
+  );
+};
+const STORAGE_KEY = "magic-link-language";
+const SUPPORTED_LANGUAGES = Object.freeze(["en", "de", "fr", "es", "pt"]);
+const translations = Object.freeze({
+  en: enTranslations,
+  de: deTranslations,
+  fr: frTranslations,
+  es: esTranslations,
+  pt: ptTranslations
+});
+const toSupportedLanguage = (locale) => {
+  if (typeof locale !== "string" || !locale) return null;
+  const base = locale.toLowerCase().split(/[-_]/)[0];
+  return SUPPORTED_LANGUAGES.includes(base) ? base : null;
+};
+const readStoredLanguage = (storage = safeLocalStorage()) => {
+  try {
+    return toSupportedLanguage(storage?.getItem(STORAGE_KEY));
+  } catch {
+    return null;
+  }
+};
+const writeStoredLanguage = (language, storage = safeLocalStorage()) => {
+  try {
+    if (language) storage?.setItem(STORAGE_KEY, language);
+    else storage?.removeItem(STORAGE_KEY);
+  } catch {
+  }
+};
+function safeLocalStorage() {
+  try {
+    return typeof window === "undefined" ? void 0 : window.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+const buildMessages = (adminMessages, language) => ({
+  ...adminMessages ?? {},
+  ...translations.en,
+  ...translations[language] ?? {}
+});
+const createIntlErrorHandler = (parentOnError) => (error) => {
+  if (error?.code === "MISSING_TRANSLATION") return;
+  if (typeof parentOnError === "function") parentOnError(error);
+};
+const LanguageContext = createContext(null);
+const usePluginLanguage = () => {
+  const context = useContext(LanguageContext);
+  if (!context) {
+    throw new Error("usePluginLanguage must be used within LanguageProvider");
+  }
+  return context;
+};
+const LanguageProvider = ({ children }) => {
+  const parentIntl = useContext(IntlContext);
+  const adminLanguage = toSupportedLanguage(parentIntl?.locale) ?? "en";
+  const [override, setOverride] = useState(() => readStoredLanguage());
+  const language = override ?? adminLanguage;
+  const changeLanguage = useCallback((next) => {
+    const supported = toSupportedLanguage(next);
+    setOverride(supported);
+    writeStoredLanguage(supported);
+  }, []);
+  const messages = useMemo(
+    () => buildMessages(parentIntl?.messages, language),
+    [parentIntl?.messages, language]
+  );
+  const parentOnError = parentIntl?.onError;
+  const onError = useMemo(() => createIntlErrorHandler(parentOnError), [parentOnError]);
+  const value = useMemo(
+    () => ({
+      language,
+      adminLanguage,
+      isFollowingAdmin: override === null,
+      languages: SUPPORTED_LANGUAGES,
+      changeLanguage,
+      /** @deprecated use `useMagicLinkIntl().t(key, defaultMessage)` */
+      t: (key) => messages[key] ?? key
+    }),
+    [language, adminLanguage, override, changeLanguage, messages]
+  );
+  const locale = parentIntl?.locale && toSupportedLanguage(parentIntl.locale) === language ? parentIntl.locale : language;
+  return /* @__PURE__ */ jsx(LanguageContext.Provider, { value, children: /* @__PURE__ */ jsx(
+    IntlProvider,
+    {
+      locale,
+      messages,
+      defaultLocale: "en",
+      timeZone: parentIntl?.timeZone,
+      onError,
+      children
+    }
+  ) });
+};
+const LicenseGuard = ({ children }) => /* @__PURE__ */ jsx(Fragment, { children });
+export {
+  LicenseGuard as L,
+  PluginPageTitle as P,
+  SubsectionHeading as S,
+  brand as a,
+  breakpoints as b,
+  color as c,
+  accent as d,
+  tint as e,
+  fontSize as f,
+  byScheme as g,
+  useFormatters as h,
+  useMagicLinkRBAC as i,
+  useCopyToClipboard as j,
+  LanguageProvider as k,
+  usePluginLanguage as l,
+  motionSafe as m,
+  reducedMotion as r,
+  space as s,
+  theme as t,
+  useMagicLinkIntl as u
+};