@shohojdhara/atomix 0.3.4 → 0.3.6

package/src/lib/theme/config/configLoader.ts

@@ -0,0 +1,254 @@
+/**
+ * Config Loader
+ * 
+ * Load design tokens from atomix.config.ts and convert to flat token format.
+ */
+
+import type { DesignTokens } from '../tokens/tokens';
+import type { AtomixConfig, ThemeTokens } from '../../config';
+
+/**
+ * Convert nested config tokens to flat DesignTokens format
+ * 
+ * Handles conversion from atomix.config.ts structure to flat tokens.
+ * Maps config structure to actual DesignTokens key names.
+ */
+function flattenConfigTokens(
+  tokens: ThemeTokens,
+  prefix: string = 'atomix'
+): Partial<DesignTokens> {
+  const flat: Partial<DesignTokens> = {};
+
+  // Colors
+  if (tokens.colors) {
+    Object.entries(tokens.colors).forEach(([key, value]) => {
+      if (typeof value === 'string') {
+        // Simple color: 'primary': '#7AFFD7'
+        // Map directly to DesignTokens keys (e.g., 'primary', 'secondary', 'error')
+        // Only map if it's a valid semantic color key
+        if (['primary', 'secondary', 'success', 'info', 'warning', 'error', 'light', 'dark'].includes(key)) {
+          flat[key as keyof DesignTokens] = value;
+        }
+      } else if (value && typeof value === 'object') {
+        // Color scale or palette
+        if ('main' in value) {
+          // PaletteColorOptions: { main: '#7AFFD7', light?: '#...', dark?: '#...' }
+          const palette = value as { main: string; light?: string; dark?: string };
+          const baseKey = key as keyof DesignTokens;
+          
+          // Map main to base color (e.g., primary, secondary, error)
+          if (['primary', 'secondary', 'success', 'info', 'warning', 'error', 'light', 'dark'].includes(key)) {
+            flat[baseKey] = palette.main;
+            
+            // Map light/dark to appropriate scale values
+            // light typically maps to step 3, dark to step 9
+            if (palette.light) {
+              flat[`${key}-3` as keyof DesignTokens] = palette.light;
+            }
+            if (palette.dark) {
+              flat[`${key}-9` as keyof DesignTokens] = palette.dark;
+            }
+          }
+        } else {
+          // Color scale: { 1: '#fff', 2: '#eee', ..., 6: '#main', ... }
+          // Or full scale: { 1: '#...', 2: '#...', ..., 10: '#...' }
+          Object.entries(value).forEach(([scaleKey, scaleValue]) => {
+            if (typeof scaleValue === 'string') {
+              // Map scale keys to DesignTokens format
+              if (scaleKey === 'main' || scaleKey === '6') {
+                // Main color maps to base key (e.g., 'primary')
+                if (['primary', 'secondary', 'success', 'info', 'warning', 'error', 'light', 'dark'].includes(key)) {
+                  flat[key as keyof DesignTokens] = scaleValue;
+                }
+                // Also map to step 6 if it's a scale color
+                if (['primary', 'red', 'green', 'blue', 'yellow', 'gray'].includes(key)) {
+                  flat[`${key}-6` as keyof DesignTokens] = scaleValue;
+                }
+              } else {
+                // Map scale numbers (1-10) to DesignTokens format
+                const scaleNum = parseInt(scaleKey, 10);
+                if (!isNaN(scaleNum) && scaleNum >= 1 && scaleNum <= 10) {
+                  flat[`${key}-${scaleKey}` as keyof DesignTokens] = scaleValue;
+                }
+              }
+            }
+          });
+        }
+      }
+    });
+  }
+
+  // Spacing
+  if (tokens.spacing) {
+    Object.entries(tokens.spacing).forEach(([key, value]) => {
+      flat[`spacing-${key}` as keyof DesignTokens] = String(value);
+    });
+  }
+
+  // Border Radius
+  if (tokens.borderRadius) {
+    Object.entries(tokens.borderRadius).forEach(([key, value]) => {
+      // Map to DesignTokens format
+      if (key === 'sm' || key === 'base' || key === '') {
+        flat['border-radius-sm' as keyof DesignTokens] = String(value);
+      } else if (key === 'md' || key === 'default') {
+        flat['border-radius' as keyof DesignTokens] = String(value);
+      } else if (key === 'lg') {
+        flat['border-radius-lg' as keyof DesignTokens] = String(value);
+      } else {
+        flat[`border-radius-${key}` as keyof DesignTokens] = String(value);
+      }
+    });
+  }
+
+  // Typography
+  if (tokens.typography) {
+    // Font Families
+    if (tokens.typography.fontFamilies) {
+      Object.entries(tokens.typography.fontFamilies).forEach(([key, value]) => {
+        // Map to DesignTokens format
+        if (key === 'sans' || key === 'base') {
+          flat['font-sans-serif' as keyof DesignTokens] = String(value);
+          flat['body-font-family' as keyof DesignTokens] = String(value);
+        } else if (key === 'mono') {
+          flat['font-monospace' as keyof DesignTokens] = String(value);
+        } else {
+          flat[`font-family-${key}` as keyof DesignTokens] = String(value);
+        }
+      });
+    }
+
+    // Font Sizes
+    if (tokens.typography.fontSizes) {
+      Object.entries(tokens.typography.fontSizes).forEach(([key, value]) => {
+        flat[`font-size-${key}` as keyof DesignTokens] = String(value);
+      });
+    }
+
+    // Font Weights
+    if (tokens.typography.fontWeights) {
+      Object.entries(tokens.typography.fontWeights).forEach(([key, value]) => {
+        flat[`font-weight-${key}` as keyof DesignTokens] = String(value);
+      });
+    }
+
+    // Line Heights
+    if (tokens.typography.lineHeights) {
+      Object.entries(tokens.typography.lineHeights).forEach(([key, value]) => {
+        if (key === 'base' || key === 'default') {
+          flat['line-height-base' as keyof DesignTokens] = String(value);
+        } else {
+          flat[`line-height-${key}` as keyof DesignTokens] = String(value);
+        }
+      });
+    }
+  }
+
+  // Shadows
+  if (tokens.shadows) {
+    Object.entries(tokens.shadows).forEach(([key, value]) => {
+      flat[`shadow-${key}` as keyof DesignTokens] = String(value);
+    });
+  }
+
+  // Z-Index
+  if (tokens.zIndex) {
+    Object.entries(tokens.zIndex).forEach(([key, value]) => {
+      flat[`z-index-${key}` as keyof DesignTokens] = String(value);
+    });
+  }
+
+  // Transitions
+  if (tokens.transitions) {
+    if (tokens.transitions.durations) {
+      Object.entries(tokens.transitions.durations).forEach(([key, value]) => {
+        flat[`transition-${key}` as keyof DesignTokens] = String(value);
+      });
+    }
+  }
+
+  return flat;
+}
+
+/**
+ * Load theme tokens from atomix.config.ts
+ * 
+ * Loads atomix.config.ts and extracts theme tokens.
+ * Config file is required - throws error if not found.
+ * 
+ * @param configPath - Optional custom config path (default: 'atomix.config.ts')
+ * @returns Partial DesignTokens from config
+ * @throws Error if config file is not found or cannot be loaded
+ * 
+ * @example
+ * ```typescript
+ * const tokens = await loadThemeFromConfig();
+ * const css = createTheme(tokens);
+ * injectTheme(css);
+ * ```
+ */
+export async function loadThemeFromConfig(
+  configPath: string = 'atomix.config.ts'
+): Promise<Partial<DesignTokens>> {
+  // In browser environments, config loading is not supported
+  if (typeof window !== 'undefined') {
+    throw new Error('loadThemeFromConfig: Not available in browser environment. Config loading requires Node.js/SSR environment.');
+  }
+
+  // Load config using the existing loader (required)
+  const { loadAtomixConfig } = await import('../../config/loader');
+  const config = loadAtomixConfig({ configPath, required: true });
+
+  if (!config || !config.theme) {
+    throw new Error(`Config file ${configPath} does not contain theme configuration.`);
+  }
+
+  // Extract tokens from config
+  const tokens = config.theme.tokens || config.theme.extend || {};
+
+  if (Object.keys(tokens).length === 0) {
+    throw new Error(`Config file ${configPath} has empty theme configuration.`);
+  }
+
+  // Convert nested structure to flat tokens
+  return flattenConfigTokens(tokens, config.prefix || 'atomix');
+}
+
+/**
+ * Load theme tokens from atomix.config.ts (synchronous version)
+ * 
+ * Synchronous version that uses require() instead of dynamic import.
+ * Only works in Node.js environment.
+ * Config file is required - throws error if not found.
+ * 
+ * @param configPath - Optional custom config path
+ * @returns Partial DesignTokens from config
+ * @throws Error if config file is not found or cannot be loaded
+ */
+export function loadThemeFromConfigSync(
+  configPath: string = 'atomix.config.ts'
+): Partial<DesignTokens> {
+  // In browser environments, config loading is not supported
+  if (typeof window !== 'undefined') {
+    throw new Error('loadThemeFromConfigSync: Not available in browser environment. Config loading requires Node.js/SSR environment.');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { loadAtomixConfig } = require('../../config/loader');
+  const config = loadAtomixConfig({ configPath, required: true });
+
+  if (!config || !config.theme) {
+    throw new Error(`Config file ${configPath} does not contain theme configuration.`);
+  }
+
+  // Extract tokens from config
+  const tokens = config.theme.tokens || config.theme.extend || {};
+
+  if (Object.keys(tokens).length === 0) {
+    throw new Error(`Config file ${configPath} has empty theme configuration.`);
+  }
+
+  // Convert nested structure to flat tokens
+  return flattenConfigTokens(tokens, config.prefix || 'atomix');
+}
+

package/src/lib/theme/config/loader.ts

@@ -1,7 +1,7 @@
 /**
  * Theme Configuration Loader
  * 
- * Loads and validates the theme configuration from theme.config.ts
+ * Loads and validates the theme configuration from atomix.config.ts
  */
 
 import type {
@@ -10,12 +10,10 @@ import type {
   ConfigValidationResult,
 } from './types';
 import { validateConfig } from './validator';
-import { ThemeError, ThemeErrorCode, getLogger } from '../errors';
+import { ThemeError, ThemeErrorCode, getLogger } from '../errors/errors';
 import {
-  DEFAULT_CONFIG_PATH,
   DEFAULT_ATOMIX_CONFIG_PATH,
   DEFAULT_CONFIG_RELATIVE_PATH,
-  DEFAULT_LEGACY_CONFIG_RELATIVE_PATH,
   DEFAULT_BASE_PATH,
   DEFAULT_STORAGE_KEY,
   DEFAULT_DATA_ATTRIBUTE,
@@ -24,7 +22,7 @@ import {
   DEFAULT_BUILD_OUTPUT_DIR,
   DEFAULT_SASS_CONFIG,
   ENV_DEFAULTS,
-} from '../constants';
+} from '../constants/constants';
 
 /**
  * Cache for loaded configuration
@@ -37,7 +35,7 @@ let cachedConfig: LoadedThemeConfig | null = null;
 const logger = getLogger();
 
 /**
- * Load theme configuration from theme.config.ts
+ * Load theme configuration from atomix.config.ts
  * 
  * @param options - Loader options
  * @returns Loaded and validated theme configuration
@@ -97,30 +95,25 @@ export function loadThemeConfig(
       try {
         configModule = nodeRequire(DEFAULT_CONFIG_RELATIVE_PATH) as ConfigModule;
       } catch {
-        // Try fallback to legacy relative path
-        try {
-          configModule = nodeRequire(DEFAULT_LEGACY_CONFIG_RELATIVE_PATH) as ConfigModule;
-        } catch {
-          // If relative paths fail, try to resolve from process.cwd()
-          const path = nodeRequire('path') as typeof import('path');
-          const fs = nodeRequire('fs') as typeof import('fs');
+        // If relative path fails, try to resolve from process.cwd()
+        const path = nodeRequire('path') as typeof import('path');
+        const fs = nodeRequire('fs') as typeof import('fs');
 
-          let configFilePath = path.resolve(process.cwd(), configPath);
+        let configFilePath = path.resolve(process.cwd(), configPath);
 
-          // Fallback if atomix.config.ts not found
-          if (!fs.existsSync(configFilePath) && configPath === DEFAULT_ATOMIX_CONFIG_PATH) {
-            configFilePath = path.resolve(process.cwd(), DEFAULT_CONFIG_PATH);
-          }
+        // If atomix.config.ts not found at the root, use the default path
+        if (!fs.existsSync(configFilePath) && configPath === DEFAULT_ATOMIX_CONFIG_PATH) {
+          configFilePath = path.resolve(process.cwd(), DEFAULT_ATOMIX_CONFIG_PATH);
+        }
 
-          if (fs.existsSync(configFilePath)) {
-            const resolvedPath = nodeRequire.resolve(configFilePath);
-            if (nodeRequire.cache && nodeRequire.cache[resolvedPath]) {
-              delete nodeRequire.cache[resolvedPath];
-            }
-            configModule = nodeRequire(configFilePath) as ConfigModule;
-          } else {
-            throw new Error(`Config file not found: ${configFilePath}`);
+        if (fs.existsSync(configFilePath)) {
+          const resolvedPath = nodeRequire.resolve(configFilePath);
+          if (nodeRequire.cache && nodeRequire.cache[resolvedPath]) {
+            delete nodeRequire.cache[resolvedPath];
           }
+          configModule = nodeRequire(configFilePath) as ConfigModule;
+        } else {
+          throw new Error(`Config file not found: ${configFilePath}`);
         }
       }
     } catch (requireError) {
@@ -136,36 +129,30 @@ export function loadThemeConfig(
 
     const rawConfig = configModule.default || configModule;
 
-    // Handle new AtomixConfig structure vs legacy ThemeConfig
-    let processedConfig: any;
-    if (rawConfig.theme && (rawConfig.theme.themes || rawConfig.theme.tokens || rawConfig.theme.extend)) {
-      // New AtomixConfig structure
-      processedConfig = {
-        themes: rawConfig.theme.themes || {},
-        build: rawConfig.build || {},
-        runtime: rawConfig.runtime || {},
-        integration: rawConfig.integration || {},
-        dependencies: rawConfig.dependencies || {},
-        // Store tokens for generator
-        __tokens: rawConfig.theme.tokens,
-        __extend: rawConfig.theme.extend,
-      };
-    } else {
-      // Legacy ThemeConfig structure
-      processedConfig = { ...rawConfig };
-    }
+    // Process the AtomixConfig structure
+    const processedConfig: LoadedThemeConfig = {
+      themes: rawConfig.theme?.themes || {},
+      build: rawConfig.build || {},
+      runtime: rawConfig.runtime || {},
+      integration: rawConfig.integration || {},
+      dependencies: rawConfig.dependencies || {},
+      validated: false, // Will be set after validation
+      // Store tokens for generator
+      __tokens: rawConfig.theme?.tokens,
+      __extend: rawConfig.theme?.extend,
+    };
 
     // Apply environment-specific overrides
-    processedConfig = applyEnvOverrides(processedConfig, env);
+    const finalConfig = applyEnvOverrides(processedConfig, env);
 
     // Validate if requested
     let validationResult: ConfigValidationResult | null = null;
     if (validate) {
-      validationResult = validateConfig(processedConfig);
+      validationResult = validateConfig(finalConfig);
     }
 
     config = {
-      ...processedConfig,
+      ...finalConfig,
       validated: validate,
       errors: validationResult?.errors,
       warnings: validationResult?.warnings,
@@ -212,6 +199,8 @@ export function loadThemeConfig(
       validated: false,
       errors: [`Failed to load config: ${error instanceof Error ? error.message : String(error)}`],
       warnings: [],
+      __tokens: {},
+      __extend: {},
     };
   }
 
@@ -307,4 +296,4 @@ export function reloadThemeConfig(
 ): LoadedThemeConfig {
   clearConfigCache();
   return loadThemeConfig(options);
-}
+}

package/src/lib/theme/config/types.ts

@@ -18,7 +18,7 @@ import type {
  * Configuration loader options
  */
 export interface ConfigLoaderOptions {
-  /** Path to theme config file (default: 'theme.config.ts') */
+  /** Path to theme config file (default: 'atomix.config.ts') */
   configPath?: string;
   /** Enable validation */
   validate?: boolean;
@@ -109,4 +109,4 @@ export type {
   BuildConfig,
   RuntimeConfig,
   IntegrationConfig,
-};
+};

package/src/lib/theme/config/validator.ts

@@ -4,13 +4,7 @@
  * Validates theme configuration structure and values
  */
 
-import type {
-  AtomixConfig,
-  ThemeDefinition,
-  CSSThemeDefinition,
-  JSThemeDefinition,
-  ConfigValidationResult,
-} from './types';
+import type { ConfigValidationResult } from './types';
 
 /**
  * Validate theme configuration
@@ -37,31 +31,25 @@ export function validateConfig(config: any): ConfigValidationResult {
     warnings.push(...themeErrors.warnings);
   }
 
-  // Validate build config
+  // Validate build config (only if provided)
   if (config.build) {
     const buildErrors = validateBuildConfig(config.build);
     errors.push(...buildErrors.errors);
     warnings.push(...buildErrors.warnings);
-  } else {
-    warnings.push('No build configuration provided, using defaults');
   }
 
-  // Validate runtime config
+  // Validate runtime config (only if provided)
   if (config.runtime) {
     const runtimeErrors = validateRuntimeConfig(config.runtime);
     errors.push(...runtimeErrors.errors);
     warnings.push(...runtimeErrors.warnings);
-  } else {
-    warnings.push('No runtime configuration provided, using defaults');
   }
 
-  // Validate integration config
+  // Validate integration config (only if provided)
   if (config.integration) {
     const integrationErrors = validateIntegrationConfig(config.integration);
     errors.push(...integrationErrors.errors);
     warnings.push(...integrationErrors.warnings);
-  } else {
-    warnings.push('No integration configuration provided, using defaults');
   }
 
   // Validate dependencies
@@ -127,23 +115,9 @@ function validateThemes(themes: Record<string, any>): ConfigValidationResult {
       warnings.push(...jsErrors.warnings);
     }
 
-    // Validate metadata
-    if (theme.version && !isValidSemver(theme.version)) {
-      warnings.push(`Theme "${themeId}" has invalid version format: ${theme.version}`);
-    }
-
-    if (theme.status && !['stable', 'beta', 'experimental', 'deprecated'].includes(theme.status)) {
-      warnings.push(`Theme "${themeId}" has invalid status: ${theme.status}`);
-    }
-
-    // Validate color format
-    if (theme.color && !isValidColor(theme.color)) {
-      warnings.push(`Theme "${themeId}" has invalid color format: ${theme.color}`);
-    }
-
-    // Validate accessibility
-    if (theme.a11y) {
-      if (theme.a11y.contrastTarget && (theme.a11y.contrastTarget < 1 || theme.a11y.contrastTarget > 21)) {
+    // Validate accessibility (only critical checks)
+    if (theme.a11y?.contrastTarget) {
+      if (typeof theme.a11y.contrastTarget !== 'number' || theme.a11y.contrastTarget < 1 || theme.a11y.contrastTarget > 21) {
         warnings.push(`Theme "${themeId}" has invalid contrast target: ${theme.a11y.contrastTarget}`);
       }
     }
@@ -187,23 +161,13 @@ function validateBuildConfig(build: any): ConfigValidationResult {
   const errors: string[] = [];
   const warnings: string[] = [];
 
-  if (!build.output || typeof build.output !== 'object') {
-    errors.push('Build config must have an "output" object');
-  } else {
-    if (!build.output.directory || typeof build.output.directory !== 'string') {
-      errors.push('Build output must have a "directory" string');
-    }
-    if (!build.output.formats || typeof build.output.formats !== 'object') {
-      errors.push('Build output must have a "formats" object');
-    }
+  // Only validate structure if provided
+  if (build.output && typeof build.output !== 'object') {
+    errors.push('Build output must be an object');
   }
 
-  if (!build.sass || typeof build.sass !== 'object') {
-    errors.push('Build config must have a "sass" object');
-  } else {
-    if (build.sass.style && !['expanded', 'compressed', 'compact', 'nested'].includes(build.sass.style)) {
-      warnings.push(`Invalid Sass style: ${build.sass.style}`);
-    }
+  if (build.sass && typeof build.sass !== 'object') {
+    errors.push('Build sass config must be an object');
   }
 
   return { valid: errors.length === 0, errors, warnings };
@@ -242,15 +206,9 @@ function validateIntegrationConfig(integration: any): ConfigValidationResult {
   const errors: string[] = [];
   const warnings: string[] = [];
 
-  if (!integration.classNames || typeof integration.classNames !== 'object') {
-    errors.push('Integration config must have a "classNames" object');
-  } else {
-    if (!integration.classNames.theme || typeof integration.classNames.theme !== 'string') {
-      errors.push('Integration classNames must have a "theme" string');
-    }
-    if (!integration.classNames.colorMode || typeof integration.classNames.colorMode !== 'string') {
-      errors.push('Integration classNames must have a "colorMode" string');
-    }
+  // Only validate structure if provided
+  if (integration.classNames && typeof integration.classNames !== 'object') {
+    errors.push('Integration classNames must be an object');
   }
 
   return { valid: errors.length === 0, errors, warnings };
@@ -290,37 +248,3 @@ function validateDependencies(
   return { valid: errors.length === 0, errors, warnings };
 }
 
-/**
- * Check if string is valid semver
- */
-function isValidSemver(version: string): boolean {
-  const semverRegex = /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/;
-  return semverRegex.test(version);
-}
-
-/**
- * Check if string is valid color
- */
-function isValidColor(color: string): boolean {
-  // Hex color
-  if (/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(color)) {
-    return true;
-  }
-  // RGB/RGBA
-  if (/^rgba?\(/.test(color)) {
-    return true;
-  }
-  // HSL/HSLA
-  if (/^hsla?\(/.test(color)) {
-    return true;
-  }
-  // Named colors (basic check)
-  const namedColors = [
-    'black', 'white', 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta',
-    'transparent', 'currentColor',
-  ];
-  if (namedColors.includes(color.toLowerCase())) {
-    return true;
-  }
-  return false;
-}

package/src/lib/theme/{constants.ts → constants/constants.ts}

@@ -24,14 +24,6 @@ export const DEFAULT_BASE_PATH = '/themes';
  */
 export const DEFAULT_STYLE_ID = 'atomix-js-theme-styles';
 
-/**
- * Default cache configuration
- */
-export const DEFAULT_CACHE_CONFIG = {
-  maxSize: 50,
-  ttl: 0, // No expiration by default
-} as const;
-
 /**
  * Default engine cache configuration
  */
@@ -58,21 +50,11 @@ export const CSS_EXTENSIONS = {
  */
 export const DEFAULT_ATOMIX_CONFIG_PATH = 'atomix.config.ts';
 
-/**
- * Default config file path (legacy)
- */
-export const DEFAULT_CONFIG_PATH = 'theme.config.ts';
-
 /**
  * Default config file path (relative)
  */
 export const DEFAULT_CONFIG_RELATIVE_PATH = '../../../../atomix.config';
 
-/**
- * Default legacy config file path (relative)
- */
-export const DEFAULT_LEGACY_CONFIG_RELATIVE_PATH = '../../../../theme.config';
-
 /**
  * Validation thresholds
  */

package/src/lib/theme/constants/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Theme Constants
+ * 
+ * System constants and default values
+ */
+
+export * from './constants';
+

package/src/lib/theme/core/ThemeRegistry.ts

@@ -71,6 +71,8 @@ export class ThemeRegistry {
           validated: false,
           errors: [],
           warnings: [],
+          __tokens: {},
+          __extend: {},
         };
       }
     } else {
@@ -160,23 +162,34 @@ export class ThemeRegistry {
   }
 
   /**
-   * Get theme object (for JS themes)
+   * Check if a theme is loaded
    */
-  getTheme(themeId: string): Theme | undefined {
-    return this.entries.get(themeId)?.theme;
+  isThemeLoaded(themeId: string): boolean {
+    const entry = this.entries.get(themeId);
+    return entry ? entry.loaded : false;
   }
 
   /**
-   * Set theme object (for JS themes)
+   * Mark a theme as loaded
    */
-  setTheme(themeId: string, theme: Theme): void {
+  markLoaded(themeId: string, theme?: Theme): void {
     const entry = this.entries.get(themeId);
     if (entry) {
-      entry.theme = theme;
       entry.loaded = true;
+      if (theme) {
+        entry.theme = theme;
+      }
     }
   }
 
+  /**
+   * Get theme object (for JS themes)
+   */
+  getTheme(themeId: string): Theme | undefined {
+    const entry = this.entries.get(themeId);
+    return entry?.loaded ? entry.theme : undefined;
+  }
+
   /**
    * Get dependencies for a theme
    */