@12nil/theme-registry-package 0.1.0

package/dist/chunk-GUPUN2GN.js

@@ -0,0 +1,732 @@
+// theme-registry.ts
+var RUNTIME_THEME_REGISTRY_VERSION = "0.2.0";
+var LEGACY_REQUIRED_KEYS = ["primary", "secondary", "background", "text", "accent", "muted", "error", "warning", "success", "info"];
+var LEGACY_ALLOWED_KEYS = [...LEGACY_REQUIRED_KEYS, "tertiary"];
+var SEMANTIC_SCHEMA = {
+  colors: ["primary", "secondary", "destructive", "success", "warning", "info"],
+  surface: ["page", "card", "sidebar", "modal", "popover"],
+  text: ["primary", "secondary", "tertiary", "disabled"],
+  border: ["default", "subtle", "strong"]
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLikelyColor(value) {
+  const trimmed = value.trim();
+  return /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(trimmed) || /^rgba?\(.+\)$/.test(trimmed) || /^hsla?\(.+\)$/.test(trimmed) || /^var\(--.+\)$/.test(trimmed) || /^[a-zA-Z]+$/.test(trimmed);
+}
+function parseSemver(version) {
+  const normalized = version.split("-")[0];
+  const parts = normalized.split(".");
+  if (parts.length < 3) return null;
+  const major = Number(parts[0]);
+  const minor = Number(parts[1]);
+  const patch = Number(parts[2]);
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
+    return null;
+  }
+  return [major, minor, patch];
+}
+function compareSemver(a, b) {
+  const av = parseSemver(a);
+  const bv = parseSemver(b);
+  if (!av || !bv) return 0;
+  for (let i = 0; i < 3; i += 1) {
+    if (av[i] > bv[i]) return 1;
+    if (av[i] < bv[i]) return -1;
+  }
+  return 0;
+}
+function assertCompatibility(minVersion, label) {
+  if (!minVersion) return;
+  if (compareSemver(RUNTIME_THEME_REGISTRY_VERSION, minVersion) < 0) {
+    throw new Error(
+      `${label} requires Runtime Theme Registry >= ${minVersion}, current version is ${RUNTIME_THEME_REGISTRY_VERSION}`
+    );
+  }
+}
+function validateMetadata(metadata) {
+  const issues = [];
+  if (!metadata) return issues;
+  if (metadata.version && !parseSemver(metadata.version)) {
+    issues.push({ path: "theme.metadata.version", message: "Expected semver format like 1.0.0" });
+  }
+  if (metadata.compatibility?.minRegistryVersion && !parseSemver(metadata.compatibility.minRegistryVersion)) {
+    issues.push({ path: "theme.metadata.compatibility.minRegistryVersion", message: "Expected semver format like 1.0.0" });
+  }
+  return issues;
+}
+function isThemeTokensV2(tokens) {
+  return isRecord(tokens) && "colors" in tokens && "surface" in tokens && "text" in tokens && "border" in tokens;
+}
+function validateLegacyTokens(tokens, modePath) {
+  const issues = [];
+  for (const key of LEGACY_REQUIRED_KEYS) {
+    if (!(key in tokens)) {
+      issues.push({ path: `${modePath}.${key}`, message: "Missing required token" });
+    }
+  }
+  for (const [key, value] of Object.entries(tokens)) {
+    if (!LEGACY_ALLOWED_KEYS.includes(key)) {
+      issues.push({ path: `${modePath}.${key}`, message: "Unknown token property" });
+      continue;
+    }
+    if (typeof value !== "string" || !isLikelyColor(value)) {
+      issues.push({ path: `${modePath}.${key}`, message: "Invalid color value" });
+    }
+  }
+  return issues;
+}
+function validateSemanticTokens(tokens, modePath) {
+  const issues = [];
+  for (const category of Object.keys(SEMANTIC_SCHEMA)) {
+    if (!(category in tokens)) {
+      issues.push({ path: `${modePath}.${category}`, message: "Missing required category" });
+      continue;
+    }
+    const categoryValue = tokens[category];
+    if (!isRecord(categoryValue)) {
+      issues.push({ path: `${modePath}.${category}`, message: "Category must be an object" });
+      continue;
+    }
+    const requiredKeys = SEMANTIC_SCHEMA[category];
+    for (const key of requiredKeys) {
+      if (!(key in categoryValue)) {
+        issues.push({ path: `${modePath}.${category}.${key}`, message: "Missing required token" });
+      }
+    }
+    for (const [key, value] of Object.entries(categoryValue)) {
+      if (!requiredKeys.includes(key)) {
+        issues.push({ path: `${modePath}.${category}.${key}`, message: "Unknown token property" });
+        continue;
+      }
+      if (typeof value !== "string" || !isLikelyColor(value)) {
+        issues.push({ path: `${modePath}.${category}.${key}`, message: "Invalid color value" });
+      }
+    }
+  }
+  for (const key of Object.keys(tokens)) {
+    if (!(key in SEMANTIC_SCHEMA)) {
+      issues.push({ path: `${modePath}.${key}`, message: "Unknown category" });
+    }
+  }
+  return issues;
+}
+function validateTheme(theme) {
+  const issues = [];
+  if (!theme.name || !theme.name.trim()) {
+    issues.push({ path: "theme.name", message: "Theme name is required" });
+  }
+  issues.push(...validateMetadata(theme.metadata));
+  if (!isRecord(theme.modes) || Object.keys(theme.modes).length === 0) {
+    issues.push({ path: "theme.modes", message: "At least one mode is required" });
+    return { valid: issues.length === 0, issues };
+  }
+  for (const [modeName, tokens] of Object.entries(theme.modes)) {
+    const modePath = `theme.modes.${modeName}`;
+    if (!isRecord(tokens)) {
+      issues.push({ path: modePath, message: "Mode tokens must be an object" });
+      continue;
+    }
+    if (isThemeTokensV2(tokens)) {
+      issues.push(...validateSemanticTokens(tokens, modePath));
+    } else {
+      issues.push(...validateLegacyTokens(tokens, modePath));
+    }
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+function mergeTokenSets(existing, incoming) {
+  if (isThemeTokensV2(existing) && isThemeTokensV2(incoming)) {
+    return {
+      colors: { ...existing.colors, ...incoming.colors },
+      surface: { ...existing.surface, ...incoming.surface },
+      text: { ...existing.text, ...incoming.text },
+      border: { ...existing.border, ...incoming.border }
+    };
+  }
+  return { ...existing, ...incoming };
+}
+function mergePlugins(existing, incoming) {
+  return {
+    ...existing,
+    ...incoming,
+    icons: { ...existing.icons ?? {}, ...incoming.icons ?? {} },
+    fonts: { ...existing.fonts ?? {}, ...incoming.fonts ?? {} },
+    spacing: { ...existing.spacing ?? {}, ...incoming.spacing ?? {} },
+    typography: { ...existing.typography ?? {}, ...incoming.typography ?? {} },
+    metadata: { ...existing.metadata ?? {}, ...incoming.metadata ?? {} }
+  };
+}
+function toPluginContributions(plugin) {
+  return {
+    icons: { ...plugin.icons ?? {} },
+    fonts: { ...plugin.fonts ?? {} },
+    spacing: { ...plugin.spacing ?? {} },
+    typography: { ...plugin.typography ?? {} },
+    metadata: { ...plugin.metadata ?? {} }
+  };
+}
+function mergePluginContributions(target, source) {
+  return {
+    icons: { ...target.icons, ...source.icons },
+    fonts: { ...target.fonts, ...source.fonts },
+    spacing: { ...target.spacing, ...source.spacing },
+    typography: { ...target.typography, ...source.typography },
+    metadata: { ...target.metadata, ...source.metadata }
+  };
+}
+function createEmptyContributions() {
+  return {
+    icons: {},
+    fonts: {},
+    spacing: {},
+    typography: {},
+    metadata: {}
+  };
+}
+function createCompositionLayerMaps() {
+  return {
+    brand: /* @__PURE__ */ new Map(),
+    appearance: /* @__PURE__ */ new Map(),
+    accessibility: /* @__PURE__ */ new Map()
+  };
+}
+function normalizeLoadedThemes(payload) {
+  return Array.isArray(payload) ? payload : [payload];
+}
+function tokenSetToCssVariables(tokens) {
+  const variables = {};
+  if (isThemeTokensV2(tokens)) {
+    const appendCategory = (category, categoryValues) => {
+      ;
+      Object.entries(categoryValues).forEach(([key, value]) => {
+        const keyName = String(key);
+        variables[`--theme-${category}-${keyName}`] = value;
+        if (category === "colors") {
+          variables[`--color-theme-${keyName}`] = value;
+        }
+      });
+    };
+    appendCategory("colors", tokens.colors);
+    appendCategory("surface", tokens.surface);
+    appendCategory("text", tokens.text);
+    appendCategory("border", tokens.border);
+    return variables;
+  }
+  Object.entries(tokens).forEach(([key, value]) => {
+    if (key === "tertiary" && !value) return;
+    variables[`--color-theme-${key}`] = value;
+  });
+  return variables;
+}
+function isCacheEntryFresh(entry, maxAgeMs) {
+  if (typeof maxAgeMs !== "number") return true;
+  return Date.now() - entry.loadedAt <= maxAgeMs;
+}
+var ThemeRegistry = class {
+  constructor() {
+    this.themes = /* @__PURE__ */ new Map();
+    this.plugins = /* @__PURE__ */ new Map();
+    this.compositionLayers = createCompositionLayerMaps();
+    this.loadedThemeCache = /* @__PURE__ */ new Map();
+    this.currentTheme = null;
+    this.currentMode = null;
+    this.fallbackConfig = {};
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  getVersion() {
+    return RUNTIME_THEME_REGISTRY_VERSION;
+  }
+  on(event, handler) {
+    const existing = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    existing.add(handler);
+    this.listeners.set(event, existing);
+    return () => {
+      existing.delete(handler);
+      if (existing.size === 0) {
+        this.listeners.delete(event);
+      }
+    };
+  }
+  onRegistered(handler) {
+    return this.on("registered", handler);
+  }
+  onThemeChanged(handler) {
+    return this.on("themeChanged", handler);
+  }
+  onVariantAdded(handler) {
+    return this.on("variantAdded", handler);
+  }
+  onDestroyed(handler) {
+    return this.on("destroyed", handler);
+  }
+  onLoaded(handler) {
+    return this.on("loaded", handler);
+  }
+  onComposed(handler) {
+    return this.on("composed", handler);
+  }
+  emit(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (!handlers) return;
+    handlers.forEach((handler) => {
+      ;
+      handler(payload);
+    });
+  }
+  register(theme, options = {}) {
+    const ifExists = options.ifExists ?? "throw";
+    const shouldValidate = options.validate ?? true;
+    assertCompatibility(theme.metadata?.compatibility?.minRegistryVersion, `Theme "${theme.name}"`);
+    if (shouldValidate) {
+      const validation = validateTheme(theme);
+      if (!validation.valid) {
+        const details = validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n");
+        throw new Error(`Theme "${theme.name}" failed validation:
+${details}`);
+      }
+    }
+    const exists = this.themes.has(theme.name);
+    if (!exists) {
+      this.themes.set(theme.name, theme);
+      this.emit("registered", { themeName: theme.name });
+      return;
+    }
+    if (ifExists === "throw") {
+      throw new Error(`Theme "${theme.name}" already exists`);
+    }
+    if (ifExists === "replace") {
+      this.themes.set(theme.name, theme);
+      this.emit("replaced", { themeName: theme.name });
+      return;
+    }
+    const existing = this.themes.get(theme.name);
+    if (!existing) {
+      this.themes.set(theme.name, theme);
+      this.emit("registered", { themeName: theme.name });
+      return;
+    }
+    const mergedModes = { ...existing.modes };
+    for (const [modeName, tokens] of Object.entries(theme.modes)) {
+      if (mergedModes[modeName]) {
+        mergedModes[modeName] = mergeTokenSets(mergedModes[modeName], tokens);
+      } else {
+        mergedModes[modeName] = tokens;
+      }
+    }
+    this.themes.set(theme.name, {
+      ...existing,
+      ...theme,
+      metadata: { ...existing.metadata ?? {}, ...theme.metadata ?? {} },
+      modes: mergedModes
+    });
+    this.emit("merged", { themeName: theme.name });
+  }
+  replace(themeName, theme) {
+    if (themeName !== theme.name) {
+      throw new Error("replace() requires matching themeName and theme.name");
+    }
+    this.register(theme, { ifExists: "replace" });
+  }
+  merge(themeName, theme) {
+    if (themeName !== theme.name) {
+      throw new Error("merge() requires matching themeName and theme.name");
+    }
+    this.register(theme, { ifExists: "merge" });
+  }
+  unregister(themeName) {
+    const removed = this.themes.delete(themeName);
+    if (removed) {
+      this.emit("unregistered", { themeName });
+    }
+    if (removed && this.currentTheme === themeName) {
+      this.currentTheme = null;
+      this.currentMode = null;
+    }
+    return removed;
+  }
+  setFallback(config) {
+    this.fallbackConfig = { ...this.fallbackConfig, ...config };
+  }
+  registerPlugin(plugin, options = {}) {
+    const ifExists = options.ifExists ?? "throw";
+    const themeIfExists = options.themeIfExists ?? "merge";
+    const validateThemes = options.validateThemes ?? true;
+    assertCompatibility(plugin.minRegistryVersion, `Plugin "${plugin.name}"`);
+    const exists = this.plugins.has(plugin.name);
+    if (exists && ifExists === "throw") {
+      throw new Error(`Plugin "${plugin.name}" already exists`);
+    }
+    let pluginToStore = plugin;
+    if (exists && ifExists === "merge") {
+      const existing = this.plugins.get(plugin.name);
+      if (existing) {
+        pluginToStore = mergePlugins(existing, plugin);
+      }
+    }
+    this.plugins.set(plugin.name, pluginToStore);
+    const pluginThemes = [
+      ...pluginToStore.theme ? [pluginToStore.theme] : [],
+      ...pluginToStore.themes ?? []
+    ];
+    for (const theme of pluginThemes) {
+      this.register(theme, { ifExists: themeIfExists, validate: validateThemes });
+    }
+    this.emit("pluginRegistered", { pluginName: plugin.name });
+  }
+  registerCompositionLayer(layer, options = {}) {
+    const targetMap = this.compositionLayers[layer.type];
+    const ifExists = options.ifExists ?? "throw";
+    const exists = targetMap.has(layer.name);
+    if (exists && ifExists === "throw") {
+      throw new Error(`Composition layer "${layer.type}:${layer.name}" already exists`);
+    }
+    if (exists && ifExists === "merge") {
+      const existing = targetMap.get(layer.name);
+      if (existing) {
+        targetMap.set(layer.name, {
+          ...existing,
+          ...layer,
+          metadata: { ...existing.metadata ?? {}, ...layer.metadata ?? {} },
+          tokens: mergeTokenSets(existing.tokens, layer.tokens)
+        });
+        return;
+      }
+    }
+    targetMap.set(layer.name, layer);
+  }
+  getCompositionLayer(type, name) {
+    return this.compositionLayers[type].get(name);
+  }
+  getCompositionLayers(type) {
+    if (type) {
+      return Array.from(this.compositionLayers[type].values());
+    }
+    return [
+      ...Array.from(this.compositionLayers.brand.values()),
+      ...Array.from(this.compositionLayers.appearance.values()),
+      ...Array.from(this.compositionLayers.accessibility.values())
+    ];
+  }
+  compose(selection) {
+    const appliedLayers = [];
+    let composedTokens = null;
+    const resolutionOrder = [
+      ["brand", selection.brand],
+      ["appearance", selection.appearance],
+      ["accessibility", selection.accessibility]
+    ];
+    resolutionOrder.forEach(([type, layerName]) => {
+      if (!layerName) return;
+      const layer = this.compositionLayers[type].get(layerName);
+      if (!layer) return;
+      appliedLayers.push(layer);
+      composedTokens = composedTokens ? mergeTokenSets(composedTokens, layer.tokens) : layer.tokens;
+    });
+    this.emit("composed", {
+      appliedLayers: appliedLayers.map((layer) => `${layer.type}:${layer.name}`)
+    });
+    return {
+      selection,
+      tokens: composedTokens,
+      appliedLayers
+    };
+  }
+  getInitialThemeAttributes(themeName, modeName) {
+    const resolved = this.resolveSelection(themeName, modeName);
+    if (!resolved.themeName || !resolved.modeName) return null;
+    return {
+      "data-theme": resolved.themeName,
+      "data-mode": resolved.modeName
+    };
+  }
+  hydrateThemeOnDocument(themeName, modeName) {
+    const resolved = this.resolveSelection(themeName, modeName);
+    if (!resolved.themeName || !resolved.modeName || !resolved.tokens) {
+      return resolved;
+    }
+    if (typeof document !== "undefined") {
+      document.documentElement.setAttribute("data-theme", resolved.themeName);
+      document.documentElement.setAttribute("data-mode", resolved.modeName);
+      const cssVariables = tokenSetToCssVariables(resolved.tokens);
+      Object.entries(cssVariables).forEach(([name, value]) => {
+        document.documentElement.style.setProperty(name, value);
+      });
+    }
+    this.currentTheme = resolved.themeName;
+    this.currentMode = resolved.modeName;
+    this.emit("themeChanged", { themeName: resolved.themeName, modeName: resolved.modeName });
+    return resolved;
+  }
+  async load(source, options = {}) {
+    const ifExists = options.ifExists ?? "merge";
+    const validate = options.validate ?? true;
+    const cacheKey = options.cacheKey ?? (typeof source === "string" ? source : void 0);
+    const forceRefresh = options.forceRefresh ?? false;
+    const maxAgeMs = options.maxAgeMs;
+    if (cacheKey && !forceRefresh && this.loadedThemeCache.has(cacheKey)) {
+      const entry = this.loadedThemeCache.get(cacheKey);
+      if (entry && isCacheEntryFresh(entry, maxAgeMs)) {
+        const names2 = entry.themes.map((theme) => theme.name);
+        this.emit("loaded", {
+          source: entry.source,
+          count: names2.length,
+          fromCache: true
+        });
+        return {
+          loaded: names2.length,
+          themes: names2,
+          source: entry.source,
+          fromCache: true
+        };
+      }
+    }
+    let loadedThemes = [];
+    if (typeof source === "string") {
+      const response = await fetch(source);
+      if (!response.ok) {
+        throw new Error(`Failed to load themes from ${source}: ${response.status} ${response.statusText}`);
+      }
+      const payload = await response.json();
+      loadedThemes = normalizeLoadedThemes(payload);
+    } else {
+      const payload = await source();
+      loadedThemes = normalizeLoadedThemes(payload);
+    }
+    const names = [];
+    loadedThemes.forEach((theme) => {
+      this.register(theme, { ifExists, validate });
+      names.push(theme.name);
+    });
+    const sourceName = typeof source === "string" ? source : "loader";
+    if (cacheKey) {
+      this.loadedThemeCache.set(cacheKey, {
+        themes: loadedThemes,
+        loadedAt: Date.now(),
+        source: sourceName
+      });
+    }
+    this.emit("loaded", {
+      source: sourceName,
+      count: names.length,
+      fromCache: false
+    });
+    return {
+      loaded: names.length,
+      themes: names,
+      source: sourceName,
+      fromCache: false
+    };
+  }
+  clearLoadCache(cacheKey) {
+    if (cacheKey) {
+      this.loadedThemeCache.delete(cacheKey);
+      return;
+    }
+    this.loadedThemeCache.clear();
+  }
+  unregisterPlugin(pluginName) {
+    const removed = this.plugins.delete(pluginName);
+    if (removed) {
+      this.emit("pluginUnregistered", { pluginName });
+    }
+    return removed;
+  }
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+  getPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  getPluginContributions(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) return void 0;
+    return toPluginContributions(plugin);
+  }
+  getMergedPluginContributions() {
+    let merged = createEmptyContributions();
+    this.plugins.forEach((plugin) => {
+      merged = mergePluginContributions(merged, toPluginContributions(plugin));
+    });
+    return merged;
+  }
+  /**
+   * Dynamically register a theme mode - useful for packages to add their own modes
+   * @param themeName - The name of the existing theme to add the mode to
+   * @param modeName - The name of the mode (e.g., 'ocean', 'forest', 'high-contrast')
+   * @param tokens - The tokens for this mode
+   */
+  registerMode(themeName, modeName, tokens) {
+    const theme = this.themes.get(themeName);
+    if (!theme) {
+      throw new Error(`Theme "${themeName}" not found. Register the theme first with themeRegistry.register(theme)`);
+    }
+    theme.modes[modeName] = tokens;
+    const validation = validateTheme(theme);
+    if (!validation.valid) {
+      delete theme.modes[modeName];
+      const details = validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n");
+      throw new Error(`Invalid mode "${modeName}" for theme "${themeName}":
+${details}`);
+    }
+    this.emit("variantAdded", { themeName, variantName: modeName });
+  }
+  /**
+   * Register multiple modes at once for a theme
+   */
+  registerModes(themeName, modes) {
+    const theme = this.themes.get(themeName);
+    if (!theme) {
+      throw new Error(`Theme "${themeName}" not found. Register the theme first with themeRegistry.register(theme)`);
+    }
+    const originalModes = { ...theme.modes };
+    Object.assign(theme.modes, modes);
+    const validation = validateTheme(theme);
+    if (!validation.valid) {
+      theme.modes = originalModes;
+      const details = validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n");
+      throw new Error(`Invalid modes for theme "${themeName}":
+${details}`);
+    }
+    Object.keys(modes).forEach((modeName) => {
+      this.emit("variantAdded", { themeName, variantName: modeName });
+    });
+  }
+  /**
+   * Create and register a new theme with specific modes
+   * Useful for packages that want to add their own themes dynamically
+   */
+  createTheme(name, modes) {
+    const theme = { name, modes };
+    this.register(theme);
+  }
+  getFallbackThemeName() {
+    if (this.fallbackConfig.themeName && this.themes.has(this.fallbackConfig.themeName)) {
+      return this.fallbackConfig.themeName;
+    }
+    const firstTheme = this.themes.keys().next().value;
+    return firstTheme ?? null;
+  }
+  resolveModeName(theme, requestedMode) {
+    if (requestedMode && theme.modes[requestedMode]) {
+      return requestedMode;
+    }
+    if (this.fallbackConfig.modeName && theme.modes[this.fallbackConfig.modeName]) {
+      return this.fallbackConfig.modeName;
+    }
+    const firstMode = Object.keys(theme.modes)[0];
+    return firstMode ?? null;
+  }
+  resolveSelection(themeName, modeName) {
+    const effectiveThemeName = themeName && this.themes.has(themeName) ? themeName : this.getFallbackThemeName();
+    if (!effectiveThemeName) {
+      return { themeName: null, modeName: null, tokens: null };
+    }
+    const theme = this.themes.get(effectiveThemeName);
+    if (!theme) {
+      return { themeName: null, modeName: null, tokens: null };
+    }
+    const effectiveModeName = this.resolveModeName(theme, modeName);
+    if (!effectiveModeName) {
+      return { themeName: theme.name, modeName: null, tokens: null };
+    }
+    return {
+      themeName: theme.name,
+      modeName: effectiveModeName,
+      tokens: theme.modes[effectiveModeName] ?? null
+    };
+  }
+  get(name) {
+    return this.themes.get(name);
+  }
+  getAll() {
+    return Array.from(this.themes.values());
+  }
+  getTokens(themeName, modeName) {
+    const theme = this.themes.get(themeName);
+    return theme?.modes[modeName];
+  }
+  setCurrent(themeName, modeName) {
+    const resolved = this.resolveSelection(themeName, modeName);
+    if (!resolved.themeName || !resolved.modeName) {
+      throw new Error(`No valid theme selection for "${themeName}" and mode "${modeName}"`);
+    }
+    this.currentTheme = resolved.themeName;
+    this.currentMode = resolved.modeName;
+    this.emit("themeChanged", { themeName: resolved.themeName, modeName: resolved.modeName });
+  }
+  getCurrent() {
+    return {
+      theme: this.currentTheme,
+      mode: this.currentMode
+    };
+  }
+  has(themeName) {
+    return this.themes.has(themeName);
+  }
+  getModes(themeName) {
+    const theme = this.themes.get(themeName);
+    return theme ? Object.keys(theme.modes) : [];
+  }
+  getVariants(themeName) {
+    return this.getModes(themeName);
+  }
+  destroy() {
+    this.themes.clear();
+    this.plugins.clear();
+    this.compositionLayers = createCompositionLayerMaps();
+    this.loadedThemeCache.clear();
+    this.currentTheme = null;
+    this.currentMode = null;
+    this.fallbackConfig = {};
+    this.emit("destroyed", { timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    this.listeners.clear();
+  }
+};
+var themeRegistry = new ThemeRegistry();
+
+// app_theme.ts
+var fnpTheme = {
+  name: "fnp",
+  modes: {
+    light: {
+      primary: "#031011",
+      secondary: "#153e46",
+      tertiary: "#378d93",
+      background: "#ffffff",
+      text: "#031011",
+      accent: "#378d93",
+      muted: "#667085",
+      error: "#DF1C41",
+      warning: "#F4C790",
+      success: "#27AE60",
+      info: "#378d93"
+    },
+    dark: {
+      primary: "#c4e8ee",
+      secondary: "#378d93",
+      tertiary: "#153e46",
+      background: "#031011",
+      text: "#c4e8ee",
+      accent: "#378d93",
+      muted: "#667085",
+      error: "#DF1C41",
+      warning: "#F4C790",
+      success: "#27AE60",
+      info: "#378d93"
+    }
+  }
+};
+themeRegistry.register(fnpTheme);
+
+export {
+  RUNTIME_THEME_REGISTRY_VERSION,
+  isThemeTokensV2,
+  validateTheme,
+  themeRegistry
+};
+//# sourceMappingURL=chunk-GUPUN2GN.js.map