@venix-sistemas/jade 1.0.0

package/dist/shared/types/typography.d.ts

@@ -0,0 +1,15 @@
+export interface FontConfig {
+    name: string;
+    preload: boolean;
+    sources: {
+        woff2: string;
+    };
+    weight: string;
+    style: string;
+}
+export interface TypographyConfig {
+    enabled: boolean;
+    defaultFonts: string;
+    fontSize: string;
+    customFonts: FontConfig[];
+}

package/dist/shared/types/vuetify.d.ts

@@ -0,0 +1,3 @@
+export interface VuetifyOptions {
+    enabled: boolean;
+}

package/dist/shared/unocss-preset.d.ts

@@ -0,0 +1,32 @@
+export interface VenixUnoPreset {
+    name: string;
+    theme: {
+        colors: Record<string, string>;
+    };
+}
+/**
+ * UnoCSS preset that exposes the theme's colors as `theme.colors` (`primary`,
+ * `secondary`, `background2`, ...), all pointing at the CSS vars this module
+ * generates (`--color-primary`, ...) — enables utilities like `text-primary`,
+ * `bg-background2/80` or `border-accent`.
+ *
+ * Must be added manually to your `uno.config.ts`:
+ *
+ * ```ts
+ * import { defineConfig } from 'unocss'
+ * import { venixUnoPreset } from '@venix-sistemas/jade/unocss'
+ *
+ * export default defineConfig({
+ *   presets: [venixUnoPreset()],
+ * })
+ * ```
+ *
+ * Not injected automatically: `@unocss/nuxt` reloads `uno.config.ts` from
+ * disk on its own (to support HMR) and shallow-merges that file against any
+ * config injected via hook — that silently discards a hook-injected `theme`
+ * whenever the consumer's `uno.config.ts` already declares its own `theme`
+ * key (even one without any colors). As a preset inside the `presets` array
+ * itself, these colors become part of what's actually read from the file and
+ * survive that merge.
+ */
+export declare function venixUnoPreset(): VenixUnoPreset;

package/dist/shared/unocss-preset.js

@@ -0,0 +1,13 @@
+import { COLOR_PROPERTIES } from "./constants.js";
+export function venixUnoPreset() {
+  const colors = {
+    inverse: "var(--color-inverse)"
+  };
+  for (const property of COLOR_PROPERTIES) {
+    colors[property] = `var(--color-${property})`;
+  }
+  return {
+    name: "venix-theme",
+    theme: { colors }
+  };
+}

package/dist/shared/utils/consent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads functional-cookie consent from `localStorage` under
+ * `COOKIE_CONSENT_STORAGE_KEY` — never written by this module on its own
+ * (only via `persistence.grant()/revoke()`), and can also come from the
+ * consumer app's own cookie-consent UI, as long as it writes the same shape
+ * (`{ functionality: boolean }`).
+ */
+export declare function hasCookieConsent(): boolean;

package/dist/shared/utils/consent.js

@@ -0,0 +1,12 @@
+import { COOKIE_CONSENT_STORAGE_KEY } from "../constants.js";
+export 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;
+  }
+}

package/dist/shared/utils/icon-refs.d.ts

@@ -0,0 +1,10 @@
+import type { ThemeColors } from '../types/colors.js';
+/**
+ * Extracts the Iconify `collection:icon` references used in color themes
+ * (`icon.css` / `icon.svg`) and in the configured icon aliases, grouped by
+ * collection. Lets each collection be bundled with only the icons actually
+ * used (tree-shaking) instead of the whole collection — essential for large
+ * collections like `mdi` (thousands of icons) used for only a handful of
+ * icons in the default theme.
+ */
+export declare function extractIconRefs(themes: Record<string, ThemeColors>, aliases: Record<string, string>): Map<string, Set<string>>;

package/dist/shared/utils/icon-refs.js

@@ -0,0 +1,24 @@
+const ICONIFY_NAME = /^([\w-]+):([\w-]+)$/;
+function addRef(refs, value) {
+  const match = value ? ICONIFY_NAME.exec(value.trim()) : null;
+  if (!match) return;
+  const collection = match[1];
+  const icon = match[2];
+  const set = refs.get(collection) ?? /* @__PURE__ */ new Set();
+  set.add(icon);
+  refs.set(collection, set);
+}
+export function extractIconRefs(themes, aliases) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const theme of Object.values(themes)) {
+    const icon = theme.icon;
+    if (icon && typeof icon === "object") {
+      addRef(refs, icon.css);
+      addRef(refs, icon.svg);
+    }
+  }
+  for (const value of Object.values(aliases)) {
+    addRef(refs, value);
+  }
+  return refs;
+}

package/dist/shared/utils/icon.d.ts

@@ -0,0 +1,27 @@
+import type { ThemeIconFormats } from '../types/colors.js';
+export type IconKind = 'emoji' | 'icon' | 'svg';
+export interface ResolvedIcon {
+    kind: IconKind;
+    value: string;
+}
+/**
+ * Resolves an icon value to the correct rendering type:
+ * - inline SVG (starts with `<svg`)
+ * - Iconify icon name (`collection:name` format, e.g. `line-md:home`)
+ * - emoji/text (any other value)
+ *
+ * Aliases are resolved first, then the resulting value goes through the same
+ * detection — an alias can point to any of the three formats.
+ */
+export declare function resolveIcon(input: string, aliases?: Record<string, string>): ResolvedIcon;
+export type ThemeIconFormat = 'emote' | 'css' | 'svg';
+export interface ResolvedThemeIcon {
+    format: ThemeIconFormat;
+    value: string;
+}
+/**
+ * Resolves a color theme's icon (a legacy string, always emote, or a
+ * `ThemeIconFormats` with variants) to the preferred format, falling back to
+ * `emote` when the theme doesn't define the chosen format.
+ */
+export declare function resolveThemeIcon(icon: string | ThemeIconFormats | undefined, preferred: ThemeIconFormat): ResolvedThemeIcon | null;

package/dist/shared/utils/icon.js

@@ -0,0 +1,20 @@
+export function resolveIcon(input, aliases = {}) {
+  const value = (aliases[input] ?? input).trim();
+  if (/^<svg[\s>]/i.test(value)) {
+    return { kind: "svg", value };
+  }
+  if (/^[\w-]+:[\w-]+$/.test(value)) {
+    return { kind: "icon", value };
+  }
+  return { kind: "emoji", value };
+}
+export function resolveThemeIcon(icon, preferred) {
+  if (!icon) return null;
+  if (typeof icon === "string") {
+    return { format: "emote", value: icon };
+  }
+  if (preferred !== "emote" && icon[preferred]) {
+    return { format: preferred, value: icon[preferred] };
+  }
+  return { format: "emote", value: icon.emote };
+}

package/dist/shared/utils/index.d.ts

@@ -0,0 +1,9 @@
+export { normalizeLocale, extractFirstLocale, normalizeColor, normalizeThemeName, } from './normalize.js';
+export { resolveFeatureOption } from './options.js';
+export { resolveIcon, resolveThemeIcon } from './icon.js';
+export type { IconKind, ResolvedIcon, ThemeIconFormat, ResolvedThemeIcon } from './icon.js';
+export { extractIconRefs } from './icon-refs.js';
+export { hasCookieConsent } from './consent.js';
+export { isColorTheme, getActiveSeasonalTheme, resolveThemePreference } from './theme-resolve.js';
+export { buildResolvedTheme } from './theme-config.js';
+export type { VenixRuntimeThemeConfig } from './theme-config.js';

package/dist/shared/utils/index.js

@@ -0,0 +1,12 @@
+export {
+  normalizeLocale,
+  extractFirstLocale,
+  normalizeColor,
+  normalizeThemeName
+} from "./normalize.js";
+export { resolveFeatureOption } from "./options.js";
+export { resolveIcon, resolveThemeIcon } from "./icon.js";
+export { extractIconRefs } from "./icon-refs.js";
+export { hasCookieConsent } from "./consent.js";
+export { isColorTheme, getActiveSeasonalTheme, resolveThemePreference } from "./theme-resolve.js";
+export { buildResolvedTheme } from "./theme-config.js";

package/dist/shared/utils/load.d.ts

@@ -0,0 +1,4 @@
+import type { ThemeConfig } from '../types/index.js';
+export declare function loadTheme(_path?: string): ThemeConfig;
+export declare function extractLocales(theme: ThemeConfig): string[];
+export declare function getDefaultLocale(theme: ThemeConfig): string;

package/dist/shared/utils/load.js

@@ -0,0 +1,24 @@
+import defaultTheme from "../../shared/theme.json" with { type: "json" };
+import { DEFAULT_LOCALE } from "../constants.js";
+import { normalizeLocale } from "./normalize.js";
+export function loadTheme(_path) {
+  return defaultTheme;
+}
+export function extractLocales(theme) {
+  const locales = /* @__PURE__ */ new Set();
+  Object.values(theme.colors?.themes || {}).forEach((themeConfig) => {
+    if (themeConfig.translations) {
+      Object.keys(themeConfig.translations).forEach((locale) => {
+        locales.add(normalizeLocale(locale));
+      });
+    }
+  });
+  return Array.from(locales);
+}
+export function getDefaultLocale(theme) {
+  const locales = extractLocales(theme);
+  if (locales.includes("en-US")) return "en-US";
+  const firstLocale = locales[0];
+  if (firstLocale) return firstLocale;
+  return DEFAULT_LOCALE;
+}

package/dist/shared/utils/normalize.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Normalizes a locale to the standard format.
+ * E.g.: "pt" -> "pt-BR", "PT-br" -> "pt-BR"
+ */
+export declare function normalizeLocale(locale: string): string;
+/**
+ * Extracts the first locale from an Accept-Language header.
+ * E.g.: "pt-BR,pt;q=0.9,en;q=0.8" -> "pt-BR"
+ */
+export declare function extractFirstLocale(acceptLanguage: string): string | null;
+/**
+ * Normalizes a hex color.
+ * E.g.: "fff" -> "#FFF", "ffffff" -> "#FFFFFF", "#fff" -> "#FFF"
+ */
+export declare function normalizeColor(color: string): string;
+/**
+ * Normalizes a theme name.
+ * E.g.: "dark" -> "Dark", "DARK" -> "Dark"
+ */
+export declare function normalizeThemeName(name: string): string;

package/dist/shared/utils/normalize.js

@@ -0,0 +1,38 @@
+import { LOCALE_MAP, DEFAULT_LOCALE } from "../constants.js";
+export function normalizeLocale(locale) {
+  if (!locale) return DEFAULT_LOCALE;
+  const lowerLocale = locale.toLowerCase();
+  if (lowerLocale.includes("-")) {
+    const parts = lowerLocale.split("-");
+    const base = parts[0];
+    const region = parts[1];
+    if (base && region) {
+      return `${base}-${region.toUpperCase()}`;
+    }
+    return base || lowerLocale;
+  }
+  return LOCALE_MAP[lowerLocale] || lowerLocale;
+}
+export function extractFirstLocale(acceptLanguage) {
+  if (!acceptLanguage) return null;
+  const parts = acceptLanguage.split(",");
+  if (parts.length === 0) return null;
+  const firstPart = parts[0];
+  if (!firstPart) return null;
+  const localeParts = firstPart.split(";");
+  if (localeParts.length === 0) return null;
+  const firstLocale = localeParts[0]?.trim();
+  return firstLocale || null;
+}
+export function normalizeColor(color) {
+  if (!color) return color;
+  color = color.trim();
+  if (!color.startsWith("#")) {
+    color = `#${color}`;
+  }
+  return color;
+}
+export function normalizeThemeName(name) {
+  if (!name) return name;
+  return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+}

package/dist/shared/utils/options.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolves a module option in `boolean | Partial<Config>` form against a base
+ * config. `false` disables the feature, an object enables it and merges in
+ * customizations, `true` forces the feature enabled (even if the base comes
+ * disabled, e.g. `theme.customCursor.enabled: false`), and `undefined` leaves
+ * the base config untouched.
+ */
+export declare function resolveFeatureOption<T extends {
+    enabled: boolean;
+}>(option: boolean | Partial<T> | undefined, base: T): T;

package/dist/shared/utils/options.js

@@ -0,0 +1,12 @@
+export function resolveFeatureOption(option, base) {
+  if (option === false) {
+    return { ...base, enabled: false };
+  }
+  if (option === true) {
+    return { ...base, enabled: true };
+  }
+  if (typeof option === "object" && option !== null) {
+    return { ...base, ...option, enabled: option.enabled ?? true };
+  }
+  return base;
+}

package/dist/shared/utils/theme-config.d.ts

@@ -0,0 +1,14 @@
+import type { ThemeConfig, ThemeColors } from '../types/index.js';
+export interface VenixRuntimeThemeConfig {
+    defaultTheme?: string;
+    colorThemes?: Record<string, Partial<ThemeColors>>;
+}
+/**
+ * Rebuilds the full `ThemeConfig` at runtime, layering `theme.json`
+ * (bundled with the module, with the "base" themes) with the customizations
+ * from `runtimeConfig.public.venixTheme` (resolved at build time from the
+ * module options in `nuxt.config`, see `module.ts`). Single implementation —
+ * used by the composable (`useVenixTheme`) and the SSR/Vuetify plugins, which
+ * used to each reimplement this merge their own way.
+ */
+export declare function buildResolvedTheme(runtimeThemeConfig?: VenixRuntimeThemeConfig): ThemeConfig;

package/dist/shared/utils/theme-config.js

@@ -0,0 +1,22 @@
+import themeData from "../theme.json" with { type: "json" };
+import { DEFAULT_THEME } from "../constants.js";
+export function buildResolvedTheme(runtimeThemeConfig) {
+  const defaultColors = {
+    enabled: true,
+    defaults: true,
+    defaultColor: DEFAULT_THEME,
+    themes: {}
+  };
+  const baseColors = themeData.colors || defaultColors;
+  return {
+    ...themeData,
+    colors: {
+      ...baseColors,
+      defaultColor: runtimeThemeConfig?.defaultTheme || baseColors.defaultColor || DEFAULT_THEME,
+      themes: {
+        ...baseColors.themes,
+        ...runtimeThemeConfig?.colorThemes || {}
+      }
+    }
+  };
+}

package/dist/shared/utils/theme-resolve.d.ts

@@ -0,0 +1,24 @@
+import type { ThemeColors } from '../types/index.js';
+/**
+ * A theme only really counts as a "color" theme if it has at least one real
+ * color — placeholder entries like `'system'` (only used to show
+ * "Automatic" in the UI, see `theme.json`) have `translations`/`icon` but no
+ * color, and don't count.
+ */
+export declare function isColorTheme(themeConfig: ThemeColors | undefined): boolean;
+/**
+ * Active seasonal theme for today. When `prefersDark` is given, only returns
+ * themes matching that mode (light/dark); when omitted, returns the first
+ * active seasonal theme regardless of mode.
+ */
+export declare function getActiveSeasonalTheme(themes: Record<string, ThemeColors>, prefersDark?: boolean, now?: Date): string | null;
+/**
+ * Resolves a theme preference (`'system'`, a theme name, or empty) to the
+ * concrete color theme that should be applied. Single implementation of this
+ * rule — used by `useVenixTheme`/`useThemeSeasonal` and the SSR plugin
+ * (`theme-init.server.ts`). The pre-hydration script
+ * (`runtime/scripts/theme-init.ts`) is the one documented exception: it has
+ * to run as a self-contained IIFE (no imports), so it deliberately duplicates
+ * this logic — keep the two in sync when changing either.
+ */
+export declare function resolveThemePreference(preference: string | undefined, themes: Record<string, ThemeColors>, defaultTheme: string, prefersDark: boolean): string;

package/dist/shared/utils/theme-resolve.js

@@ -0,0 +1,45 @@
+export function isColorTheme(themeConfig) {
+  if (!themeConfig) return false;
+  return !!themeConfig.primary || !!themeConfig.background;
+}
+function parseDatePart(value) {
+  const parts = value.split("-").map(Number);
+  if (parts.length !== 2) return null;
+  const [month, day] = parts;
+  if (month === void 0 || day === void 0) return null;
+  return [month, day];
+}
+function isDateInSeasonalRange(themeConfig, now) {
+  if (themeConfig.seasonal !== true || !themeConfig.dateRange) return false;
+  const start = parseDatePart(themeConfig.dateRange.start);
+  const end = parseDatePart(themeConfig.dateRange.end);
+  if (!start || !end) return false;
+  const current = (now.getMonth() + 1) * 100 + now.getDate();
+  const startNum = start[0] * 100 + start[1];
+  const endNum = end[0] * 100 + end[1];
+  return startNum <= endNum ? current >= startNum && current <= endNum : current >= startNum || current <= endNum;
+}
+export function getActiveSeasonalTheme(themes, prefersDark, now = /* @__PURE__ */ new Date()) {
+  for (const [themeName, themeConfig] of Object.entries(themes)) {
+    if (themeName === "system") continue;
+    if (!isColorTheme(themeConfig)) continue;
+    if (!isDateInSeasonalRange(themeConfig, now)) continue;
+    if (prefersDark !== void 0 && themeConfig.dark !== prefersDark) continue;
+    return themeName;
+  }
+  return null;
+}
+export function resolveThemePreference(preference, themes, defaultTheme, prefersDark) {
+  let resolved;
+  if (preference === "system") {
+    resolved = getActiveSeasonalTheme(themes, prefersDark) || (prefersDark ? "dark" : "light");
+  } else if (preference && isColorTheme(themes[preference])) {
+    resolved = preference;
+  } else {
+    resolved = defaultTheme;
+  }
+  if (!isColorTheme(themes[resolved])) {
+    resolved = isColorTheme(themes[defaultTheme]) ? defaultTheme : "dark";
+  }
+  return resolved;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@venix-sistemas/jade",
+  "version": "1.0.0",
+  "description": "Complete color system for Nuxt: seasonal colors, automatic theme, SSR, Cookie Policy, cursor, scrollbar, etc...",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "nuxt-theme",
+    "jade",
+    "jade-theme",
+    "theme",
+    "theming",
+    "colors",
+    "dark-mode",
+    "seasonal-theme",
+    "typography",
+    "scrollbar",
+    "cursor",
+    "unocss",
+    "vuetify",
+    "iconify",
+    "i18n"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "author": "Vinicius da Silva Viana <contato@venixsistemas.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Venix-Sistemas/jade.git"
+  },
+  "homepage": "https://github.com/Venix-Sistemas/jade#readme",
+  "bugs": {
+    "url": "https://github.com/Venix-Sistemas/jade/issues"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs",
+      "exports": "./src/module.ts"
+    },
+    "./theme.json": "./dist/shared/theme.json",
+    "./unocss": {
+      "types": "./dist/shared/unocss-preset.d.ts",
+      "import": "./dist/shared/unocss-preset.js"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "release:alpha": "npm run lint && npm run test && npm run prepack && changelogen --release --prerelease alpha && npm publish --tag alpha && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "@iconify-json/line-md": "^1.2.16",
+    "@iconify-json/mdi": "^1.2.3",
+    "@iconify/utils": "^3.1.7",
+    "@nuxt/icon": "^2.5.1",
+    "@nuxt/kit": "^4.5.2"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "4.0.0-beta.3",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.5.2",
+    "@nuxt/test-utils": "^4.3.3",
+    "@nuxtjs/i18n": "10.6.0",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.12.0",
+    "nuxt": "^4.5.2",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3",
+    "vue-tsc": "^3.3.12"
+  },
+  "packageManager": "pnpm@12.3.4"
+}