@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.1.4 → 0.1.5

package/src/tokens/tokenManager.ts

@@ -0,0 +1,248 @@
+import type { CompleteThemeConfig } from '../themes/types';
+import type { ThemeTokens, TokenExportOptions } from './types';
+import { TokenGenerator } from './tokenGenerator';
+import { TokenExporter } from './tokenExporter';
+import { TokenValidator, ValidationResult } from './tokenValidator';
+
+export interface TokenManagerOptions {
+  autoValidate?: boolean;
+  autoGenerate?: boolean;
+  defaultExportFormat?: TokenExportOptions['format'];
+  includeMetadata?: boolean;
+  includeComments?: boolean;
+}
+
+export class TokenManager {
+  private options: TokenManagerOptions;
+  private generatedTokens: Map<string, ThemeTokens> = new Map();
+
+  constructor(options: TokenManagerOptions = {}) {
+    this.options = {
+      autoValidate: true,
+      autoGenerate: true,
+      defaultExportFormat: 'json',
+      includeMetadata: true,
+      includeComments: true,
+      ...options
+    };
+  }
+
+  /**
+   * Generates tokens for a theme configuration
+   */
+  generateTokens(themeConfig: CompleteThemeConfig): ThemeTokens {
+    const tokens = TokenGenerator.generateTokens(themeConfig);
+    
+    if (this.options.autoValidate) {
+      const validation = this.validateTokens(tokens);
+      if (!validation.isValid) {
+        console.warn('Token validation failed:', validation.errors);
+      }
+    }
+
+    this.generatedTokens.set(themeConfig.meta.name, tokens);
+    return tokens;
+  }
+
+  /**
+   * Generates tokens for multiple themes
+   */
+  generateTokensForThemes(themes: CompleteThemeConfig[]): Map<string, ThemeTokens> {
+    themes.forEach(theme => {
+      this.generateTokens(theme);
+    });
+    
+    return this.generatedTokens;
+  }
+
+  /**
+   * Validates tokens
+   */
+  validateTokens(tokens: ThemeTokens): ValidationResult {
+    return TokenValidator.validateTokens(tokens);
+  }
+
+  /**
+   * Exports tokens in the specified format
+   */
+  exportTokens(
+    tokens: ThemeTokens, 
+    format?: TokenExportOptions['format'],
+    platform?: TokenExportOptions['platform']
+  ): string {
+    const options: TokenExportOptions = {
+      format: format || this.options.defaultExportFormat!,
+      platform,
+      includeMetadata: this.options.includeMetadata,
+      includeComments: this.options.includeComments
+    };
+
+    return TokenExporter.exportTokens(tokens, options);
+  }
+
+  /**
+   * Exports all generated tokens
+   */
+  exportAllTokens(format?: TokenExportOptions['format']): Map<string, string> {
+    const exports = new Map<string, string>();
+    
+    this.generatedTokens.forEach((tokens, themeName) => {
+      const exported = this.exportTokens(tokens, format);
+      exports.set(themeName, exported);
+    });
+
+    return exports;
+  }
+
+  /**
+   * Exports tokens for a specific theme
+   */
+  exportThemeTokens(themeName: string, format?: TokenExportOptions['format']): string | null {
+    const tokens = this.generatedTokens.get(themeName);
+    if (!tokens) {
+      console.warn(`No tokens found for theme: ${themeName}`);
+      return null;
+    }
+
+    return this.exportTokens(tokens, format);
+  }
+
+  /**
+   * Gets generated tokens for a theme
+   */
+  getTokens(themeName: string): ThemeTokens | undefined {
+    return this.generatedTokens.get(themeName);
+  }
+
+  /**
+   * Gets all generated tokens
+   */
+  getAllTokens(): Map<string, ThemeTokens> {
+    return new Map(this.generatedTokens);
+  }
+
+  /**
+   * Clears all generated tokens
+   */
+  clearTokens(): void {
+    this.generatedTokens.clear();
+  }
+
+  /**
+   * Removes tokens for a specific theme
+   */
+  removeTokens(themeName: string): boolean {
+    return this.generatedTokens.delete(themeName);
+  }
+
+  /**
+   * Gets token statistics
+   */
+  getTokenStats(): {
+    totalThemes: number;
+    totalTokens: number;
+    tokenBreakdown: Record<string, number>;
+  } {
+    const totalThemes = this.generatedTokens.size;
+    let totalTokens = 0;
+    const tokenBreakdown: Record<string, number> = {};
+
+    this.generatedTokens.forEach(tokens => {
+      Object.entries(tokens.tokens).forEach(([category, categoryTokens]) => {
+        if (categoryTokens) {
+          const count = this.countTokensInGroup(categoryTokens);
+          tokenBreakdown[category] = (tokenBreakdown[category] || 0) + count;
+          totalTokens += count;
+        }
+      });
+    });
+
+    return {
+      totalThemes,
+      totalTokens,
+      tokenBreakdown
+    };
+  }
+
+  /**
+   * Counts tokens in a token group recursively
+   */
+  private countTokensInGroup(group: any): number {
+    let count = 0;
+    
+    Object.values(group).forEach(value => {
+      if (value && typeof value === 'object') {
+        if ('type' in value && 'value' in value) {
+          // This is a token
+          count++;
+        } else {
+          // This is a group, recurse
+          count += this.countTokensInGroup(value);
+        }
+      }
+    });
+
+    return count;
+  }
+
+  /**
+   * Updates manager options
+   */
+  updateOptions(newOptions: Partial<TokenManagerOptions>): void {
+    this.options = { ...this.options, ...newOptions };
+  }
+
+  /**
+   * Gets current manager options
+   */
+  getOptions(): TokenManagerOptions {
+    return { ...this.options };
+  }
+
+  /**
+   * Exports tokens to file (simulated - in real implementation would write to filesystem)
+   */
+  exportToFile(
+    themeName: string, 
+    format: TokenExportOptions['format'] = 'json',
+    filename?: string
+  ): { success: boolean; filename: string; content: string } {
+    const tokens = this.generatedTokens.get(themeName);
+    if (!tokens) {
+      throw new Error(`No tokens found for theme: ${themeName}`);
+    }
+
+    const content = this.exportTokens(tokens, format);
+    const finalFilename = filename || `${themeName}-tokens.${format}`;
+
+    // In a real implementation, this would write to the filesystem
+    // For now, we'll just return the content and filename
+    return {
+      success: true,
+      filename: finalFilename,
+      content
+    };
+  }
+
+  /**
+   * Exports all themes to files
+   */
+  exportAllToFiles(format?: TokenExportOptions['format']): Map<string, { success: boolean; filename: string; content: string }> {
+    const exports = new Map<string, { success: boolean; filename: string; content: string }>();
+    
+    this.generatedTokens.forEach((_tokens, themeName) => {
+      try {
+        const result = this.exportToFile(themeName, format);
+        exports.set(themeName, result);
+      } catch (error) {
+        exports.set(themeName, {
+          success: false,
+          filename: `${themeName}-tokens.${format}`,
+          content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
+        });
+      }
+    });
+
+    return exports;
+  }
+}