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

package/dist/tokens/tokenGenerator.js

@@ -1,17 +1,20 @@
-
-
+import type { CompleteThemeConfig } from '../themes/types';
+import type { ThemeTokens, TokenGroup, ColorToken, FontToken, SpacingToken, ShadowToken, TransitionToken } from './types';
 
 export class TokenGenerator {
   /**
    * Generates design tokens from a complete theme configuration
    */
-  static generateTokens(themeConfig),
-      version,
-      tokens),
-        font),
-        spacing),
-        shadow),
-        transition)
+  static generateTokens(themeConfig: CompleteThemeConfig): ThemeTokens {
+    return {
+      theme: themeConfig.meta.name,
+      version: themeConfig.meta.version || '1.0.0',
+      tokens: {
+        color: this.generateColorTokens(themeConfig.colors),
+        font: this.generateFontTokens(themeConfig.fonts),
+        spacing: this.generateSpacingTokens(themeConfig.spacing),
+        shadow: this.generateShadowTokens(themeConfig.shadows),
+        transition: this.generateTransitionTokens(themeConfig.transitions)
       }
     };
   }
@@ -19,7 +22,8 @@ export class TokenGenerator {
   /**
    * Generates color tokens from theme colors
    */
-  private static generateColorTokens(colors])= {};
+  private static generateColorTokens(colors: CompleteThemeConfig['colors']): TokenGroup {
+    const colorTokens: TokenGroup = {};
 
     // Primary colors
     if (colors.primary) {
@@ -62,17 +66,18 @@ export class TokenGenerator {
   /**
    * Creates a color group from a color scale
    */
-  private static createColorGroup(colorScale, semantic])= {};
+  private static createColorGroup(colorScale: any, semantic: ColorToken['semantic']): TokenGroup {
+    const group: TokenGroup = {};
     
     Object.entries(colorScale).forEach(([shade, value]) => {
       if (typeof value === 'string') {
         group[shade] = {
           value,
-          type,
+          type: 'color',
           semantic,
-          description} color - ${shade} shade`,
-          category,
-          tags, shade]
+          description: `${semantic} color - ${shade} shade`,
+          category: 'color',
+          tags: [semantic, shade]
         } as ColorToken;
       }
     });
@@ -83,56 +88,57 @@ export class TokenGenerator {
   /**
    * Generates font tokens from theme fonts
    */
-  private static generateFontTokens(fonts])= {};
+  private static generateFontTokens(fonts: CompleteThemeConfig['fonts']): TokenGroup {
+    const fontTokens: TokenGroup = {};
 
     // Font families
     if (fonts.primary) {
       fontTokens.primary = {
-        value,
-        type,
-        description,
-        category,
-        tags, 'font']
+        value: fonts.primary.family,
+        type: 'fontFamily',
+        description: 'Primary font family',
+        category: 'typography',
+        tags: ['primary', 'font']
       } as FontToken;
     }
 
     if (fonts.secondary) {
       fontTokens.secondary = {
-        value,
-        type,
-        description,
-        category,
-        tags, 'font']
+        value: fonts.secondary.family,
+        type: 'fontFamily',
+        description: 'Secondary font family',
+        category: 'typography',
+        tags: ['secondary', 'font']
       } as FontToken;
     }
 
     if (fonts.display) {
       fontTokens.display = {
-        value,
-        type,
-        description,
-        category,
-        tags, 'font']
+        value: fonts.display.family,
+        type: 'fontFamily',
+        description: 'Display font family',
+        category: 'typography',
+        tags: ['display', 'font']
       } as FontToken;
     }
 
     if (fonts.body) {
       fontTokens.body = {
-        value,
-        type,
-        description,
-        category,
-        tags, 'font']
+        value: fonts.body.family,
+        type: 'fontFamily',
+        description: 'Body font family',
+        category: 'typography',
+        tags: ['body', 'font']
       } as FontToken;
     }
 
     if (fonts.mono) {
       fontTokens.mono = {
-        value,
-        type,
-        description,
-        category,
-        tags, 'font']
+        value: fonts.mono.family,
+        type: 'fontFamily',
+        description: 'Monospace font family',
+        category: 'typography',
+        tags: ['mono', 'font']
       } as FontToken;
     }
 
@@ -141,10 +147,10 @@ export class TokenGenerator {
       Object.entries(fonts.primary.sizes).forEach(([size, value]) => {
         fontTokens[`size-${size}`] = {
           value,
-          type,
-          description}`,
-          category,
-          tags, 'size', size]
+          type: 'fontSize',
+          description: `Font size - ${size}`,
+          category: 'typography',
+          tags: ['font', 'size', size]
         } as FontToken;
       });
     }
@@ -153,11 +159,11 @@ export class TokenGenerator {
     if (fonts.primary?.weights) {
       fonts.primary.weights.forEach((weight, index) => {
         fontTokens[`weight-${index}`] = {
-          value,
-          type,
-          description}`,
-          category,
-          tags, 'weight', weight.toString()]
+          value: weight,
+          type: 'fontWeight',
+          description: `Font weight - ${weight}`,
+          category: 'typography',
+          tags: ['font', 'weight', weight.toString()]
         } as FontToken;
       });
     }
@@ -167,10 +173,10 @@ export class TokenGenerator {
       Object.entries(fonts.primary.lineHeights).forEach(([height, value]) => {
         fontTokens[`line-height-${height}`] = {
           value,
-          type,
-          description}`,
-          category,
-          tags, 'line-height', height]
+          type: 'lineHeight',
+          description: `Line height - ${height}`,
+          category: 'typography',
+          tags: ['font', 'line-height', height]
         } as FontToken;
       });
     }
@@ -180,10 +186,10 @@ export class TokenGenerator {
       Object.entries(fonts.primary.letterSpacing).forEach(([spacing, value]) => {
         fontTokens[`letter-spacing-${spacing}`] = {
           value,
-          type,
-          description}`,
-          category,
-          tags, 'letter-spacing', spacing]
+          type: 'letterSpacing',
+          description: `Letter spacing - ${spacing}`,
+          category: 'typography',
+          tags: ['font', 'letter-spacing', spacing]
         } as FontToken;
       });
     }
@@ -194,17 +200,18 @@ export class TokenGenerator {
   /**
    * Generates spacing tokens from theme spacing
    */
-  private static generateSpacingTokens(spacing])= {};
+  private static generateSpacingTokens(spacing: CompleteThemeConfig['spacing']): TokenGroup {
+    const spacingTokens: TokenGroup = {};
 
     if (spacing) {
       Object.entries(spacing).forEach(([scale, value]) => {
         spacingTokens[scale] = {
           value,
-          type,
-          unit,
-          description}`,
-          category,
-          tags, 'layout', scale]
+          type: 'spacing',
+          unit: 'px',
+          description: `Spacing scale - ${scale}`,
+          category: 'layout',
+          tags: ['spacing', 'layout', scale]
         } as SpacingToken;
       });
     }
@@ -215,17 +222,18 @@ export class TokenGenerator {
   /**
    * Generates shadow tokens from theme shadows
    */
-  private static generateShadowTokens(shadows])= {};
+  private static generateShadowTokens(shadows: CompleteThemeConfig['shadows']): TokenGroup {
+    const shadowTokens: TokenGroup = {};
 
     if (shadows) {
       Object.entries(shadows).forEach(([elevation, value]) => {
         shadowTokens[elevation] = {
           value,
-          type,
-          elevation,
-          description} elevation`,
-          category,
-          tags, 'elevation', elevation]
+          type: 'shadow',
+          elevation: elevation as 'low' | 'medium' | 'high',
+          description: `Shadow - ${elevation} elevation`,
+          category: 'effects',
+          tags: ['shadow', 'elevation', elevation]
         } as ShadowToken;
       });
     }
@@ -236,17 +244,18 @@ export class TokenGenerator {
   /**
    * Generates transition tokens from theme transitions
    */
-  private static generateTransitionTokens(transitions])= {};
+  private static generateTransitionTokens(transitions: CompleteThemeConfig['transitions']): TokenGroup {
+    const transitionTokens: TokenGroup = {};
 
     if (transitions) {
       Object.entries(transitions).forEach(([name, value]) => {
         transitionTokens[name] = {
           value,
-          type,
-          easing),
-          description}`,
-          category,
-          tags, 'animation', name]
+          type: 'transition',
+          easing: this.detectEasing(value),
+          description: `Transition - ${name}`,
+          category: 'animation',
+          tags: ['transition', 'animation', name]
         } as TransitionToken;
       });
     }
@@ -257,7 +266,7 @@ export class TokenGenerator {
   /**
    * Detects easing function from transition value
    */
-  private static detectEasing(transition)] {
+  private static detectEasing(transition: string): TransitionToken['easing'] {
     if (transition.includes('ease-in-out')) return 'ease-in-out';
     if (transition.includes('ease-in')) return 'ease-in';
     if (transition.includes('ease-out')) return 'ease-out';

package/dist/tokens/tokenManager.esm.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'}`
         });
       }
     });