@rakeyshgidwani/roger-ui-bank-theme-jeremy 0.5.3

package/dist/tokens/tokenGenerator.js

@@ -0,0 +1,244 @@
+export class TokenGenerator {
+    /**
+     * Generates design tokens from a complete theme configuration
+     */
+    static generateTokens(themeConfig) {
+        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)
+            }
+        };
+    }
+    /**
+     * Generates color tokens from theme colors
+     */
+    static generateColorTokens(colors) {
+        const colorTokens = {};
+        // Primary colors
+        if (colors.primary) {
+            colorTokens.primary = this.createColorGroup(colors.primary, 'primary');
+        }
+        // Secondary colors
+        if (colors.secondary) {
+            colorTokens.secondary = this.createColorGroup(colors.secondary, 'secondary');
+        }
+        // Neutral colors
+        if (colors.neutral) {
+            colorTokens.neutral = this.createColorGroup(colors.neutral, 'neutral');
+        }
+        // Surface colors
+        if (colors.surface) {
+            colorTokens.surface = this.createColorGroup(colors.surface, 'neutral');
+        }
+        // Text colors
+        if (colors.text) {
+            colorTokens.text = this.createColorGroup(colors.text, 'neutral');
+        }
+        // Interactive colors
+        if (colors.interactive) {
+            colorTokens.interactive = this.createColorGroup(colors.interactive, 'neutral');
+        }
+        // Semantic colors
+        if (colors.semantic) {
+            colorTokens.semantic = this.createColorGroup(colors.semantic, 'neutral');
+        }
+        return colorTokens;
+    }
+    /**
+     * Creates a color group from a color scale
+     */
+    static createColorGroup(colorScale, semantic) {
+        const group = {};
+        Object.entries(colorScale).forEach(([shade, value]) => {
+            if (typeof value === 'string') {
+                group[shade] = {
+                    value,
+                    type: 'color',
+                    semantic,
+                    description: `${semantic} color - ${shade} shade`,
+                    category: 'color',
+                    tags: [semantic, shade]
+                };
+            }
+        });
+        return group;
+    }
+    /**
+     * Generates font tokens from theme fonts
+     */
+    static generateFontTokens(fonts) {
+        const fontTokens = {};
+        // Font families
+        if (fonts.primary) {
+            fontTokens.primary = {
+                value: fonts.primary.family,
+                type: 'fontFamily',
+                description: 'Primary font family',
+                category: 'typography',
+                tags: ['primary', 'font']
+            };
+        }
+        if (fonts.secondary) {
+            fontTokens.secondary = {
+                value: fonts.secondary.family,
+                type: 'fontFamily',
+                description: 'Secondary font family',
+                category: 'typography',
+                tags: ['secondary', 'font']
+            };
+        }
+        if (fonts.display) {
+            fontTokens.display = {
+                value: fonts.display.family,
+                type: 'fontFamily',
+                description: 'Display font family',
+                category: 'typography',
+                tags: ['display', 'font']
+            };
+        }
+        if (fonts.body) {
+            fontTokens.body = {
+                value: fonts.body.family,
+                type: 'fontFamily',
+                description: 'Body font family',
+                category: 'typography',
+                tags: ['body', 'font']
+            };
+        }
+        if (fonts.mono) {
+            fontTokens.mono = {
+                value: fonts.mono.family,
+                type: 'fontFamily',
+                description: 'Monospace font family',
+                category: 'typography',
+                tags: ['mono', 'font']
+            };
+        }
+        // Font sizes (from primary font)
+        if (fonts.primary?.sizes) {
+            Object.entries(fonts.primary.sizes).forEach(([size, value]) => {
+                fontTokens[`size-${size}`] = {
+                    value,
+                    type: 'fontSize',
+                    description: `Font size - ${size}`,
+                    category: 'typography',
+                    tags: ['font', 'size', size]
+                };
+            });
+        }
+        // Font weights (from primary font)
+        if (fonts.primary?.weights) {
+            fonts.primary.weights.forEach((weight, index) => {
+                fontTokens[`weight-${index}`] = {
+                    value: weight,
+                    type: 'fontWeight',
+                    description: `Font weight - ${weight}`,
+                    category: 'typography',
+                    tags: ['font', 'weight', weight.toString()]
+                };
+            });
+        }
+        // Line heights (from primary font)
+        if (fonts.primary?.lineHeights) {
+            Object.entries(fonts.primary.lineHeights).forEach(([height, value]) => {
+                fontTokens[`line-height-${height}`] = {
+                    value,
+                    type: 'lineHeight',
+                    description: `Line height - ${height}`,
+                    category: 'typography',
+                    tags: ['font', 'line-height', height]
+                };
+            });
+        }
+        // Letter spacing (from primary font)
+        if (fonts.primary?.letterSpacing) {
+            Object.entries(fonts.primary.letterSpacing).forEach(([spacing, value]) => {
+                fontTokens[`letter-spacing-${spacing}`] = {
+                    value,
+                    type: 'letterSpacing',
+                    description: `Letter spacing - ${spacing}`,
+                    category: 'typography',
+                    tags: ['font', 'letter-spacing', spacing]
+                };
+            });
+        }
+        return fontTokens;
+    }
+    /**
+     * Generates spacing tokens from theme spacing
+     */
+    static generateSpacingTokens(spacing) {
+        const spacingTokens = {};
+        if (spacing) {
+            Object.entries(spacing).forEach(([scale, value]) => {
+                spacingTokens[scale] = {
+                    value,
+                    type: 'spacing',
+                    unit: 'px',
+                    description: `Spacing scale - ${scale}`,
+                    category: 'layout',
+                    tags: ['spacing', 'layout', scale]
+                };
+            });
+        }
+        return spacingTokens;
+    }
+    /**
+     * Generates shadow tokens from theme shadows
+     */
+    static generateShadowTokens(shadows) {
+        const shadowTokens = {};
+        if (shadows) {
+            Object.entries(shadows).forEach(([elevation, value]) => {
+                shadowTokens[elevation] = {
+                    value,
+                    type: 'shadow',
+                    elevation: elevation,
+                    description: `Shadow - ${elevation} elevation`,
+                    category: 'effects',
+                    tags: ['shadow', 'elevation', elevation]
+                };
+            });
+        }
+        return shadowTokens;
+    }
+    /**
+     * Generates transition tokens from theme transitions
+     */
+    static generateTransitionTokens(transitions) {
+        const transitionTokens = {};
+        if (transitions) {
+            Object.entries(transitions).forEach(([name, value]) => {
+                transitionTokens[name] = {
+                    value,
+                    type: 'transition',
+                    easing: this.detectEasing(value),
+                    description: `Transition - ${name}`,
+                    category: 'animation',
+                    tags: ['transition', 'animation', name]
+                };
+            });
+        }
+        return transitionTokens;
+    }
+    /**
+     * Detects easing function from transition value
+     */
+    static detectEasing(transition) {
+        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';
+        if (transition.includes('linear'))
+            return 'linear';
+        return undefined;
+    }
+}

package/dist/tokens/tokenManager.d.ts

@@ -0,0 +1,92 @@
+import type { CompleteThemeConfig } from '../themes/types.js';
+import type { ThemeTokens, TokenExportOptions } from './types.js';
+import { ValidationResult } from './tokenValidator.js';
+export interface TokenManagerOptions {
+    autoValidate?: boolean;
+    autoGenerate?: boolean;
+    defaultExportFormat?: TokenExportOptions['format'];
+    includeMetadata?: boolean;
+    includeComments?: boolean;
+}
+export declare class TokenManager {
+    private options;
+    private generatedTokens;
+    constructor(options?: TokenManagerOptions);
+    /**
+     * Generates tokens for a theme configuration
+     */
+    generateTokens(themeConfig: CompleteThemeConfig): ThemeTokens;
+    /**
+     * Generates tokens for multiple themes
+     */
+    generateTokensForThemes(themes: CompleteThemeConfig[]): Map<string, ThemeTokens>;
+    /**
+     * Validates tokens
+     */
+    validateTokens(tokens: ThemeTokens): ValidationResult;
+    /**
+     * Exports tokens in the specified format
+     */
+    exportTokens(tokens: ThemeTokens, format?: TokenExportOptions['format'], platform?: TokenExportOptions['platform']): string;
+    /**
+     * Exports all generated tokens
+     */
+    exportAllTokens(format?: TokenExportOptions['format']): Map<string, string>;
+    /**
+     * Exports tokens for a specific theme
+     */
+    exportThemeTokens(themeName: string, format?: TokenExportOptions['format']): string | null;
+    /**
+     * Gets generated tokens for a theme
+     */
+    getTokens(themeName: string): ThemeTokens | undefined;
+    /**
+     * Gets all generated tokens
+     */
+    getAllTokens(): Map<string, ThemeTokens>;
+    /**
+     * Clears all generated tokens
+     */
+    clearTokens(): void;
+    /**
+     * Removes tokens for a specific theme
+     */
+    removeTokens(themeName: string): boolean;
+    /**
+     * Gets token statistics
+     */
+    getTokenStats(): {
+        totalThemes: number;
+        totalTokens: number;
+        tokenBreakdown: Record<string, number>;
+    };
+    /**
+     * Counts tokens in a token group recursively
+     */
+    private countTokensInGroup;
+    /**
+     * Updates manager options
+     */
+    updateOptions(newOptions: Partial<TokenManagerOptions>): void;
+    /**
+     * Gets current manager options
+     */
+    getOptions(): TokenManagerOptions;
+    /**
+     * Exports tokens to file (simulated - in real implementation would write to filesystem)
+     */
+    exportToFile(themeName: string, format?: TokenExportOptions['format'], filename?: string): {
+        success: boolean;
+        filename: string;
+        content: string;
+    };
+    /**
+     * Exports all themes to files
+     */
+    exportAllToFiles(format?: TokenExportOptions['format']): Map<string, {
+        success: boolean;
+        filename: string;
+        content: string;
+    }>;
+}
+//# sourceMappingURL=tokenManager.d.ts.map

package/dist/tokens/tokenManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenManager.d.ts","sourceRoot":"","sources":["../../src/tokens/tokenManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGlE,OAAO,EAAkB,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvE,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mBAAmB,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IACnD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,eAAe,CAAuC;gBAElD,OAAO,GAAE,mBAAwB;IAW7C;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,mBAAmB,GAAG,WAAW;IAc7D;;OAEG;IACH,uBAAuB,CAAC,MAAM,EAAE,mBAAmB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAQhF;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,gBAAgB;IAIrD;;OAEG;IACH,YAAY,CACV,MAAM,EAAE,WAAW,EACnB,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,EACrC,QAAQ,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,GACxC,MAAM;IAWT;;OAEG;IACH,eAAe,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAW3E;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,IAAI;IAU1F;;OAEG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIrD;;OAEG;IACH,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAIxC;;OAEG;IACH,WAAW,IAAI,IAAI;IAInB;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIxC;;OAEG;IACH,aAAa,IAAI;QACf,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACxC;IAsBD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAkB1B;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,IAAI;IAI7D;;OAEG;IACH,UAAU,IAAI,mBAAmB;IAIjC;;OAEG;IACH,YAAY,CACV,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,kBAAkB,CAAC,QAAQ,CAAU,EAC7C,QAAQ,CAAC,EAAE,MAAM,GAChB;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAkB1D;;OAEG;IACH,gBAAgB,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAkB9H"}

package/dist/tokens/tokenManager.esm.js

@@ -0,0 +1,194 @@
+import { TokenGenerator } from './tokenGenerator.js';
+import { TokenExporter } from './tokenExporter.js';
+import { TokenValidator } from './tokenValidator.js';
+export class TokenManager {
+    constructor(options = {}) {
+        this.generatedTokens = new Map();
+        this.options = {
+            autoValidate: true,
+            autoGenerate: true,
+            defaultExportFormat: 'json',
+            includeMetadata: true,
+            includeComments: true,
+            ...options
+        };
+    }
+    /**
+     * Generates tokens for a theme configuration
+     */
+    generateTokens(themeConfig) {
+        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) {
+        themes.forEach(theme => {
+            this.generateTokens(theme);
+        });
+        return this.generatedTokens;
+    }
+    /**
+     * Validates tokens
+     */
+    validateTokens(tokens) {
+        return TokenValidator.validateTokens(tokens);
+    }
+    /**
+     * Exports tokens in the specified format
+     */
+    exportTokens(tokens, format, platform) {
+        const options = {
+            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) {
+        const exports = new Map();
+        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, format) {
+        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) {
+        return this.generatedTokens.get(themeName);
+    }
+    /**
+     * Gets all generated tokens
+     */
+    getAllTokens() {
+        return new Map(this.generatedTokens);
+    }
+    /**
+     * Clears all generated tokens
+     */
+    clearTokens() {
+        this.generatedTokens.clear();
+    }
+    /**
+     * Removes tokens for a specific theme
+     */
+    removeTokens(themeName) {
+        return this.generatedTokens.delete(themeName);
+    }
+    /**
+     * Gets token statistics
+     */
+    getTokenStats() {
+        const totalThemes = this.generatedTokens.size;
+        let totalTokens = 0;
+        const tokenBreakdown = {};
+        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
+     */
+    countTokensInGroup(group) {
+        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) {
+        this.options = { ...this.options, ...newOptions };
+    }
+    /**
+     * Gets current manager options
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+    /**
+     * Exports tokens to file (simulated - in real implementation would write to filesystem)
+     */
+    exportToFile(themeName, format = 'json', filename) {
+        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) {
+        const exports = new Map();
+        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;
+    }
+}