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

package/dist/themes/validation.js

@@ -0,0 +1,627 @@
+// Theme Validation System
+// This file provides comprehensive validation for theme configurations
+import { ColorManager } from './colorManager';
+export class ThemeValidator {
+    /**
+     * Validate a complete theme configuration
+     */
+    static validateTheme(theme) {
+        const errors = [];
+        const warnings = [];
+        // Validate required fields
+        this.validateRequiredFields(theme, errors);
+        // Phase 1 Enhancement: Validate new foundation primitives
+        this.validatePhase1RequiredFields(theme, errors);
+        this.validateBreakpointSystem(theme, errors, warnings);
+        this.validateContentDensitySystem(theme, errors, warnings);
+        this.validateResponsiveTypographySystem(theme, errors, warnings);
+        // Validate color formats
+        this.validateColorFormats(theme, errors, warnings);
+        // Validate color contrast
+        this.validateColorContrast(theme, warnings);
+        // Validate font configurations
+        this.validateFontConfigurations(theme, warnings);
+        // Validate spacing scales
+        this.validateSpacingScales(theme, warnings);
+        // Validate navigation configurations
+        this.validateNavigationConfigurations(theme, errors, warnings);
+        // Validate metadata
+        this.validateMetadata(theme, errors, warnings);
+        // Validate semantic consistency
+        this.validateSemanticConsistency(theme, warnings);
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    /**
+     * Validate that all required fields are present
+     */
+    static validateRequiredFields(theme, errors) {
+        for (const fieldPath of this.REQUIRED_FIELDS) {
+            const value = this.getNestedValue(theme, fieldPath);
+            if (value === undefined || value === null || value === '') {
+                errors.push({
+                    path: fieldPath,
+                    message: `Required field '${fieldPath}' is missing or empty`,
+                    severity: 'error'
+                });
+            }
+        }
+    }
+    /**
+     * Validate color format consistency
+     */
+    static validateColorFormats(theme, errors, warnings) {
+        const colorFields = this.getAllColorFields(theme);
+        const formats = new Set();
+        for (const { path, value } of colorFields) {
+            if (typeof value === 'string') {
+                // Use colorManager for validation
+                if (!ColorManager.isValidColor(value)) {
+                    errors.push({
+                        path,
+                        message: `Invalid color format: '${value}'. Expected hex, rgb, hsl, or named color format`,
+                        severity: 'error'
+                    });
+                }
+                else {
+                    const format = this.detectColorFormat(value);
+                    if (format) {
+                        formats.add(format);
+                    }
+                }
+            }
+        }
+        // Warn if multiple color formats are used
+        if (formats.size > 1) {
+            warnings.push({
+                path: 'colors',
+                message: `Multiple color formats detected: ${Array.from(formats).join(', ')}. Consider using a consistent format for better maintainability`,
+                severity: 'warning'
+            });
+        }
+    }
+    /**
+     * Validate color contrast ratios
+     */
+    static validateColorContrast(theme, warnings) {
+        const textColors = [
+            theme.colors?.text?.primary,
+            theme.colors?.text?.secondary,
+            theme.colors?.text?.muted
+        ].filter(Boolean);
+        const backgroundColors = [
+            theme.colors?.surface?.background,
+            theme.colors?.surface?.surface
+        ].filter(Boolean);
+        for (const textColor of textColors) {
+            for (const bgColor of backgroundColors) {
+                if (textColor && bgColor) {
+                    // Use colorManager for contrast checking
+                    const accessibility = ColorManager.checkColorContrast(textColor, bgColor);
+                    if (!accessibility.aa) {
+                        warnings.push({
+                            path: 'colors',
+                            message: `Color contrast ratio ${accessibility.contrastRatio.toFixed(2)}:1 between '${textColor}' and '${bgColor}' is below WCAG AA standard (4.5:1)`,
+                            severity: 'warning'
+                        });
+                    }
+                    else if (!accessibility.aaa) {
+                        warnings.push({
+                            path: 'colors',
+                            message: `Color contrast ratio ${accessibility.contrastRatio.toFixed(2)}:1 between '${textColor}' and '${bgColor}' is below WCAG AAA standard (7:1)`,
+                            severity: 'info'
+                        });
+                    }
+                    // Add accessibility recommendations
+                    if (accessibility.recommended.length > 0) {
+                        warnings.push({
+                            path: 'colors',
+                            message: `Accessibility recommendations: ${accessibility.recommended.join('; ')}`,
+                            severity: 'info'
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Validate font configurations
+     */
+    static validateFontConfigurations(theme, warnings) {
+        // Validate font weights
+        if (theme.fonts?.primary?.weights) {
+            for (const weight of theme.fonts.primary.weights) {
+                if (!this.FONT_WEIGHTS.includes(weight)) {
+                    warnings.push({
+                        path: 'fonts.primary.weights',
+                        message: `Font weight ${weight} is not a standard CSS font weight. Consider using: ${this.FONT_WEIGHTS.join(', ')}`,
+                        severity: 'warning'
+                    });
+                }
+            }
+        }
+        // Validate font size scale
+        if (theme.fonts?.primary?.sizes) {
+            const sizes = Object.values(theme.fonts.primary.sizes);
+            const numericSizes = sizes.map(size => parseFloat(size)).filter(size => !isNaN(size));
+            if (numericSizes.length > 1) {
+                for (let i = 1; i < numericSizes.length; i++) {
+                    if (numericSizes[i] <= numericSizes[i - 1]) {
+                        warnings.push({
+                            path: 'fonts.primary.sizes',
+                            message: `Font sizes should be in ascending order. Found: ${numericSizes[i - 1]} followed by ${numericSizes[i]}`,
+                            severity: 'warning'
+                        });
+                    }
+                }
+            }
+        }
+        // Validate font family fallbacks
+        if (theme.fonts?.primary?.family) {
+            const family = theme.fonts.primary.family;
+            if (!family.includes(',') && !family.includes('"') && !family.includes("'")) {
+                warnings.push({
+                    path: 'fonts.primary.family',
+                    message: `Font family '${family}' should include fallback fonts for better cross-platform compatibility`,
+                    severity: 'warning'
+                });
+            }
+        }
+    }
+    /**
+     * Validate spacing scales
+     */
+    static validateSpacingScales(theme, warnings) {
+        if (theme.spacing?.scale) {
+            const scales = Object.values(theme.spacing.scale);
+            const numericScales = scales.map(scale => parseFloat(scale)).filter(scale => !isNaN(scale));
+            if (numericScales.length > 1) {
+                // Check if spacing follows a consistent pattern
+                const ratios = [];
+                for (let i = 1; i < numericScales.length; i++) {
+                    ratios.push(numericScales[i] / numericScales[i - 1]);
+                }
+                const avgRatio = ratios.reduce((sum, ratio) => sum + ratio, 0) / ratios.length;
+                const variance = ratios.reduce((sum, ratio) => sum + Math.pow(ratio - avgRatio, 2), 0) / ratios.length;
+                if (variance > 0.1) { // High variance indicates inconsistent spacing
+                    warnings.push({
+                        path: 'spacing.scale',
+                        message: `Spacing scale appears inconsistent. Consider using a mathematical scale (e.g., 1.5x or 2x multiplier) for better visual harmony`,
+                        severity: 'warning'
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Validate navigation configurations
+     */
+    static validateNavigationConfigurations(theme, _errors, warnings) {
+        if (theme.navigation) {
+            // Validate layout and behavior combinations
+            const { layout, behavior } = theme.navigation;
+            if (layout === 'sidebar' && behavior === 'floating') {
+                warnings.push({
+                    path: 'navigation',
+                    message: 'Sidebar layout with floating behavior may cause usability issues. Consider using static or sticky behavior',
+                    severity: 'warning'
+                });
+            }
+            if (layout === 'tabs' && behavior === 'overlay') {
+                warnings.push({
+                    path: 'navigation',
+                    message: 'Tab layout with overlay behavior is unusual. Consider using static or sticky behavior',
+                    severity: 'warning'
+                });
+            }
+            // Validate responsive behavior
+            if (theme.navigation.responsive === 'desktop-first' && layout === 'horizontal') {
+                warnings.push({
+                    path: 'navigation',
+                    message: 'Desktop-first responsive approach with horizontal layout may cause mobile usability issues',
+                    severity: 'warning'
+                });
+            }
+        }
+    }
+    /**
+     * Validate metadata
+     */
+    static validateMetadata(theme, errors, warnings) {
+        if (theme.meta) {
+            // Validate version format
+            if (theme.meta.version && !/^\d+\.\d+\.\d+/.test(theme.meta.version)) {
+                warnings.push({
+                    path: 'meta.version',
+                    message: `Version '${theme.meta.version}' should follow semantic versioning (e.g., 1.0.0)`,
+                    severity: 'warning'
+                });
+            }
+            // Validate category
+            if (theme.meta.category && !['brand', 'enterprise', 'custom', 'accessibility'].includes(theme.meta.category)) {
+                errors.push({
+                    path: 'meta.category',
+                    message: `Invalid category '${theme.meta.category}'. Must be one of: brand, enterprise, custom, accessibility`,
+                    severity: 'error'
+                });
+            }
+            // Validate tags
+            if (theme.meta.tags && theme.meta.tags.length > 10) {
+                warnings.push({
+                    path: 'meta.tags',
+                    message: `Theme has ${theme.meta.tags.length} tags. Consider limiting to 10 tags for better organization`,
+                    severity: 'warning'
+                });
+            }
+        }
+    }
+    /**
+     * Validate semantic consistency
+     */
+    static validateSemanticConsistency(theme, warnings) {
+        // Check if semantic colors are distinct from primary colors
+        if (theme.colors?.semantic && theme.colors?.primary) {
+            const semanticColors = Object.values(theme.colors.semantic);
+            const primaryColors = Object.values(theme.colors.primary);
+            for (const semanticColor of semanticColors) {
+                for (const primaryColor of primaryColors) {
+                    if (this.colorsAreSimilar(semanticColor, primaryColor)) {
+                        warnings.push({
+                            path: 'colors.semantic',
+                            message: `Semantic color '${semanticColor}' is too similar to primary color '${primaryColor}'. Consider using more distinct colors for better semantic clarity`,
+                            severity: 'warning'
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Helper: Get nested value from object using dot notation
+     */
+    static getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => current?.[key], obj);
+    }
+    /**
+     * Helper: Get all color fields from theme
+     */
+    static getAllColorFields(theme) {
+        const fields = [];
+        const traverseColors = (obj, path) => {
+            if (obj && typeof obj === 'object') {
+                for (const [key, value] of Object.entries(obj)) {
+                    const currentPath = path ? `${path}.${key}` : key;
+                    if (typeof value === 'string' && this.isColorValue(value)) {
+                        fields.push({ path: currentPath, value });
+                    }
+                    else if (typeof value === 'object') {
+                        traverseColors(value, currentPath);
+                    }
+                }
+            }
+        };
+        traverseColors(theme.colors, 'colors');
+        return fields;
+    }
+    /**
+     * Helper: Detect color format
+     */
+    static detectColorFormat(color) {
+        for (const [format, regex] of Object.entries(this.COLOR_FORMATS)) {
+            if (regex.test(color)) {
+                return format;
+            }
+        }
+        return null;
+    }
+    /**
+     * Helper: Check if value looks like a color
+     */
+    static isColorValue(value) {
+        // Accept any string that might be a color, let detectColorFormat validate it
+        return value.startsWith('#') ||
+            value.startsWith('rgb') ||
+            value.startsWith('hsl') ||
+            value.startsWith('var(--') ||
+            value === 'transparent' ||
+            value === 'currentColor' ||
+            value === 'inherit' ||
+            // Also accept any string that might be a color (for validation)
+            value.includes('color') ||
+            value.includes('invalid');
+    }
+    /**
+     * Helper: Calculate color contrast ratio
+     */
+    static calculateColorContrast(color1, color2) {
+        try {
+            const luminance1 = this.getLuminance(color1);
+            const luminance2 = this.getLuminance(color2);
+            const lighter = Math.max(luminance1, luminance2);
+            const darker = Math.min(luminance1, luminance2);
+            return (lighter + 0.05) / (darker + 0.05);
+        }
+        catch {
+            return 1; // Default fallback
+        }
+    }
+    /**
+     * Helper: Get luminance of a color
+     */
+    static getLuminance(color) {
+        // Handle CSS variables and other formats
+        if (color.startsWith('var(--') || color === 'transparent' || color === 'currentColor' || color === 'inherit') {
+            return 0.5; // Default fallback
+        }
+        // Convert hex to RGB and calculate luminance
+        try {
+            const hex = color.replace('#', '');
+            const r = parseInt(hex.substr(0, 2), 16) / 255;
+            const g = parseInt(hex.substr(2, 2), 16) / 255;
+            const b = parseInt(hex.substr(4, 2), 16) / 255;
+            const [rs, gs, bs] = [r, g, b].map(c => {
+                if (c <= 0.03928)
+                    return c / 12.92;
+                return Math.pow((c + 0.055) / 1.055, 2.4);
+            });
+            return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+        }
+        catch {
+            return 0.5; // Default fallback
+        }
+    }
+    /**
+     * Helper: Check if two colors are similar
+     */
+    static colorsAreSimilar(color1, color2) {
+        try {
+            const contrast = this.calculateColorContrast(color1, color2);
+            return contrast < 2.0; // Very low contrast indicates similar colors
+        }
+        catch {
+            return false;
+        }
+    }
+    // Phase 1 Enhancement: New validation methods for foundation primitives
+    /**
+     * Validate Phase 1 required fields
+     */
+    static validatePhase1RequiredFields(theme, errors) {
+        this.PHASE1_REQUIRED_FIELDS.forEach(fieldPath => {
+            const value = this.getNestedValue(theme, fieldPath);
+            if (value === undefined || value === null || value === '') {
+                errors.push({
+                    path: fieldPath,
+                    message: `Required Phase 1 field '${fieldPath}' is missing`,
+                    severity: 'critical'
+                });
+            }
+        });
+    }
+    /**
+     * Validate enhanced breakpoint system
+     */
+    static validateBreakpointSystem(theme, errors, warnings) {
+        if (!theme.breakpoints) {
+            errors.push({
+                path: 'breakpoints',
+                message: 'Breakpoint system is required for Phase 1 compliance',
+                severity: 'critical'
+            });
+            return;
+        }
+        const requiredBreakpoints = ['xs', 'sm', 'md', 'lg', 'xl', '2xl', '3xl'];
+        const expectedValues = {
+            xs: '475px',
+            sm: '640px',
+            md: '768px',
+            lg: '1024px',
+            xl: '1280px',
+            '2xl': '1536px',
+            '3xl': '1920px'
+        };
+        requiredBreakpoints.forEach(breakpoint => {
+            const value = theme.breakpoints[breakpoint];
+            if (!value) {
+                errors.push({
+                    path: `breakpoints.${breakpoint}`,
+                    message: `Breakpoint '${breakpoint}' is required`,
+                    severity: 'error'
+                });
+            }
+            else {
+                // Validate format (should end with 'px')
+                if (!value.endsWith('px')) {
+                    warnings.push({
+                        path: `breakpoints.${breakpoint}`,
+                        message: `Breakpoint '${breakpoint}' should use px units`,
+                        severity: 'warning'
+                    });
+                }
+                // Validate expected values for consistency
+                if (value !== expectedValues[breakpoint]) {
+                    warnings.push({
+                        path: `breakpoints.${breakpoint}`,
+                        message: `Breakpoint '${breakpoint}' value '${value}' differs from specification '${expectedValues[breakpoint]}'`,
+                        severity: 'info'
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * Validate content density system
+     */
+    static validateContentDensitySystem(theme, errors, warnings) {
+        if (!theme.contentDensity) {
+            errors.push({
+                path: 'contentDensity',
+                message: 'Content density system is required for Phase 1 compliance',
+                severity: 'critical'
+            });
+            return;
+        }
+        const densityLevels = ['compact', 'comfortable', 'spacious'];
+        densityLevels.forEach(level => {
+            const density = theme.contentDensity[level];
+            if (!density) {
+                errors.push({
+                    path: `contentDensity.${level}`,
+                    message: `Density level '${level}' is required`,
+                    severity: 'error'
+                });
+                return;
+            }
+            // Validate spacing structure
+            if (!density.spacing) {
+                errors.push({
+                    path: `contentDensity.${level}.spacing`,
+                    message: `Spacing configuration is required for density level '${level}'`,
+                    severity: 'error'
+                });
+            }
+            else {
+                ['section', 'component', 'element'].forEach(spacingType => {
+                    const spacingValue = density.spacing[spacingType];
+                    if (!spacingValue) {
+                        warnings.push({
+                            path: `contentDensity.${level}.spacing.${spacingType}`,
+                            message: `Spacing type '${spacingType}' is recommended for density level '${level}'`,
+                            severity: 'warning'
+                        });
+                    }
+                });
+            }
+            // Validate typography structure
+            if (!density.typography) {
+                errors.push({
+                    path: `contentDensity.${level}.typography`,
+                    message: `Typography configuration is required for density level '${level}'`,
+                    severity: 'error'
+                });
+            }
+            else {
+                if (typeof density.typography.scale !== 'number') {
+                    errors.push({
+                        path: `contentDensity.${level}.typography.scale`,
+                        message: `Typography scale must be a number for density level '${level}'`,
+                        severity: 'error'
+                    });
+                }
+                if (typeof density.typography.lineHeight !== 'number') {
+                    errors.push({
+                        path: `contentDensity.${level}.typography.lineHeight`,
+                        message: `Typography lineHeight must be a number for density level '${level}'`,
+                        severity: 'error'
+                    });
+                }
+            }
+            // Validate touch targets for mobile-focused densities
+            if (level === 'compact' && !density.touchTargets) {
+                warnings.push({
+                    path: `contentDensity.${level}.touchTargets`,
+                    message: `Touch targets configuration is recommended for compact density level`,
+                    severity: 'warning'
+                });
+            }
+        });
+    }
+    /**
+     * Validate responsive typography system
+     */
+    static validateResponsiveTypographySystem(theme, errors, warnings) {
+        if (!theme.responsiveTypography) {
+            errors.push({
+                path: 'responsiveTypography',
+                message: 'Responsive typography system is required for Phase 1 compliance',
+                severity: 'critical'
+            });
+            return;
+        }
+        const typographyLevels = ['heading1', 'heading2', 'heading3', 'heading4', 'heading5', 'heading6', 'body', 'bodyLarge', 'bodySmall', 'caption'];
+        const breakpoints = ['xs', 'sm', 'md', 'lg', 'xl', '2xl', '3xl'];
+        typographyLevels.forEach(level => {
+            const typography = theme.responsiveTypography[level];
+            if (!typography) {
+                warnings.push({
+                    path: `responsiveTypography.${level}`,
+                    message: `Typography level '${level}' is recommended for complete responsive scaling`,
+                    severity: 'warning'
+                });
+                return;
+            }
+            breakpoints.forEach(breakpoint => {
+                const value = typography[breakpoint];
+                if (!value) {
+                    warnings.push({
+                        path: `responsiveTypography.${level}.${breakpoint}`,
+                        message: `Breakpoint '${breakpoint}' is missing for typography level '${level}'`,
+                        severity: 'warning'
+                    });
+                }
+                else {
+                    // Validate format (should end with 'px' or be a number)
+                    if (typeof value === 'string' && !value.endsWith('px') && !value.endsWith('rem') && !value.endsWith('em')) {
+                        warnings.push({
+                            path: `responsiveTypography.${level}.${breakpoint}`,
+                            message: `Typography value should include units (px, rem, or em) for '${level}.${breakpoint}'`,
+                            severity: 'warning'
+                        });
+                    }
+                }
+            });
+        });
+    }
+}
+ThemeValidator.REQUIRED_FIELDS = [
+    'fonts.primary.family',
+    'fonts.primary.sizes.md',
+    'colors.primary.500',
+    'colors.semantic.success',
+    'colors.semantic.error',
+    'colors.semantic.warning',
+    'colors.semantic.info',
+    'colors.surface.background',
+    'colors.text.primary',
+    'spacing.scale.md',
+    'shadows.md',
+    'transitions.duration.normal',
+    'transitions.easing.ease',
+    'meta.name',
+    'meta.description',
+    'meta.version'
+];
+// Phase 1 Enhancement: Required fields for new foundation primitives
+ThemeValidator.PHASE1_REQUIRED_FIELDS = [
+    // Enhanced Breakpoint System
+    'breakpoints.xs',
+    'breakpoints.sm',
+    'breakpoints.md',
+    'breakpoints.lg',
+    'breakpoints.xl',
+    'breakpoints.2xl',
+    'breakpoints.3xl',
+    // Content Density System
+    'contentDensity.compact.spacing.section',
+    'contentDensity.compact.typography.scale',
+    'contentDensity.comfortable.spacing.section',
+    'contentDensity.comfortable.typography.scale',
+    'contentDensity.spacious.spacing.section',
+    'contentDensity.spacious.typography.scale',
+    // Responsive Typography System
+    'responsiveTypography.heading1.xs',
+    'responsiveTypography.heading1.3xl',
+    'responsiveTypography.body.xs',
+    'responsiveTypography.body.3xl'
+];
+ThemeValidator.COLOR_FORMATS = {
+    hex: /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/,
+    rgb: /^rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)$/,
+    rgba: /^rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[\d.]+\s*\)$/,
+    hsl: /^hsl\(\s*\d+\s*,\s*\d+%\s*,\s*\d+%\s*\)$/,
+    hsla: /^hsla\(\s*\d+\s*,\s*\d+%\s*,\s*\d+%\s*,\s*[\d.]+\s*\)$/
+};
+ThemeValidator.FONT_WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900];

package/dist/tokens/index.d.ts

@@ -0,0 +1,11 @@
+export type { DesignToken, TokenType, ColorToken, FontToken, SpacingToken, ShadowToken, TransitionToken, TokenGroup, ThemeTokens, TokenExportOptions } from './types';
+export { TokenGenerator } from './tokenGenerator';
+export { TokenExporter } from './tokenExporter';
+export type { ValidationResult, ValidationError, ValidationWarning } from './tokenValidator';
+export { TokenValidator } from './tokenValidator';
+export type { TokenManagerOptions } from './tokenManager';
+export { TokenManager } from './tokenManager';
+import { TokenManager, type TokenManagerOptions } from './tokenManager.js';
+export declare const createTokenManager: (options?: TokenManagerOptions) => TokenManager;
+export declare const defaultTokenManager: TokenManager;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tokens/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,eAAe,EACf,UAAU,EACV,WAAW,EACX,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC7F,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,eAAO,MAAM,kBAAkB,GAAI,UAAU,mBAAmB,iBAA8B,CAAC;AAG/F,eAAO,MAAM,mBAAmB,cAAqB,CAAC"}

package/dist/tokens/index.esm.js

@@ -0,0 +1,11 @@
+// Token generation
+export { TokenGenerator } from './tokenGenerator';
+// Token export functionality
+export { TokenExporter } from './tokenExporter';
+export { TokenValidator } from './tokenValidator';
+export { TokenManager } from './tokenManager';
+// Convenience functions
+import { TokenManager } from './tokenManager.js';
+export const createTokenManager = (options) => new TokenManager(options);
+// Default token manager instance
+export const defaultTokenManager = new TokenManager();

package/dist/tokens/index.js

@@ -0,0 +1,11 @@
+// Token generation
+export { TokenGenerator } from './tokenGenerator';
+// Token export functionality
+export { TokenExporter } from './tokenExporter';
+export { TokenValidator } from './tokenValidator';
+export { TokenManager } from './tokenManager';
+// Convenience functions
+import { TokenManager } from './tokenManager.js';
+export const createTokenManager = (options) => new TokenManager(options);
+// Default token manager instance
+export const defaultTokenManager = new TokenManager();