@venix-sistemas/jade 1.0.0

package/dist/runtime/composables/useThemeLocale.js

@@ -0,0 +1,87 @@
+import { watch } from "vue";
+import { useRequestHeaders, useState, useRoute } from "#app";
+import { DEFAULT_LOCALE } from "../../shared/constants";
+import { normalizeLocale, extractFirstLocale } from "../../shared/utils/normalize";
+import { hasCookieConsent } from "../../shared/utils/consent";
+export const useThemeLocale = (theme, localeCookie, options = {}) => {
+  const { enabled = true, forcedLocale, defaultLocale } = options;
+  const headers = useRequestHeaders(["accept-language"]);
+  const route = useRoute();
+  const fallbackLocale = defaultLocale || DEFAULT_LOCALE;
+  const detectLocale = () => {
+    const getAvailableLocales = () => {
+      const availableLocales = /* @__PURE__ */ new Set();
+      Object.values(theme.colors.themes).forEach((themeConfig) => {
+        if (themeConfig.translations) {
+          Object.keys(themeConfig.translations).forEach((locale) => {
+            availableLocales.add(normalizeLocale(locale));
+          });
+        }
+      });
+      return Array.from(availableLocales);
+    };
+    const findLocaleInAvailable = (requestedLocale) => {
+      const availableLocales = getAvailableLocales();
+      const normalized = normalizeLocale(requestedLocale);
+      if (availableLocales.includes(normalized)) return normalized;
+      const baseLocale = normalized.split("-")[0];
+      return availableLocales.find((locale) => locale.split("-")[0] === baseLocale) || null;
+    };
+    const findBestLocale = (requestedLocale) => findLocaleInAvailable(requestedLocale) || fallbackLocale;
+    if (forcedLocale) return findBestLocale(forcedLocale);
+    if (!enabled) return fallbackLocale;
+    if (localeCookie.value) return findBestLocale(localeCookie.value);
+    const pathSegment = route.path.split("/").find(Boolean);
+    if (pathSegment) {
+      const pathLocale = findLocaleInAvailable(pathSegment);
+      if (pathLocale) return pathLocale;
+    }
+    const acceptLanguageHeader = headers["accept-language"];
+    if (acceptLanguageHeader) {
+      const acceptLanguage = Array.isArray(acceptLanguageHeader) ? acceptLanguageHeader[0] : acceptLanguageHeader;
+      if (acceptLanguage) {
+        const firstLocale = extractFirstLocale(acceptLanguage);
+        if (firstLocale) return findBestLocale(firstLocale);
+      }
+    }
+    if (import.meta.client && typeof navigator !== "undefined") {
+      return findBestLocale(navigator.language || fallbackLocale);
+    }
+    return fallbackLocale;
+  };
+  const currentLocale = useState("venix-theme-locale", () => detectLocale());
+  if (enabled && !forcedLocale && localeCookie.value) {
+    const cookieLocale = normalizeLocale(localeCookie.value);
+    if (cookieLocale !== currentLocale.value) {
+      currentLocale.value = cookieLocale;
+    }
+  }
+  watch(localeCookie, (newLocale) => {
+    if (enabled && newLocale && !forcedLocale) {
+      currentLocale.value = normalizeLocale(newLocale);
+    }
+  });
+  const translate = (translations, fallback) => {
+    if (!translations) return fallback || "";
+    const locale = currentLocale.value;
+    if (translations[locale]) return translations[locale];
+    const baseLocale = locale.split("-")[0];
+    if (baseLocale && translations[baseLocale]) return translations[baseLocale];
+    if (translations[fallbackLocale]) return translations[fallbackLocale];
+    if (translations["en-US"]) return translations["en-US"];
+    const firstTranslation = Object.values(translations)[0];
+    if (firstTranslation) return firstTranslation;
+    return fallback || "";
+  };
+  const setLocale = (locale) => {
+    currentLocale.value = normalizeLocale(locale);
+    if (enabled && !forcedLocale && hasCookieConsent()) {
+      localeCookie.value = normalizeLocale(locale);
+    }
+  };
+  return {
+    currentLocale,
+    translate,
+    setLocale
+  };
+};

package/dist/runtime/composables/useThemeSeasonal.d.ts

@@ -0,0 +1,4 @@
+import type { ThemeConfig } from '../../shared/types/index.js';
+export declare const useThemeSeasonal: (theme: ThemeConfig) => {
+    getActiveSeasonalTheme: (prefersDark?: boolean) => string | null;
+};

package/dist/runtime/composables/useThemeSeasonal.js

@@ -0,0 +1,7 @@
+import { getActiveSeasonalTheme } from "../../shared/utils/theme-resolve";
+export const useThemeSeasonal = (theme) => {
+  const getActiveSeasonalThemeFor = (prefersDark) => getActiveSeasonalTheme(theme.colors.themes, prefersDark);
+  return {
+    getActiveSeasonalTheme: getActiveSeasonalThemeFor
+  };
+};

package/dist/runtime/composables/useVenixIcon.d.ts

@@ -0,0 +1,3 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { ResolvedIcon } from '../../shared/utils/icon.js';
+export declare function useVenixIcon(icon: string | Ref<string> | ComputedRef<string>): ComputedRef<ResolvedIcon>;

package/dist/runtime/composables/useVenixIcon.js

@@ -0,0 +1,11 @@
+import { computed } from "vue";
+import { useRuntimeConfig } from "#app";
+import { resolveIcon } from "../../shared/utils/icon";
+export function useVenixIcon(icon) {
+  const config = useRuntimeConfig();
+  const aliases = config.public.venixTheme?.icon?.aliases || {};
+  return computed(() => {
+    const value = typeof icon === "string" ? icon : icon.value;
+    return resolveIcon(value, aliases);
+  });
+}

package/dist/runtime/composables/useVenixTheme.d.ts

@@ -0,0 +1,33 @@
+export declare const useVenixTheme: () => {
+    theme: {
+        value: import("vue").ComputedRef<string>;
+        preference: import("vue").Ref<string, string>;
+        data: import("vue").ComputedRef<{
+            value: string;
+            name: string;
+            icon: import("../../shared/utils/icon.js").ResolvedThemeIcon | null;
+        } | undefined>;
+        toggle: (forceTheme?: string) => void;
+        isSeasonalActive: import("vue").ComputedRef<boolean>;
+        activeSeasonalTheme: import("vue").ComputedRef<string | null>;
+        shouldApplyColors: boolean;
+        colors: import("../../shared/types/index.js").ColorsConfig;
+    };
+    themes: import("vue").ComputedRef<{
+        value: string;
+        name: string;
+        icon: import("../../shared/utils/icon.js").ResolvedThemeIcon | null;
+    }[]>;
+    locale: {
+        current: import("vue").Ref<string, string>;
+        set: (locale: string) => void;
+        translate: (translations?: Record<string, string>, fallback?: string) => string;
+    };
+    persistence: {
+        hasConsent: import("vue").Ref<boolean, boolean>;
+        grant: () => void;
+        revoke: () => void;
+        enable: () => void;
+        disable: () => void;
+    };
+};

package/dist/runtime/composables/useVenixTheme.js

@@ -0,0 +1,186 @@
+import { computed, watch, onMounted, onUnmounted, getCurrentInstance } from "vue";
+import { useRuntimeConfig, useState } from "#app";
+import { DEFAULT_THEME, DEFAULT_LOCALE, COOKIE_PREFERENCES_UPDATED_EVENT, COOKIE_CONSENT_STORAGE_KEY, THEME_APPLIED_EVENT } from "../../shared/constants";
+import { useThemeCookies } from "./useThemeCookies.js";
+import { useThemeLocale } from "./useThemeLocale.js";
+import { useThemeSeasonal } from "./useThemeSeasonal.js";
+import { useThemeColors } from "./useThemeColors.js";
+import { hasCookieConsent } from "../../shared/utils/consent";
+import { buildResolvedTheme } from "../../shared/utils/theme-config";
+import { resolveThemePreference } from "../../shared/utils/theme-resolve";
+export const useVenixTheme = () => {
+  const config = useRuntimeConfig();
+  const themeConfig = config.public.venixTheme;
+  const theme = buildResolvedTheme(themeConfig);
+  const defaultTheme = theme.colors.defaultColor || DEFAULT_THEME;
+  const shouldApplyColors = themeConfig?.applyColors !== false && theme.colors.defaults !== false;
+  const cookies = useThemeCookies(themeConfig?.localeCookie);
+  const hasConsent = useState(
+    "venix-cookie-consent",
+    () => typeof window !== "undefined" && hasCookieConsent()
+  );
+  const locale = useThemeLocale(theme, cookies.localeCookie, {
+    enabled: themeConfig?.enabled?.translation !== false,
+    forcedLocale: themeConfig?.locale,
+    defaultLocale: themeConfig?.defaultLocale || DEFAULT_LOCALE
+  });
+  if (themeConfig?.enabled?.manageHtmlLang) {
+    if (typeof document !== "undefined") {
+      document.documentElement.lang = locale.currentLocale.value;
+    }
+    watch(locale.currentLocale, (newLocale) => {
+      if (typeof document !== "undefined") document.documentElement.lang = newLocale;
+    });
+  }
+  const seasonal = useThemeSeasonal(theme);
+  const colors = useThemeColors(theme, locale.translate, themeConfig?.iconFormat || "svg");
+  const initialPreference = cookies.preferenceCookie.value || defaultTheme;
+  const preference = useState("venix-theme-preference", () => initialPreference || "system");
+  const getResolvedTheme = (pref) => {
+    const prefersDark = typeof window !== "undefined" ? window.matchMedia("(prefers-color-scheme: dark)").matches : true;
+    return resolveThemePreference(pref, theme.colors.themes, defaultTheme, prefersDark);
+  };
+  const apply = (pref) => {
+    if (!shouldApplyColors) return;
+    const resolved = getResolvedTheme(pref);
+    if (typeof document !== "undefined") {
+      const html = document.documentElement;
+      html.classList.remove(...colors.themeValues.value);
+      html.classList.add(resolved);
+      html.setAttribute("data-theme", resolved);
+      window.__VENIX_INITIAL_THEME__ = resolved;
+      window.dispatchEvent(new CustomEvent(THEME_APPLIED_EVENT, { detail: resolved }));
+    }
+  };
+  const applyWithTransition = (pref) => {
+    const canAnimate = typeof document !== "undefined" && typeof document.startViewTransition === "function" && !window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    if (!canAnimate) {
+      apply(pref);
+      return;
+    }
+    const body = document.body;
+    const hasCustomCursor = theme.customCursor?.enabled !== false && !!theme.customCursor?.cursors;
+    const currentCursor = hasCustomCursor ? getComputedStyle(body).cursor : null;
+    if (currentCursor && currentCursor !== "auto") {
+      body.style.setProperty("cursor", currentCursor, "important");
+    }
+    const restoreCursor = () => body.style.removeProperty("cursor");
+    const transition = document.startViewTransition(() => apply(pref));
+    transition.ready.catch(() => {
+    });
+    transition.finished.then(restoreCursor).catch(restoreCursor);
+  };
+  if (typeof document !== "undefined" && shouldApplyColors) {
+    if (cookies.preferenceCookie.value && cookies.preferenceCookie.value !== preference.value) {
+      preference.value = cookies.preferenceCookie.value;
+    }
+    const currentTheme = document.documentElement.getAttribute("data-theme");
+    if (currentTheme) {
+      if (!cookies.preferenceCookie.value) {
+        preference.value = currentTheme;
+      }
+    } else {
+      apply(preference.value);
+    }
+  }
+  const syncPersistence = () => {
+    hasConsent.value = hasCookieConsent();
+    if (hasConsent.value) {
+      cookies.persistIfConsented(preference.value, getResolvedTheme(preference.value));
+    } else {
+      cookies.disablePersistence();
+    }
+  };
+  const grantPersistence = () => {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(COOKIE_CONSENT_STORAGE_KEY, JSON.stringify({ functionality: true }));
+    syncPersistence();
+    window.dispatchEvent(new Event(COOKIE_PREFERENCES_UPDATED_EVENT));
+  };
+  const revokePersistence = () => {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(COOKIE_CONSENT_STORAGE_KEY, JSON.stringify({ functionality: false }));
+    syncPersistence();
+    window.dispatchEvent(new Event(COOKIE_PREFERENCES_UPDATED_EVENT));
+  };
+  const instance = getCurrentInstance();
+  const runOnClientMount = (fn) => {
+    if (instance) {
+      onMounted(fn);
+    } else if (typeof window !== "undefined") {
+      queueMicrotask(fn);
+    }
+  };
+  runOnClientMount(() => {
+    hasConsent.value = hasCookieConsent();
+    if (!shouldApplyColors) return;
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleSystemThemeChange = () => {
+      if (preference.value === "system") applyWithTransition("system");
+    };
+    mq.addEventListener("change", handleSystemThemeChange);
+    const checkSeasonalChange = () => {
+      const now = /* @__PURE__ */ new Date();
+      const msToMidnight = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).getTime() - now.getTime();
+      return setTimeout(() => {
+        if (preference.value === "system") applyWithTransition("system");
+        checkSeasonalChange();
+      }, msToMidnight + 1e3);
+    };
+    const midnightTimeout = checkSeasonalChange();
+    window.addEventListener(COOKIE_PREFERENCES_UPDATED_EVENT, syncPersistence);
+    if (instance) {
+      onUnmounted(() => {
+        mq.removeEventListener("change", handleSystemThemeChange);
+        clearTimeout(midnightTimeout);
+        window.removeEventListener(COOKIE_PREFERENCES_UPDATED_EVENT, syncPersistence);
+      });
+    }
+  });
+  watch(preference, (newPref) => {
+    if (!shouldApplyColors) return;
+    applyWithTransition(newPref);
+    cookies.persistIfConsented(newPref, getResolvedTheme(newPref));
+  });
+  const toggle = (forceTheme) => {
+    const newTheme = forceTheme ?? (preference.value === "light" ? "dark" : "light");
+    preference.value = newTheme;
+    cookies.persistIfConsented(newTheme, getResolvedTheme(newTheme));
+  };
+  const data = computed(
+    () => colors.themes.value.find((t) => t.value === preference.value) ?? colors.themes.value[0]
+  );
+  const isSeasonalActive = computed(() => {
+    if (preference.value !== "system") return false;
+    return seasonal.getActiveSeasonalTheme() !== null;
+  });
+  const activeSeasonalTheme = computed(() => {
+    if (preference.value !== "system") return null;
+    return seasonal.getActiveSeasonalTheme();
+  });
+  return {
+    theme: {
+      value: computed(() => getResolvedTheme(preference.value)),
+      preference,
+      data,
+      toggle,
+      isSeasonalActive,
+      activeSeasonalTheme,
+      shouldApplyColors,
+      colors: theme.colors
+    },
+    themes: colors.themes,
+    locale: {
+      current: locale.currentLocale,
+      set: locale.setLocale,
+      translate: locale.translate
+    },
+    persistence: {
+      hasConsent,
+      grant: grantPersistence,
+      revoke: revokePersistence,
+      enable: () => cookies.persistIfConsented(preference.value, getResolvedTheme(preference.value)),
+      disable: cookies.disablePersistence
+    }
+  };
+};

package/dist/runtime/nitro/theme-init.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/nitro/theme-init.js

@@ -0,0 +1,11 @@
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
+import initTheme from "../scripts/theme-init.js";
+import { buildResolvedTheme } from "../../shared/utils/theme-config";
+export default defineNitroPlugin((nitroApp) => {
+  const theme = buildResolvedTheme(useRuntimeConfig().public.venixTheme);
+  const inlineScript = `<script>(${initTheme.toString()})(${JSON.stringify(theme)})<\/script>`;
+  const hookRenderHtml = nitroApp.hooks.hook;
+  hookRenderHtml("render:html", (html) => {
+    html.head.unshift(inlineScript);
+  });
+});

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,3 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin(() => {
+});

package/dist/runtime/plugins/theme-init.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/theme-init.server.js

@@ -0,0 +1,37 @@
+import { defineNuxtPlugin, useRuntimeConfig, useCookie, useHead } from "#app";
+import { THEME_PREFERENCE_COOKIE, THEME_RESOLVED_COOKIE, DEFAULT_LOCALE_COOKIE_NAME, DEFAULT_LOCALE, DEFAULT_THEME } from "../../shared/constants";
+import { useThemeLocale } from "../composables/useThemeLocale.js";
+import { buildResolvedTheme } from "../../shared/utils/theme-config";
+import { isColorTheme, resolveThemePreference } from "../../shared/utils/theme-resolve";
+export default defineNuxtPlugin({
+  name: "venix-theme-init-server",
+  enforce: "pre",
+  setup() {
+    const config = useRuntimeConfig();
+    const themeConfig = config.public.venixTheme;
+    const resolvedCookie = useCookie(THEME_RESOLVED_COOKIE);
+    const preferenceCookie = useCookie(THEME_PREFERENCE_COOKIE);
+    const theme = buildResolvedTheme(themeConfig);
+    const defaultTheme = theme.colors.defaultColor || DEFAULT_THEME;
+    let resolvedTheme = defaultTheme;
+    if (resolvedCookie.value && isColorTheme(theme.colors.themes[resolvedCookie.value])) {
+      resolvedTheme = resolvedCookie.value;
+    } else if (preferenceCookie.value) {
+      resolvedTheme = resolveThemePreference(preferenceCookie.value, theme.colors.themes, defaultTheme, true);
+    }
+    const htmlAttrs = {
+      "data-theme": resolvedTheme,
+      "class": resolvedTheme
+    };
+    if (themeConfig?.enabled?.manageHtmlLang) {
+      const localeCookie = useCookie(themeConfig?.localeCookie || DEFAULT_LOCALE_COOKIE_NAME);
+      const locale = useThemeLocale(theme, localeCookie, {
+        enabled: themeConfig?.enabled?.translation !== false,
+        forcedLocale: themeConfig?.locale,
+        defaultLocale: themeConfig?.defaultLocale || DEFAULT_LOCALE
+      });
+      htmlAttrs.lang = locale.currentLocale.value;
+    }
+    useHead({ htmlAttrs });
+  }
+});

package/dist/runtime/plugins/vuetify-theme.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/vuetify-theme.js

@@ -0,0 +1,42 @@
+import { defineNuxtPlugin, useRuntimeConfig, useCookie } from "#app";
+import { THEME_PREFERENCE_COOKIE, THEME_RESOLVED_COOKIE, THEME_APPLIED_EVENT, DEFAULT_THEME } from "../../shared/constants";
+import { buildResolvedTheme } from "../../shared/utils/theme-config";
+function applyVuetifyTheme(vuetify, name) {
+  if (typeof vuetify.theme.change === "function") {
+    vuetify.theme.change(name);
+  } else {
+    vuetify.theme.global.name.value = name;
+  }
+}
+export default defineNuxtPlugin({
+  name: "venix-theme-vuetify-sync",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const config = useRuntimeConfig();
+    const themeConfig = config.public.venixTheme;
+    const resolvedCookie = useCookie(THEME_RESOLVED_COOKIE);
+    const preferenceCookie = useCookie(THEME_PREFERENCE_COOKIE);
+    const theme = buildResolvedTheme(themeConfig);
+    const defaultTheme = theme.colors.defaultColor || DEFAULT_THEME;
+    const hookBeforeCreate = nuxtApp.hook;
+    hookBeforeCreate("vuetify:before-create", ({ vuetifyOptions }) => {
+      const themes = vuetifyOptions?.theme?.themes;
+      if (!vuetifyOptions?.theme || !themes) return;
+      let resolved = defaultTheme;
+      if (resolvedCookie.value && themes[resolvedCookie.value]) {
+        resolved = resolvedCookie.value;
+      } else if (preferenceCookie.value && themes[preferenceCookie.value]) {
+        resolved = preferenceCookie.value;
+      }
+      vuetifyOptions.theme.defaultTheme = resolved;
+    });
+    if (import.meta.client) {
+      const hookReady = nuxtApp.hook;
+      hookReady("vuetify:ready", (vuetify) => {
+        window.addEventListener(THEME_APPLIED_EVENT, ((event) => {
+          applyVuetifyTheme(vuetify, event.detail);
+        }));
+      });
+    }
+  }
+});

package/dist/runtime/scripts/theme-init.d.ts

@@ -0,0 +1,27 @@
+import type { ThemeConfig } from '../../shared/types/index.js';
+declare global {
+    interface Window {
+        __VENIX_INITIAL_THEME__?: string;
+    }
+}
+/**
+ * Runs as an inline script in `<head>`, injected via Nitro's `render:html`
+ * hook by the `runtime/nitro/theme-init.ts` plugin (see
+ * `setup/register-plugins.ts`) — BEFORE the Vue bundle, to avoid a
+ * wrong-theme flash before hydration (SSR doesn't know the user's real
+ * light/dark preference when the preference is 'system', nor does it have
+ * `matchMedia`).
+ *
+ * Because it runs this way, this function (only this function — the rest of
+ * the file, including the type imports, is erased by TypeScript and never
+ * reaches the browser) has to be 100% self-contained: `initTheme.toString()`
+ * gets serialized and executed as a standalone IIFE, so any import from
+ * another module would become a `ReferenceError` on the client. That's why
+ * the cookie names below and the theme-resolution rule
+ * (`resolveThemePreference`/`getActiveSeasonalTheme`) are deliberately
+ * duplicated — the canonical implementation, shared between the composable
+ * and the SSR plugin, lives in `shared/constants.ts` and
+ * `shared/utils/theme-resolve.ts`. Keep the two sides in sync when changing
+ * either one.
+ */
+export default function initTheme(themeData: ThemeConfig): void;

package/dist/runtime/scripts/theme-init.js

@@ -0,0 +1,89 @@
+export default function initTheme(themeData) {
+  const THEME_PREFERENCE_COOKIE = "venix-theme-preference";
+  const THEME_RESOLVED_COOKIE = "venix-theme-resolved";
+  const COOKIE_CONSENT_STORAGE_KEY = "venix-cookie-consent";
+  function hasCookieConsent() {
+    if (typeof localStorage === "undefined") return false;
+    const consentData = localStorage.getItem(COOKIE_CONSENT_STORAGE_KEY);
+    if (!consentData) return false;
+    try {
+      const consent = JSON.parse(consentData);
+      return consent?.functionality === true;
+    } catch {
+      return false;
+    }
+  }
+  function getCookie(name) {
+    const match = document.cookie.match(new RegExp("(^|; )" + name + "=([^;]+)"));
+    const cookieValue = match?.[2];
+    return cookieValue ? decodeURIComponent(cookieValue) : null;
+  }
+  function setCookieIfConsented(name, value) {
+    if (hasCookieConsent()) {
+      document.cookie = `${name}=${encodeURIComponent(value)}; path=/; max-age=31536000; SameSite=Lax`;
+    }
+  }
+  function isColorTheme(themeConfig) {
+    if (!themeConfig) return false;
+    return !!themeConfig.primary || !!themeConfig.background;
+  }
+  function isDateInSeasonalRange(themeConfig, now) {
+    if (themeConfig.seasonal !== true || !themeConfig.dateRange) return false;
+    const startParts = themeConfig.dateRange.start.split("-").map(Number);
+    const endParts = themeConfig.dateRange.end.split("-").map(Number);
+    if (startParts.length !== 2 || endParts.length !== 2) return false;
+    const [startMonth, startDay] = startParts;
+    const [endMonth, endDay] = endParts;
+    if (startMonth === void 0 || startDay === void 0 || endMonth === void 0 || endDay === void 0) return false;
+    const current = (now.getMonth() + 1) * 100 + now.getDate();
+    const startNum = startMonth * 100 + startDay;
+    const endNum = endMonth * 100 + endDay;
+    return startNum <= endNum ? current >= startNum && current <= endNum : current >= startNum || current <= endNum;
+  }
+  function getActiveSeasonalTheme(themes2, prefersDark) {
+    const now = /* @__PURE__ */ new Date();
+    for (const [themeName, themeConfig] of Object.entries(themes2)) {
+      if (themeName === "system") continue;
+      if (!isColorTheme(themeConfig)) continue;
+      if (!isDateInSeasonalRange(themeConfig, now)) continue;
+      if (themeConfig.dark !== prefersDark) continue;
+      return themeName;
+    }
+    return null;
+  }
+  function resolveThemePreference(preference2, themes2, defaultTheme2, prefersDark) {
+    let resolved;
+    if (preference2 === "system") {
+      resolved = getActiveSeasonalTheme(themes2, prefersDark) || (prefersDark ? "dark" : "light");
+    } else if (preference2 && isColorTheme(themes2[preference2])) {
+      resolved = preference2;
+    } else {
+      resolved = defaultTheme2;
+    }
+    if (!isColorTheme(themes2[resolved])) {
+      resolved = isColorTheme(themes2[defaultTheme2]) ? defaultTheme2 : "dark";
+    }
+    return resolved;
+  }
+  const html = document.documentElement;
+  const themes = themeData.colors?.themes || {};
+  const defaultTheme = themeData.colors?.defaultColor || "dark";
+  const preference = getCookie(THEME_PREFERENCE_COOKIE);
+  const resolvedCookie = getCookie(THEME_RESOLVED_COOKIE);
+  const systemPrefersDark = typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches;
+  let theme;
+  if (resolvedCookie && isColorTheme(themes[resolvedCookie])) {
+    theme = resolvedCookie;
+  } else {
+    theme = resolveThemePreference(preference || void 0, themes, defaultTheme, systemPrefersDark);
+  }
+  html.classList.add(theme);
+  html.setAttribute("data-theme", theme);
+  window.__VENIX_INITIAL_THEME__ = theme;
+  if (!resolvedCookie || resolvedCookie !== theme) {
+    setCookieIfConsented(THEME_RESOLVED_COOKIE, theme);
+  }
+  if (!preference) {
+    setCookieIfConsented(THEME_PREFERENCE_COOKIE, theme);
+  }
+}

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/shared/constants.d.ts

@@ -0,0 +1,28 @@
+export declare const THEME_PREFERENCE_COOKIE = "venix-theme-preference";
+export declare const THEME_RESOLVED_COOKIE = "venix-theme-resolved";
+export declare const COOKIE_PREFERENCES_UPDATED_EVENT = "venix-cookie-preferences-updated";
+/**
+ * Dispatched synchronously by `apply()` (useVenixTheme.ts), inside the same
+ * `document.startViewTransition()` callback — BEFORE the View Transition
+ * captures the new state. Integrations that need to react to theme changes
+ * (e.g. `vuetify-theme.ts`) should listen for this event instead of watching
+ * `theme.preference` on their own: a separate `watch()` runs asynchronously,
+ * decoupled from the transition (Vue's timing isn't the browser's), so the
+ * integration's DOM mutation ends up competing with the View Transition's
+ * snapshot capture for the same frame — in practice this can cause a real,
+ * noticeable freeze in apps with a lot of theme-reactive DOM (e.g. Vuetify
+ * recomputing CSS vars for every component). Listening for this event
+ * guarantees the integration runs in the same synchronous tick as the
+ * `data-theme` change, as part of the same transition.
+ */
+export declare const THEME_APPLIED_EVENT = "venix-theme-applied";
+/** Read (never written) by this module — the consumer app's cookie-consent UI writes here. */
+export declare const COOKIE_CONSENT_STORAGE_KEY = "venix-cookie-consent";
+export declare const DEFAULT_LOCALE = "en-US";
+export declare const DEFAULT_LOCALE_COOKIE_NAME = "i18n_redirected";
+export declare const LOCALE_MAP: Record<string, string>;
+export declare const DEFAULT_THEME = "dark";
+export declare const SYSTEM_THEME = "system";
+export declare const COLOR_PROPERTIES: readonly ["primary", "secondary", "accent", "error", "info", "success", "warning", "background", "background2", "background3"];
+export declare const NON_COLOR_PROPERTIES: readonly ["dark", "seasonal", "dateRange", "translations", "icon"];
+export declare const CSS_HEADER = "/* ============================================ */";

package/dist/shared/constants.js

@@ -0,0 +1,40 @@
+export const THEME_PREFERENCE_COOKIE = "venix-theme-preference";
+export const THEME_RESOLVED_COOKIE = "venix-theme-resolved";
+export const COOKIE_PREFERENCES_UPDATED_EVENT = "venix-cookie-preferences-updated";
+export const THEME_APPLIED_EVENT = "venix-theme-applied";
+export const COOKIE_CONSENT_STORAGE_KEY = "venix-cookie-consent";
+export const DEFAULT_LOCALE = "en-US";
+export const DEFAULT_LOCALE_COOKIE_NAME = "i18n_redirected";
+export const LOCALE_MAP = {
+  pt: "pt-BR",
+  en: "en-US",
+  es: "es-ES",
+  fr: "fr-FR",
+  de: "de-DE",
+  it: "it-IT",
+  ja: "ja-JP",
+  ko: "ko-KR",
+  zh: "zh-CN"
+};
+export const DEFAULT_THEME = "dark";
+export const SYSTEM_THEME = "system";
+export const COLOR_PROPERTIES = [
+  "primary",
+  "secondary",
+  "accent",
+  "error",
+  "info",
+  "success",
+  "warning",
+  "background",
+  "background2",
+  "background3"
+];
+export const NON_COLOR_PROPERTIES = [
+  "dark",
+  "seasonal",
+  "dateRange",
+  "translations",
+  "icon"
+];
+export const CSS_HEADER = "/* ============================================ */";

package/dist/shared/css/colors.d.ts

@@ -0,0 +1,2 @@
+import type { ThemeColors } from '../types/index.js';
+export declare function generateThemeVars(mode: string, colors: ThemeColors): string;