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

package/dist/tokens/tokenValidator.esm.js

@@ -1,50 +1,54 @@
-
+import type { ThemeTokens, DesignToken, TokenType } from './types';
 
 export interface ValidationResult {
-  isValid;
-  errors];
-  warnings];
+  isValid: boolean;
+  errors: ValidationError[];
+  warnings: ValidationWarning[];
 }
 
 export interface ValidationError {
-  path;
-  message;
-  severity;
+  path: string;
+  message: string;
+  severity: 'error' | 'critical';
 }
 
 export interface ValidationWarning {
-  path;
-  message;
-  suggestion?;
+  path: string;
+  message: string;
+  suggestion?: string;
 }
 
 export class TokenValidator {
   /**
    * Validates a complete theme tokens object
    */
-  static validateTokens(tokens)] = [];
-    const warnings] = [];
+  static validateTokens(tokens: ThemeTokens): ValidationResult {
+    const errors: ValidationError[] = [];
+    const warnings: ValidationWarning[] = [];
 
     // Validate basic structure
     if (!tokens.theme) {
       errors.push({
-        path,
-        message,
-        severity});
+        path: 'theme',
+        message: 'Theme name is required',
+        severity: 'critical'
+      });
     }
 
     if (!tokens.version) {
       errors.push({
-        path,
-        message,
-        severity});
+        path: 'version',
+        message: 'Theme version is required',
+        severity: 'critical'
+      });
     }
 
     if (!tokens.tokens) {
       errors.push({
-        path,
-        message,
-        severity});
+        path: 'tokens',
+        message: 'Tokens object is required',
+        severity: 'critical'
+      });
     }
 
     // Validate token categories
@@ -58,7 +62,7 @@ export class TokenValidator {
     }
 
     return {
-      isValid=== 0,
+      isValid: errors.length === 0,
       errors,
       warnings
     };
@@ -68,18 +72,19 @@ export class TokenValidator {
    * Validates a specific token category
    */
   private static validateTokenCategory(
-    category, 
-    categoryName, 
-    errors], 
-    warnings]
+    category: any, 
+    categoryName: string, 
+    errors: ValidationError[], 
+    warnings: ValidationWarning[]
   ) {
     if (!category) return;
 
     if (typeof category !== 'object') {
       errors.push({
-        path}`,
-        message} category must be an object`,
-        severity});
+        path: `tokens.${categoryName}`,
+        message: `${categoryName} category must be an object`,
+        severity: 'error'
+      });
       return;
     }
 
@@ -90,10 +95,10 @@ export class TokenValidator {
    * Validates a token group recursively
    */
   private static validateTokenGroup(
-    group, 
-    path, 
-    errors], 
-    warnings]
+    group: any, 
+    path: string, 
+    errors: ValidationError[], 
+    warnings: ValidationWarning[]
   ) {
     Object.entries(group).forEach(([key, value]) => {
       const currentPath = `${path}.${key}`;
@@ -105,9 +110,10 @@ export class TokenValidator {
         this.validateTokenGroup(value, currentPath, errors, warnings);
       } else {
         errors.push({
-          path,
-          message}`,
-          severity});
+          path: currentPath,
+          message: `Invalid token structure at ${currentPath}`,
+          severity: 'error'
+        });
       }
     });
   }
@@ -116,29 +122,32 @@ export class TokenValidator {
    * Validates an individual token
    */
   private static validateToken(
-    token, 
-    path, 
-    errors], 
-    warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    warnings: ValidationWarning[]
   ) {
     // Check required properties
     if (token.value === undefined || token.value === null) {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Token value is required',
+        severity: 'error'
+      });
     }
 
     if (!token.type) {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Token type is required',
+        severity: 'error'
+      });
     } else if (!this.isValidTokenType(token.type)) {
       errors.push({
         path,
-        message}`,
-        severity});
+        message: `Invalid token type: ${token.type}`,
+        severity: 'error'
+      });
     }
 
     // Validate token type-specific values
@@ -148,16 +157,18 @@ export class TokenValidator {
     if (!token.description) {
       warnings.push({
         path,
-        message,
-        suggestion});
+        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,
-        suggestion});
+        message: 'Token tags are missing',
+        suggestion: 'Add tags to improve token categorization and searchability'
+      });
     }
   }
 
@@ -165,29 +176,38 @@ export class TokenValidator {
    * Validates token value based on type
    */
   private static validateTokenValue(
-    token, 
-    path, 
-    errors], 
-    warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    warnings: ValidationWarning[]
   ) {
     switch (token.type) {
-      case 'color', path, errors, warnings);
+      case 'color':
+        this.validateColorToken(token, path, errors, warnings);
         break;
-      case 'fontFamily', path, errors, warnings);
+      case 'fontFamily':
+        this.validateFontFamilyToken(token, path, errors, warnings);
         break;
-      case 'fontSize', path, errors, warnings);
+      case 'fontSize':
+        this.validateFontSizeToken(token, path, errors, warnings);
         break;
-      case 'fontWeight', path, errors, warnings);
+      case 'fontWeight':
+        this.validateFontWeightToken(token, path, errors, warnings);
         break;
-      case 'lineHeight', path, errors, warnings);
+      case 'lineHeight':
+        this.validateLineHeightToken(token, path, errors, warnings);
         break;
-      case 'spacing', path, errors, warnings);
+      case 'spacing':
+        this.validateSpacingToken(token, path, errors, warnings);
         break;
-      case 'shadow', path, errors, warnings);
+      case 'shadow':
+        this.validateShadowToken(token, path, errors, warnings);
         break;
-      case 'transition', path, errors, warnings);
+      case 'transition':
+        this.validateTransitionToken(token, path, errors, warnings);
         break;
-      case 'breakpoint', path, errors, warnings);
+      case 'breakpoint':
+        this.validateBreakpointToken(token, path, errors, warnings);
         break;
     }
   }
@@ -196,18 +216,19 @@ export class TokenValidator {
    * Validates color tokens
    */
   private static validateColorToken(
-    token, 
-    path, 
-    errors], 
-    warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    warnings: ValidationWarning[]
   ) {
     const value = token.value as string;
     
     if (typeof value !== 'string') {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Color token value must be a string',
+        severity: 'error'
+      });
       return;
     }
 
@@ -215,16 +236,17 @@ export class TokenValidator {
     if (!this.isValidColor(value)) {
       errors.push({
         path,
-        message}`,
-        severity});
+        message: `Invalid color format: ${value}`,
+        severity: 'error'
+      });
     }
 
     // Check for semantic color consistency
     if (token.category === 'color' && !(token as any).semantic) {
       warnings.push({
         path,
-        message,
-        suggestion, secondary, accent, success, warning, error, neutral)'
+        message: 'Semantic color missing semantic property',
+        suggestion: 'Add semantic property (primary, secondary, accent, success, warning, error, neutral)'
       });
     }
   }
@@ -233,25 +255,27 @@ export class TokenValidator {
    * Validates font family tokens
    */
   private static validateFontFamilyToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as string;
     
     if (typeof value !== 'string') {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Font family token value must be a string',
+        severity: 'error'
+      });
     }
 
     if (value.trim().length === 0) {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Font family token value cannot be empty',
+        severity: 'error'
+      });
     }
   }
 
@@ -259,10 +283,10 @@ export class TokenValidator {
    * Validates font size tokens
    */
   private static validateFontSizeToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as string | number;
     
@@ -270,21 +294,24 @@ export class TokenValidator {
       if (value <= 0) {
         errors.push({
           path,
-          message,
-          severity});
+          message: 'Font size token value must be positive',
+          severity: 'error'
+        });
       }
     } else if (typeof value === 'string') {
       if (!this.isValidCSSUnit(value)) {
         errors.push({
           path,
-          message}`,
-          severity});
+          message: `Invalid font size unit: ${value}`,
+          severity: 'error'
+        });
       }
     } else {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Font size token value must be a number or valid CSS unit string',
+        severity: 'error'
+      });
     }
   }
 
@@ -292,10 +319,10 @@ export class TokenValidator {
    * Validates font weight tokens
    */
   private static validateFontWeightToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as string | number;
     
@@ -303,22 +330,25 @@ export class TokenValidator {
       if (value < 100 || value > 900 || value % 100 !== 0) {
         errors.push({
           path,
-          message,
-          severity});
+          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}`,
-          severity});
+          message: `Invalid font weight value: ${value}`,
+          severity: 'error'
+        });
       }
     } else {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Font weight token value must be a number or valid string',
+        severity: 'error'
+      });
     }
   }
 
@@ -326,10 +356,10 @@ export class TokenValidator {
    * Validates line height tokens
    */
   private static validateLineHeightToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as string | number;
     
@@ -337,21 +367,24 @@ export class TokenValidator {
       if (value <= 0) {
         errors.push({
           path,
-          message,
-          severity});
+          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}`,
-          severity});
+          message: `Invalid line height value: ${value}`,
+          severity: 'error'
+        });
       }
     } else {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Line height token value must be a number or valid CSS unit string',
+        severity: 'error'
+      });
     }
   }
 
@@ -359,26 +392,28 @@ export class TokenValidator {
    * Validates spacing tokens
    */
   private static validateSpacingToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as number;
     
     if (typeof value !== 'number') {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Spacing token value must be a number',
+        severity: 'error'
+      });
       return;
     }
 
     if (value < 0) {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Spacing token value cannot be negative',
+        severity: 'error'
+      });
     }
   }
 
@@ -386,25 +421,27 @@ export class TokenValidator {
    * Validates shadow tokens
    */
   private static validateShadowToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as string;
     
     if (typeof value !== 'string') {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Shadow token value must be a string',
+        severity: 'error'
+      });
     }
 
     if (value.trim().length === 0) {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Shadow token value cannot be empty',
+        severity: 'error'
+      });
     }
   }
 
@@ -412,25 +449,27 @@ export class TokenValidator {
    * Validates transition tokens
    */
   private static validateTransitionToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as string;
     
     if (typeof value !== 'string') {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Transition token value must be a string',
+        severity: 'error'
+      });
     }
 
     if (value.trim().length === 0) {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Transition token value cannot be empty',
+        severity: 'error'
+      });
     }
   }
 
@@ -438,33 +477,37 @@ export class TokenValidator {
    * Validates breakpoint tokens
    */
   private static validateBreakpointToken(
-    token, 
-    path, 
-    errors], 
-    _warnings]
+    token: DesignToken, 
+    path: string, 
+    errors: ValidationError[], 
+    _warnings: ValidationWarning[]
   ) {
     const value = token.value as number;
     
     if (typeof value !== 'number') {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Breakpoint token value must be a number',
+        severity: 'error'
+      });
       return;
     }
 
     if (value < 0) {
       errors.push({
         path,
-        message,
-        severity});
+        message: 'Breakpoint token value cannot be negative',
+        severity: 'error'
+      });
     }
   }
 
   /**
    * Checks if a value is a valid token
    */
-  private static isToken(value)=== 'object' && 
+  private static isToken(value: any): value is DesignToken {
+    return value && 
+           typeof value === 'object' && 
            'value' in value && 
            'type' in value;
   }
@@ -472,7 +515,8 @@ export class TokenValidator {
   /**
    * Checks if a token type is valid
    */
-  private static isValidTokenType(type)] = [
+  private static isValidTokenType(type: any): type is TokenType {
+    const validTypes: TokenType[] = [
       'color', 'fontFamily', 'fontSize', 'fontWeight', 'lineHeight', 
       'letterSpacing', 'spacing', 'borderRadius', 'shadow', 'transition', 
       'zIndex', 'breakpoint'
@@ -483,7 +527,8 @@ export class TokenValidator {
   /**
    * Checks if a color value is valid
    */
-  private static isValidColor(color), rgb, rgba, named colors
+  private static isValidColor(color: string): boolean {
+    // 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);
   }
@@ -491,7 +536,8 @@ export class TokenValidator {
   /**
    * Checks if a CSS unit is valid
    */
-  private static isValidCSSUnit(value)= /^[\d.]+(px|em|rem|vh|vw|%|ch|ex|in|cm|mm|pt|pc)$/;
+  private static isValidCSSUnit(value: string): boolean {
+    const unitRegex = /^[\d.]+(px|em|rem|vh|vw|%|ch|ex|in|cm|mm|pt|pc)$/;
     return unitRegex.test(value);
   }
 }