@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.2.9 → 0.2.10

package/dist/tokens/tokenManager.js

@@ -1,28 +1,28 @@
-
-
+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?;
-  autoGenerate?;
-  defaultExportFormat?];
-  includeMetadata?;
-  includeComments?;
+  autoValidate?: boolean;
+  autoGenerate?: boolean;
+  defaultExportFormat?: TokenExportOptions['format'];
+  includeMetadata?: boolean;
+  includeComments?: boolean;
 }
 
 export class TokenManager {
-  private options;
-  private generatedTokens, ThemeTokens> = new Map();
+  private options: TokenManagerOptions;
+  private generatedTokens: Map<string, ThemeTokens> = new Map();
 
-  constructor(options= {}) {
+  constructor(options: TokenManagerOptions = {}) {
     this.options = {
-      autoValidate,
-      autoGenerate,
-      defaultExportFormat,
-      includeMetadata,
-      includeComments,
+      autoValidate: true,
+      autoGenerate: true,
+      defaultExportFormat: 'json',
+      includeMetadata: true,
+      includeComments: true,
       ...options
     };
   }
@@ -30,12 +30,13 @@ export class TokenManager {
   /**
    * Generates tokens for a theme configuration
    */
-  generateTokens(themeConfig)= TokenGenerator.generateTokens(themeConfig);
+  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);
+        console.warn('Token validation failed:', validation.errors);
       }
     }
 
@@ -46,7 +47,7 @@ export class TokenManager {
   /**
    * Generates tokens for multiple themes
    */
-  generateTokensForThemes(themes]), ThemeTokens> {
+  generateTokensForThemes(themes: CompleteThemeConfig[]): Map<string, ThemeTokens> {
     themes.forEach(theme => {
       this.generateTokens(theme);
     });
@@ -57,21 +58,24 @@ export class TokenManager {
   /**
    * Validates tokens
    */
-  validateTokens(tokens));
+  validateTokens(tokens: ThemeTokens): ValidationResult {
+    return TokenValidator.validateTokens(tokens);
   }
 
   /**
    * Exports tokens in the specified format
    */
   exportTokens(
-    tokens, 
-    format?],
-    platform?]
-  )= {
-      format,
+    tokens: ThemeTokens, 
+    format?: TokenExportOptions['format'],
+    platform?: TokenExportOptions['platform']
+  ): string {
+    const options: TokenExportOptions = {
+      format: format || this.options.defaultExportFormat!,
       platform,
-      includeMetadata,
-      includeComments};
+      includeMetadata: this.options.includeMetadata,
+      includeComments: this.options.includeComments
+    };
 
     return TokenExporter.exportTokens(tokens, options);
   }
@@ -79,7 +83,7 @@ export class TokenManager {
   /**
    * Exports all generated tokens
    */
-  exportAllTokens(format?]), string> {
+  exportAllTokens(format?: TokenExportOptions['format']): Map<string, string> {
     const exports = new Map<string, string>();
     
     this.generatedTokens.forEach((tokens, themeName) => {
@@ -93,9 +97,10 @@ export class TokenManager {
   /**
    * Exports tokens for a specific theme
    */
-  exportThemeTokens(themeName, format?])= this.generatedTokens.get(themeName);
+  exportThemeTokens(themeName: string, format?: TokenExportOptions['format']): string | null {
+    const tokens = this.generatedTokens.get(themeName);
     if (!tokens) {
-      console.warn(`No tokens found for theme}`);
+      console.warn(`No tokens found for theme: ${themeName}`);
       return null;
     }
 
@@ -105,38 +110,42 @@ export class TokenManager {
   /**
    * Gets generated tokens for a theme
    */
-  getTokens(themeName));
+  getTokens(themeName: string): ThemeTokens | undefined {
+    return this.generatedTokens.get(themeName);
   }
 
   /**
    * Gets all generated tokens
    */
-  getAllTokens(), ThemeTokens> {
+  getAllTokens(): Map<string, ThemeTokens> {
     return new Map(this.generatedTokens);
   }
 
   /**
    * Clears all generated tokens
    */
-  clearTokens());
+  clearTokens(): void {
+    this.generatedTokens.clear();
   }
 
   /**
    * Removes tokens for a specific theme
    */
-  removeTokens(themeName));
+  removeTokens(themeName: string): boolean {
+    return this.generatedTokens.delete(themeName);
   }
 
   /**
    * Gets token statistics
    */
-  getTokenStats();
-    totalTokens;
-    tokenBreakdown, number>;
+  getTokenStats(): {
+    totalThemes: number;
+    totalTokens: number;
+    tokenBreakdown: Record<string, number>;
   } {
     const totalThemes = this.generatedTokens.size;
     let totalTokens = 0;
-    const tokenBreakdown, number> = {};
+    const tokenBreakdown: Record<string, number> = {};
 
     this.generatedTokens.forEach(tokens => {
       Object.entries(tokens.tokens).forEach(([category, categoryTokens]) => {
@@ -158,7 +167,8 @@ export class TokenManager {
   /**
    * Counts tokens in a token group recursively
    */
-  private countTokensInGroup(group)= 0;
+  private countTokensInGroup(group: any): number {
+    let count = 0;
     
     Object.values(group).forEach(value => {
       if (value && typeof value === 'object') {
@@ -178,25 +188,28 @@ export class TokenManager {
   /**
    * Updates manager options
    */
-  updateOptions(newOptions)= { ...this.options, ...newOptions };
+  updateOptions(newOptions: Partial<TokenManagerOptions>): void {
+    this.options = { ...this.options, ...newOptions };
   }
 
   /**
    * Gets current manager options
    */
-  getOptions()};
+  getOptions(): TokenManagerOptions {
+    return { ...this.options };
   }
 
   /**
    * Exports tokens to file (simulated - in real implementation would write to filesystem)
    */
   exportToFile(
-    themeName, 
-    format] = 'json',
-    filename?); filename; content} {
+    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}`);
+      throw new Error(`No tokens found for theme: ${themeName}`);
     }
 
     const content = this.exportTokens(tokens, format);
@@ -205,8 +218,8 @@ export class TokenManager {
     // In a real implementation, this would write to the filesystem
     // For now, we'll just return the content and filename
     return {
-      success,
-      filename,
+      success: true,
+      filename: finalFilename,
       content
     };
   }
@@ -214,8 +227,8 @@ export class TokenManager {
   /**
    * Exports all themes to files
    */
-  exportAllToFiles(format?]), { success; filename; content}> {
-    const exports = new Map<string, { success; filename; content}>();
+  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 {
@@ -223,9 +236,9 @@ export class TokenManager {
         exports.set(themeName, result);
       } catch (error) {
         exports.set(themeName, {
-          success,
-          filename}-tokens.${format}`,
-          content}`
+          success: false,
+          filename: `${themeName}-tokens.${format}`,
+          content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
         });
       }
     });