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

package/dist/tokens/tokenManager.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;
+    }
+}

package/dist/tokens/tokenValidator.d.ts

@@ -0,0 +1,91 @@
+import type { ThemeTokens } from './types.js';
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+    severity: 'error' | 'critical';
+}
+export interface ValidationWarning {
+    path: string;
+    message: string;
+    suggestion?: string;
+}
+export declare class TokenValidator {
+    /**
+     * Validates a complete theme tokens object
+     */
+    static validateTokens(tokens: ThemeTokens): ValidationResult;
+    /**
+     * Validates a specific token category
+     */
+    private static validateTokenCategory;
+    /**
+     * Validates a token group recursively
+     */
+    private static validateTokenGroup;
+    /**
+     * Validates an individual token
+     */
+    private static validateToken;
+    /**
+     * Validates token value based on type
+     */
+    private static validateTokenValue;
+    /**
+     * Validates color tokens
+     */
+    private static validateColorToken;
+    /**
+     * Validates font family tokens
+     */
+    private static validateFontFamilyToken;
+    /**
+     * Validates font size tokens
+     */
+    private static validateFontSizeToken;
+    /**
+     * Validates font weight tokens
+     */
+    private static validateFontWeightToken;
+    /**
+     * Validates line height tokens
+     */
+    private static validateLineHeightToken;
+    /**
+     * Validates spacing tokens
+     */
+    private static validateSpacingToken;
+    /**
+     * Validates shadow tokens
+     */
+    private static validateShadowToken;
+    /**
+     * Validates transition tokens
+     */
+    private static validateTransitionToken;
+    /**
+     * Validates breakpoint tokens
+     */
+    private static validateBreakpointToken;
+    /**
+     * Checks if a value is a valid token
+     */
+    private static isToken;
+    /**
+     * Checks if a token type is valid
+     */
+    private static isValidTokenType;
+    /**
+     * Checks if a color value is valid
+     */
+    private static isValidColor;
+    /**
+     * Checks if a CSS unit is valid
+     */
+    private static isValidCSSUnit;
+}
+//# sourceMappingURL=tokenValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenValidator.d.ts","sourceRoot":"","sources":["../../src/tokens/tokenValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAA0B,MAAM,YAAY,CAAC;AAEtE,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,GAAG,UAAU,CAAC;CAChC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,cAAc;IACzB;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,gBAAgB;IA8C5D;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAoBpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAwBjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAmD5B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAqCjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAoCjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAyBtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAiCpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAkCtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAiCtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA0BnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAyBlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAyBtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA0BtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,OAAO;IAOtB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAS/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAM3B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;CAI9B"}

package/dist/tokens/tokenValidator.esm.js

@@ -0,0 +1,423 @@
+export class TokenValidator {
+    /**
+     * Validates a complete theme tokens object
+     */
+    static validateTokens(tokens) {
+        const errors = [];
+        const warnings = [];
+        // Validate basic structure
+        if (!tokens.theme) {
+            errors.push({
+                path: 'theme',
+                message: 'Theme name is required',
+                severity: 'critical'
+            });
+        }
+        if (!tokens.version) {
+            errors.push({
+                path: 'version',
+                message: 'Theme version is required',
+                severity: 'critical'
+            });
+        }
+        if (!tokens.tokens) {
+            errors.push({
+                path: 'tokens',
+                message: 'Tokens object is required',
+                severity: 'critical'
+            });
+        }
+        // Validate token categories
+        if (tokens.tokens) {
+            this.validateTokenCategory(tokens.tokens.color, 'color', errors, warnings);
+            this.validateTokenCategory(tokens.tokens.font, 'font', errors, warnings);
+            this.validateTokenCategory(tokens.tokens.spacing, 'spacing', errors, warnings);
+            this.validateTokenCategory(tokens.tokens.shadow, 'shadow', errors, warnings);
+            this.validateTokenCategory(tokens.tokens.transition, 'transition', errors, warnings);
+            this.validateTokenCategory(tokens.tokens.breakpoint, 'breakpoint', errors, warnings);
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    /**
+     * Validates a specific token category
+     */
+    static validateTokenCategory(category, categoryName, errors, warnings) {
+        if (!category)
+            return;
+        if (typeof category !== 'object') {
+            errors.push({
+                path: `tokens.${categoryName}`,
+                message: `${categoryName} category must be an object`,
+                severity: 'error'
+            });
+            return;
+        }
+        this.validateTokenGroup(category, `tokens.${categoryName}`, errors, warnings);
+    }
+    /**
+     * Validates a token group recursively
+     */
+    static validateTokenGroup(group, path, errors, warnings) {
+        Object.entries(group).forEach(([key, value]) => {
+            const currentPath = `${path}.${key}`;
+            if (this.isToken(value)) {
+                this.validateToken(value, currentPath, errors, warnings);
+            }
+            else if (typeof value === 'object' && value !== null) {
+                // Recursively validate nested groups
+                this.validateTokenGroup(value, currentPath, errors, warnings);
+            }
+            else {
+                errors.push({
+                    path: currentPath,
+                    message: `Invalid token structure at ${currentPath}`,
+                    severity: 'error'
+                });
+            }
+        });
+    }
+    /**
+     * Validates an individual token
+     */
+    static validateToken(token, path, errors, warnings) {
+        // Check required properties
+        if (token.value === undefined || token.value === null) {
+            errors.push({
+                path,
+                message: 'Token value is required',
+                severity: 'error'
+            });
+        }
+        if (!token.type) {
+            errors.push({
+                path,
+                message: 'Token type is required',
+                severity: 'error'
+            });
+        }
+        else if (!this.isValidTokenType(token.type)) {
+            errors.push({
+                path,
+                message: `Invalid token type: ${token.type}`,
+                severity: 'error'
+            });
+        }
+        // Validate token type-specific values
+        this.validateTokenValue(token, path, errors, warnings);
+        // Check for missing descriptions (warning)
+        if (!token.description) {
+            warnings.push({
+                path,
+                message: 'Token description is missing',
+                suggestion: 'Add a description to improve token documentation'
+            });
+        }
+        // Check for missing tags (warning)
+        if (!token.tags || token.tags.length === 0) {
+            warnings.push({
+                path,
+                message: 'Token tags are missing',
+                suggestion: 'Add tags to improve token categorization and searchability'
+            });
+        }
+    }
+    /**
+     * Validates token value based on type
+     */
+    static validateTokenValue(token, path, errors, warnings) {
+        switch (token.type) {
+            case 'color':
+                this.validateColorToken(token, path, errors, warnings);
+                break;
+            case 'fontFamily':
+                this.validateFontFamilyToken(token, path, errors, warnings);
+                break;
+            case 'fontSize':
+                this.validateFontSizeToken(token, path, errors, warnings);
+                break;
+            case 'fontWeight':
+                this.validateFontWeightToken(token, path, errors, warnings);
+                break;
+            case 'lineHeight':
+                this.validateLineHeightToken(token, path, errors, warnings);
+                break;
+            case 'spacing':
+                this.validateSpacingToken(token, path, errors, warnings);
+                break;
+            case 'shadow':
+                this.validateShadowToken(token, path, errors, warnings);
+                break;
+            case 'transition':
+                this.validateTransitionToken(token, path, errors, warnings);
+                break;
+            case 'breakpoint':
+                this.validateBreakpointToken(token, path, errors, warnings);
+                break;
+        }
+    }
+    /**
+     * Validates color tokens
+     */
+    static validateColorToken(token, path, errors, warnings) {
+        const value = token.value;
+        if (typeof value !== 'string') {
+            errors.push({
+                path,
+                message: 'Color token value must be a string',
+                severity: 'error'
+            });
+            return;
+        }
+        // Check if it's a valid color format
+        if (!this.isValidColor(value)) {
+            errors.push({
+                path,
+                message: `Invalid color format: ${value}`,
+                severity: 'error'
+            });
+        }
+        // Check for semantic color consistency
+        if (token.category === 'color' && !token.semantic) {
+            warnings.push({
+                path,
+                message: 'Semantic color missing semantic property',
+                suggestion: 'Add semantic property (primary, secondary, accent, success, warning, error, neutral)'
+            });
+        }
+    }
+    /**
+     * Validates font family tokens
+     */
+    static validateFontFamilyToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value !== 'string') {
+            errors.push({
+                path,
+                message: 'Font family token value must be a string',
+                severity: 'error'
+            });
+        }
+        if (value.trim().length === 0) {
+            errors.push({
+                path,
+                message: 'Font family token value cannot be empty',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Validates font size tokens
+     */
+    static validateFontSizeToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value === 'number') {
+            if (value <= 0) {
+                errors.push({
+                    path,
+                    message: 'Font size token value must be positive',
+                    severity: 'error'
+                });
+            }
+        }
+        else if (typeof value === 'string') {
+            if (!this.isValidCSSUnit(value)) {
+                errors.push({
+                    path,
+                    message: `Invalid font size unit: ${value}`,
+                    severity: 'error'
+                });
+            }
+        }
+        else {
+            errors.push({
+                path,
+                message: 'Font size token value must be a number or valid CSS unit string',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Validates font weight tokens
+     */
+    static validateFontWeightToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value === 'number') {
+            if (value < 100 || value > 900 || value % 100 !== 0) {
+                errors.push({
+                    path,
+                    message: 'Font weight token value must be a multiple of 100 between 100 and 900',
+                    severity: 'error'
+                });
+            }
+        }
+        else if (typeof value === 'string') {
+            const validWeights = ['normal', 'bold', 'lighter', 'bolder'];
+            if (!validWeights.includes(value)) {
+                errors.push({
+                    path,
+                    message: `Invalid font weight value: ${value}`,
+                    severity: 'error'
+                });
+            }
+        }
+        else {
+            errors.push({
+                path,
+                message: 'Font weight token value must be a number or valid string',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Validates line height tokens
+     */
+    static validateLineHeightToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value === 'number') {
+            if (value <= 0) {
+                errors.push({
+                    path,
+                    message: 'Line height token value must be positive',
+                    severity: 'error'
+                });
+            }
+        }
+        else if (typeof value === 'string') {
+            if (!this.isValidCSSUnit(value) && value !== 'normal') {
+                errors.push({
+                    path,
+                    message: `Invalid line height value: ${value}`,
+                    severity: 'error'
+                });
+            }
+        }
+        else {
+            errors.push({
+                path,
+                message: 'Line height token value must be a number or valid CSS unit string',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Validates spacing tokens
+     */
+    static validateSpacingToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value !== 'number') {
+            errors.push({
+                path,
+                message: 'Spacing token value must be a number',
+                severity: 'error'
+            });
+            return;
+        }
+        if (value < 0) {
+            errors.push({
+                path,
+                message: 'Spacing token value cannot be negative',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Validates shadow tokens
+     */
+    static validateShadowToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value !== 'string') {
+            errors.push({
+                path,
+                message: 'Shadow token value must be a string',
+                severity: 'error'
+            });
+        }
+        if (value.trim().length === 0) {
+            errors.push({
+                path,
+                message: 'Shadow token value cannot be empty',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Validates transition tokens
+     */
+    static validateTransitionToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value !== 'string') {
+            errors.push({
+                path,
+                message: 'Transition token value must be a string',
+                severity: 'error'
+            });
+        }
+        if (value.trim().length === 0) {
+            errors.push({
+                path,
+                message: 'Transition token value cannot be empty',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Validates breakpoint tokens
+     */
+    static validateBreakpointToken(token, path, errors, _warnings) {
+        const value = token.value;
+        if (typeof value !== 'number') {
+            errors.push({
+                path,
+                message: 'Breakpoint token value must be a number',
+                severity: 'error'
+            });
+            return;
+        }
+        if (value < 0) {
+            errors.push({
+                path,
+                message: 'Breakpoint token value cannot be negative',
+                severity: 'error'
+            });
+        }
+    }
+    /**
+     * Checks if a value is a valid token
+     */
+    static isToken(value) {
+        return value &&
+            typeof value === 'object' &&
+            'value' in value &&
+            'type' in value;
+    }
+    /**
+     * Checks if a token type is valid
+     */
+    static isValidTokenType(type) {
+        const validTypes = [
+            'color', 'fontFamily', 'fontSize', 'fontWeight', 'lineHeight',
+            'letterSpacing', 'spacing', 'borderRadius', 'shadow', 'transition',
+            'zIndex', 'breakpoint'
+        ];
+        return validTypes.includes(type);
+    }
+    /**
+     * Checks if a color value is valid
+     */
+    static isValidColor(color) {
+        // Basic color validation - hex, rgb, rgba, named colors
+        const colorRegex = /^(#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})|rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)|rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[\d.]+\s*\)|transparent|currentColor)$/;
+        return colorRegex.test(color);
+    }
+    /**
+     * Checks if a CSS unit is valid
+     */
+    static isValidCSSUnit(value) {
+        const unitRegex = /^[\d.]+(px|em|rem|vh|vw|%|ch|ex|in|cm|mm|pt|pc)$/;
+        return unitRegex.test(value);
+    }
+}