@ngcorex/css 0.1.6 → 0.2.0

package/dist/validation/index.js

@@ -0,0 +1,206 @@
+/**
+ * Main validation entry point
+ * Coordinates all non-blocking token validations
+ */
+import { validateDuplicateTokens } from './token-duplicates.js';
+import { validateScaleConsistency } from './scale-consistency.js';
+import { validateColorFormat } from './color-format.js';
+import { validateSpacingFormat } from './spacing-format.js';
+import { validateShadowFormat } from './shadow-format.js';
+import { validateZIndexLogic } from './z-index-logic.js';
+/**
+ * Default validation configuration
+ */
+export const DEFAULT_VALIDATION_CONFIG = {
+    enabled: {
+        duplicateTokens: true,
+        scaleConsistency: true,
+        colorFormat: true,
+        spacingFormat: true,
+        shadowFormat: true,
+        zIndexLogic: true
+    },
+    severity: 'warning'
+};
+/**
+ * Run all enabled validations on tokens
+ */
+export function runValidations(tokens, config = DEFAULT_VALIDATION_CONFIG) {
+    const results = [];
+    // Run duplicate token validation
+    if (config.enabled.duplicateTokens) {
+        const duplicateResults = validateDuplicateTokens(tokens, 'tokens.json', config.severity);
+        results.push(...duplicateResults);
+    }
+    // Run scale consistency validation
+    if (config.enabled.scaleConsistency) {
+        const scaleResults = validateScaleConsistency(tokens, config.severity);
+        results.push(...scaleResults);
+    }
+    // Run color format validation
+    if (config.enabled.colorFormat) {
+        const colorResults = validateColorFormat(tokens, config.severity);
+        results.push(...colorResults);
+    }
+    // Run spacing format validation
+    if (config.enabled.spacingFormat) {
+        const spacingResults = validateSpacingFormat(tokens, config.severity);
+        results.push(...spacingResults);
+    }
+    // Run shadow format validation
+    if (config.enabled.shadowFormat) {
+        const shadowResults = validateShadowFormat(tokens, config.severity);
+        results.push(...shadowResults);
+    }
+    // Run z-index logic validation
+    if (config.enabled.zIndexLogic) {
+        const zIndexResults = validateZIndexLogic(tokens, config.severity);
+        results.push(...zIndexResults);
+    }
+    // Run custom validators
+    if (config.customValidators) {
+        for (const validator of config.customValidators) {
+            const customResults = validator.validate(tokens);
+            results.push(...customResults);
+        }
+    }
+    // Count results by severity
+    const summary = {
+        info: results.filter(r => r.severity === 'info').length,
+        warning: results.filter(r => r.severity === 'warning').length,
+        error: results.filter(r => r.severity === 'error').length
+    };
+    // Report is valid if there are no errors (warnings and info are non-blocking)
+    const valid = summary.error === 0;
+    return {
+        valid,
+        results,
+        summary
+    };
+}
+/**
+ * Run validations and return only warnings and errors (filter out info)
+ */
+export function runValidationsWithoutInfo(tokens, config = DEFAULT_VALIDATION_CONFIG) {
+    const report = runValidations(tokens, config);
+    const filteredResults = report.results.filter(r => r.severity !== 'info');
+    return {
+        valid: report.valid,
+        results: filteredResults,
+        summary: {
+            info: 0,
+            warning: filteredResults.filter(r => r.severity === 'warning').length,
+            error: filteredResults.filter(r => r.severity === 'error').length
+        }
+    };
+}
+/**
+ * Get a human-readable summary of the validation report
+ */
+export function getValidationSummary(report) {
+    const lines = [];
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    lines.push('  🔍 Token Validation Report');
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    lines.push('');
+    if (report.valid) {
+        lines.push('  ✅ No blocking errors found');
+    }
+    else {
+        lines.push(`  ❌ ${report.summary.error} error${report.summary.error > 1 ? 's' : ''} found`);
+    }
+    if (report.summary.warning > 0) {
+        lines.push(`  ⚠️  ${report.summary.warning} warning${report.summary.warning > 1 ? 's' : ''}`);
+    }
+    if (report.summary.info > 0) {
+        lines.push(`  ℹ️  ${report.summary.info} info message${report.summary.info > 1 ? 's' : ''}`);
+    }
+    lines.push('');
+    lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Print validation results grouped by severity
+ */
+export function printValidationResults(report) {
+    if (report.results.length === 0) {
+        console.log('✅ No validation issues found');
+        return;
+    }
+    // Print errors first
+    const errors = report.results.filter(r => r.severity === 'error');
+    if (errors.length > 0) {
+        console.log('');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log(`  ❌ ${errors.length} Error${errors.length > 1 ? 's' : ''}`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+        for (const result of errors) {
+            console.log(`  ❌ ${result.message}`);
+            console.log(`  Path: ${result.path}`);
+            if (result.suggestion) {
+                console.log(`  💡 ${result.suggestion}`);
+            }
+            console.log('');
+        }
+    }
+    // Print warnings
+    const warnings = report.results.filter(r => r.severity === 'warning');
+    if (warnings.length > 0) {
+        console.log('');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log(`  ⚠️  ${warnings.length} Warning${warnings.length > 1 ? 's' : ''}`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+        for (const result of warnings) {
+            console.log(`  ⚠️  ${result.message}`);
+            console.log(`  Path: ${result.path}`);
+            if (result.suggestion) {
+                console.log(`  💡 ${result.suggestion}`);
+            }
+            console.log('');
+        }
+    }
+    // Print info messages
+    const info = report.results.filter(r => r.severity === 'info');
+    if (info.length > 0) {
+        console.log('');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log(`  ℹ️  ${info.length} Info Message${info.length > 1 ? 's' : ''}`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+        for (const result of info) {
+            console.log(`  ℹ️  ${result.message}`);
+            console.log(`  Path: ${result.path}`);
+            if (result.suggestion) {
+                console.log(`  💡 ${result.suggestion}`);
+            }
+            console.log('');
+        }
+    }
+}
+/**
+ * Check if validation report has any results
+ */
+export function hasValidationResults(report) {
+    return report.results.length > 0;
+}
+/**
+ * Check if validation report has errors
+ */
+export function hasValidationErrors(report) {
+    return report.summary.error > 0;
+}
+/**
+ * Check if validation report has warnings
+ */
+export function hasValidationWarnings(report) {
+    return report.summary.warning > 0;
+}
+/**
+ * Check if validation report has info messages
+ */
+export function hasValidationInfo(report) {
+    return report.summary.info > 0;
+}

package/dist/validation/scale-consistency.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Scale consistency checks
+ * Checks for logical progressions in token scales (e.g., spacing, radius, typography)
+ */
+import type { ValidationResult, TokensForValidation, ScaleConsistencyIssue } from './types.js';
+/**
+ * Validate all scales for consistency
+ */
+export declare function validateScaleConsistency(tokens: TokensForValidation, severity?: 'info' | 'warning' | 'error'): ValidationResult[];
+/**
+ * Get a summary of scale consistency issues
+ */
+export declare function getScaleConsistencySummary(issues: ScaleConsistencyIssue[]): string;
+//# sourceMappingURL=scale-consistency.d.ts.map

package/dist/validation/scale-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale-consistency.d.ts","sourceRoot":"","sources":["../../src/validation/scale-consistency.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EAEtB,MAAM,YAAY,CAAC;AAoMpB;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,GAAE,MAAM,GAAG,SAAS,GAAG,OAAmB,GACjD,gBAAgB,EAAE,CAgCpB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,MAAM,CAelF"}

package/dist/validation/scale-consistency.js

@@ -0,0 +1,215 @@
+/**
+ * Scale consistency checks
+ * Checks for logical progressions in token scales (e.g., spacing, radius, typography)
+ */
+/**
+ * Validation code for scale consistency
+ */
+const SCALE_CONSISTENCY_CODE = 'SCALE_CONSISTENCY';
+/**
+ * Common scale orders for different categories
+ */
+const COMMON_SCALE_ORDERS = {
+    spacing: {
+        category: 'spacing',
+        expectedOrder: ['xs', 'sm', 'md', 'lg', 'xl', '2xl', '3xl', '4xl'],
+        isNumeric: true
+    },
+    radius: {
+        category: 'radius',
+        expectedOrder: ['none', 'xs', 'sm', 'md', 'lg', 'xl', '2xl', '3xl', 'full'],
+        isNumeric: true
+    },
+    fontSize: {
+        category: 'fontSize',
+        expectedOrder: ['xs', 'sm', 'base', 'lg', 'xl', '2xl', '3xl', '4xl', '5xl', '6xl'],
+        isNumeric: true
+    },
+    fontWeight: {
+        category: 'fontWeight',
+        expectedOrder: ['thin', 'light', 'normal', 'medium', 'semibold', 'bold', 'extrabold', 'black'],
+        isNumeric: true
+    },
+    lineHeight: {
+        category: 'lineHeight',
+        expectedOrder: ['none', 'tight', 'snug', 'normal', 'relaxed', 'loose'],
+        isNumeric: true
+    },
+    zIndex: {
+        category: 'zIndex',
+        expectedOrder: ['base', 'dropdown', 'sticky', 'fixed', 'modal', 'popover', 'tooltip'],
+        isNumeric: true
+    }
+};
+/**
+ * Parse a CSS value to extract numeric value and unit
+ */
+function parseCssValue(value) {
+    const match = value.match(/^(-?\d*\.?\d+)(px|rem|em|%|vh|vw|vmin|vmax|ch|ex|fr|deg|rad|turn|s|ms)?$/);
+    if (!match)
+        return null;
+    return {
+        value: parseFloat(match[1]),
+        unit: match[2] || ''
+    };
+}
+/**
+ * Check if values are in a monotonic progression
+ */
+function checkMonotonicProgression(values, expectedIncreasing = true) {
+    const issues = [];
+    for (let i = 1; i < values.length; i++) {
+        const diff = values[i] - values[i - 1];
+        if (expectedIncreasing && diff <= 0) {
+            issues.push(i);
+        }
+        else if (!expectedIncreasing && diff >= 0) {
+            issues.push(i);
+        }
+    }
+    return {
+        isMonotonic: issues.length === 0,
+        issues
+    };
+}
+/**
+ * Check for gaps in a numeric progression
+ */
+function checkForGaps(values, keys, expectedOrder) {
+    const gapIndices = [];
+    // Check if any expected keys are missing
+    for (let i = 0; i < expectedOrder.length; i++) {
+        if (!keys.includes(expectedOrder[i])) {
+            // Find the position where this key should be
+            const position = expectedOrder.indexOf(expectedOrder[i]);
+            if (position < keys.length) {
+                gapIndices.push(i);
+            }
+        }
+    }
+    return {
+        hasGaps: gapIndices.length > 0,
+        gapIndices
+    };
+}
+/**
+ * Validate scale consistency for a token category
+ */
+function validateScale(category, tokens, severity = 'warning') {
+    const results = [];
+    const scaleOrder = COMMON_SCALE_ORDERS[category];
+    if (!scaleOrder) {
+        // No predefined order for this category, skip
+        return results;
+    }
+    // Get keys in expected order (if they exist)
+    const keys = [];
+    const values = [];
+    const keyToValueMap = new Map();
+    for (const key of scaleOrder.expectedOrder) {
+        if (key in tokens) {
+            keys.push(key);
+            const rawValue = tokens[key];
+            let numericValue;
+            if (typeof rawValue === 'number') {
+                numericValue = rawValue;
+            }
+            else {
+                const parsed = parseCssValue(rawValue);
+                if (parsed) {
+                    numericValue = parsed.value;
+                }
+                else {
+                    // Can't parse as numeric, skip this key
+                    continue;
+                }
+            }
+            values.push(numericValue);
+            keyToValueMap.set(key, { value: numericValue, raw: rawValue });
+        }
+    }
+    if (values.length < 2) {
+        // Not enough values to check consistency
+        return results;
+    }
+    // Check for monotonic progression
+    const { isMonotonic, issues } = checkMonotonicProgression(values, scaleOrder.isNumeric);
+    if (!isMonotonic) {
+        for (const issueIndex of issues) {
+            const key = keys[issueIndex];
+            const prevKey = keys[issueIndex - 1];
+            const currentValue = keyToValueMap.get(key).raw;
+            const prevValue = keyToValueMap.get(prevKey).raw;
+            results.push({
+                severity,
+                code: SCALE_CONSISTENCY_CODE,
+                message: `Non-monotonic progression in ${category} scale: "${key}" (${currentValue}) is not greater than "${prevKey}" (${prevValue})`,
+                path: `${category}.${key}`,
+                suggestion: `Consider adjusting the value of "${key}" to be greater than "${prevKey}" for a consistent scale.`,
+                example: `// Example:\n// ${category}.${prevKey}: ${prevValue}\n// ${category}.${key}: ${currentValue} // Should be > ${prevValue}`
+            });
+        }
+    }
+    // Check for gaps in the scale
+    const { hasGaps, gapIndices } = checkForGaps(values, keys, scaleOrder.expectedOrder);
+    // Skip "missing keys" info for zIndex - z-index-logic.ts provides more semantic "missing layers" message
+    if (hasGaps && category !== 'zIndex') {
+        const missingKeys = gapIndices.map(i => scaleOrder.expectedOrder[i]);
+        results.push({
+            severity: 'info', // Gaps are less severe than non-monotonic values
+            code: SCALE_CONSISTENCY_CODE,
+            message: `Potential gaps in ${category} scale: missing keys ${missingKeys.map(k => `"${k}"`).join(', ')}`,
+            path: category,
+            suggestion: `Consider adding the missing scale keys for a more complete scale.`,
+            example: `// Example:\n// ${category}.${missingKeys[0]}: "value"`
+        });
+    }
+    return results;
+}
+/**
+ * Validate all scales for consistency
+ */
+export function validateScaleConsistency(tokens, severity = 'warning') {
+    const results = [];
+    // Validate spacing scale
+    if (tokens.spacing) {
+        results.push(...validateScale('spacing', tokens.spacing, severity));
+    }
+    // Validate radius scale
+    if (tokens.radius) {
+        results.push(...validateScale('radius', tokens.radius, severity));
+    }
+    // Validate typography scales
+    if (tokens.typography) {
+        if (tokens.typography.fontSize) {
+            results.push(...validateScale('fontSize', tokens.typography.fontSize, severity));
+        }
+        if (tokens.typography.fontWeight) {
+            results.push(...validateScale('fontWeight', tokens.typography.fontWeight, severity));
+        }
+        if (tokens.typography.lineHeight) {
+            results.push(...validateScale('lineHeight', tokens.typography.lineHeight, severity));
+        }
+    }
+    // Validate z-index scale
+    if (tokens.zIndex) {
+        results.push(...validateScale('zIndex', tokens.zIndex, severity));
+    }
+    return results;
+}
+/**
+ * Get a summary of scale consistency issues
+ */
+export function getScaleConsistencySummary(issues) {
+    if (issues.length === 0) {
+        return 'No scale consistency issues found.';
+    }
+    const summary = [];
+    summary.push(`Found ${issues.length} scale consistency issue${issues.length > 1 ? 's' : ''}:`);
+    for (const issue of issues) {
+        summary.push(`  • ${issue.category}: ${issue.issue}`);
+        summary.push(`    ${issue.details}`);
+        summary.push(`    💡 ${issue.suggestion}`);
+    }
+    return summary.join('\n');
+}

package/dist/validation/shadow-format.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shadow format validation
+ * Checks for valid CSS box-shadow syntax
+ */
+import type { ValidationResult, TokensForValidation, ShadowFormatIssue } from './types.js';
+/**
+ * Validate all shadow formats
+ */
+export declare function validateShadowFormat(tokens: TokensForValidation, severity?: 'info' | 'warning' | 'error'): ValidationResult[];
+/**
+ * Get a summary of shadow format issues
+ */
+export declare function getShadowFormatSummary(issues: ShadowFormatIssue[]): string;
+//# sourceMappingURL=shadow-format.d.ts.map

package/dist/validation/shadow-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-format.d.ts","sourceRoot":"","sources":["../../src/validation/shadow-format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AA6NpB;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,GAAE,MAAM,GAAG,SAAS,GAAG,OAAmB,GACjD,gBAAgB,EAAE,CAqBpB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,MAAM,CAe1E"}

package/dist/validation/shadow-format.js

@@ -0,0 +1,217 @@
+/**
+ * Shadow format validation
+ * Checks for valid CSS box-shadow syntax
+ */
+import { isValidColor, getColorFormat } from './color-format.js';
+/**
+ * Validation code for shadow format
+ */
+const SHADOW_FORMAT_CODE = 'SHADOW_FORMAT';
+/**
+ * Parse a box-shadow value
+ * Format: offset-x | offset-y | blur-radius | spread-radius | color | inset
+ */
+function parseBoxShadow(value) {
+    const trimmed = value.trim();
+    const parts = trimmed.split(/\s+/);
+    const result = {
+        valid: false,
+        offsetX: undefined,
+        offsetY: undefined,
+        blur: undefined,
+        spread: undefined,
+        color: undefined,
+        inset: false,
+        error: undefined
+    };
+    // Check for inset keyword
+    let startIndex = 0;
+    if (parts[0] === 'inset') {
+        result.inset = true;
+        startIndex = 1;
+    }
+    // Need at least 2 values (offset-x and offset-y)
+    if (parts.length - startIndex < 2) {
+        result.error = 'Box-shadow requires at least offset-x and offset-y values';
+        return result;
+    }
+    // Parse offset-x
+    if (!isValidLength(parts[startIndex])) {
+        result.error = `Invalid offset-x value: "${parts[startIndex]}"`;
+        return result;
+    }
+    result.offsetX = parts[startIndex];
+    // Parse offset-y
+    if (!isValidLength(parts[startIndex + 1])) {
+        result.error = `Invalid offset-y value: "${parts[startIndex + 1]}"`;
+        return result;
+    }
+    result.offsetY = parts[startIndex + 1];
+    // Parse blur-radius (optional)
+    if (parts.length > startIndex + 2) {
+        if (isValidLength(parts[startIndex + 2])) {
+            result.blur = parts[startIndex + 2];
+            startIndex += 3;
+        }
+        else if (isValidColor(parts[startIndex + 2])) {
+            result.color = parts[startIndex + 2];
+            startIndex += 2;
+        }
+        else {
+            result.error = `Invalid blur-radius or color value: "${parts[startIndex + 2]}"`;
+            return result;
+        }
+    }
+    else {
+        startIndex += 2;
+    }
+    // Parse spread-radius (optional)
+    if (parts.length > startIndex && isValidLength(parts[startIndex])) {
+        result.spread = parts[startIndex];
+        startIndex += 1;
+    }
+    // Parse color (optional)
+    if (parts.length > startIndex && isValidColor(parts[startIndex])) {
+        result.color = parts[startIndex];
+    }
+    result.valid = true;
+    return result;
+}
+/**
+ * Check if a value is a valid CSS length
+ */
+function isValidLength(value) {
+    const match = value.match(/^(-?\d*\.?\d+)(px|rem|em|%|vh|vw|vmin|vmax|ch|ex)?$/);
+    if (!match)
+        return false;
+    const numericValue = parseFloat(match[1]);
+    return !isNaN(numericValue);
+}
+/**
+ * Check if a length value is negative
+ */
+function isNegativeLength(value) {
+    return value.startsWith('-');
+}
+/**
+ * Validate a single shadow value
+ */
+function validateShadowValue(path, value, severity = 'warning') {
+    const parsed = parseBoxShadow(value);
+    if (!parsed.valid) {
+        return {
+            severity: 'error',
+            code: SHADOW_FORMAT_CODE,
+            message: `Invalid shadow format: "${value}"`,
+            path,
+            suggestion: parsed.error || 'Use valid box-shadow syntax: offset-x offset-y [blur-radius] [spread-radius] [color] [inset]',
+            example: `// Examples:\n// "${path}": "0 1px 2px 0 rgba(0,0,0,0.05)"\n// "${path}": "0 4px 6px -1px rgba(0,0,0,0.1)"`
+        };
+    }
+    const issues = [];
+    // Check for negative blur-radius
+    if (parsed.blur && isNegativeLength(parsed.blur)) {
+        issues.push('Blur-radius should not be negative');
+    }
+    // Check for color format
+    if (parsed.color) {
+        const format = getColorFormat(parsed.color);
+        if (format === 'hex3' || format === 'hex4') {
+            issues.push('Consider using full hex color format (hex6) for better precision');
+        }
+    }
+    if (issues.length > 0) {
+        return {
+            severity,
+            code: SHADOW_FORMAT_CODE,
+            message: `Shadow format issues: ${issues.join(', ')}`,
+            path,
+            suggestion: 'Review the shadow value for best practices.',
+            example: `// Example:\n// "${path}": "0 1px 2px 0 rgba(0,0,0,0.05)"`
+        };
+    }
+    return null;
+}
+/**
+ * Check for shadow scale consistency
+ */
+function checkShadowScaleConsistency(shadows, severity = 'warning') {
+    const results = [];
+    const keys = Object.keys(shadows);
+    if (keys.length < 2)
+        return results;
+    // Expected shadow scale order
+    const expectedOrder = ['xs', 'sm', 'md', 'lg', 'xl', '2xl'];
+    const orderedKeys = keys.filter(k => expectedOrder.includes(k)).sort((a, b) => {
+        return expectedOrder.indexOf(a) - expectedOrder.indexOf(b);
+    });
+    if (orderedKeys.length < 2)
+        return results;
+    // Parse shadows to compare blur values
+    const blurValues = [];
+    for (const key of orderedKeys) {
+        const parsed = parseBoxShadow(shadows[key]);
+        let blur = null;
+        if (parsed.blur) {
+            const match = parsed.blur.match(/^(-?\d*\.?\d+)(px|rem|em)?$/);
+            if (match) {
+                blur = parseFloat(match[1]);
+            }
+        }
+        blurValues.push({ key, blur });
+    }
+    // Check for monotonic progression
+    for (let i = 1; i < blurValues.length; i++) {
+        const prev = blurValues[i - 1];
+        const curr = blurValues[i];
+        if (prev.blur !== null && curr.blur !== null) {
+            if (curr.blur <= prev.blur) {
+                results.push({
+                    severity,
+                    code: SHADOW_FORMAT_CODE,
+                    message: `Non-monotonic shadow scale: "${curr.key}" blur (${curr.blur}px) is not greater than "${prev.key}" (${prev.blur}px)`,
+                    path: `shadows.${curr.key}`,
+                    suggestion: 'Shadow blur values should increase with scale size.',
+                    example: `// Example:\n// "shadows.${prev.key}": "${shadows[prev.key]}"\n// "shadows.${curr.key}": "0 ${curr.blur + 2}px ..."`
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Validate all shadow formats
+ */
+export function validateShadowFormat(tokens, severity = 'warning') {
+    const results = [];
+    if (!tokens.shadows) {
+        return results;
+    }
+    const shadows = tokens.shadows;
+    // Validate each shadow value
+    for (const [key, value] of Object.entries(shadows)) {
+        const result = validateShadowValue(`shadows.${key}`, value, severity);
+        if (result) {
+            results.push(result);
+        }
+    }
+    // Check for scale consistency
+    results.push(...checkShadowScaleConsistency(shadows, severity));
+    return results;
+}
+/**
+ * Get a summary of shadow format issues
+ */
+export function getShadowFormatSummary(issues) {
+    if (issues.length === 0) {
+        return 'No shadow format issues found.';
+    }
+    const summary = [];
+    summary.push(`Found ${issues.length} shadow format issue${issues.length > 1 ? 's' : ''}:`);
+    for (const issue of issues) {
+        summary.push(`  • ${issue.path}: ${issue.issue}`);
+        summary.push(`    ${issue.details}`);
+        summary.push(`    💡 ${issue.suggestion}`);
+    }
+    return summary.join('\n');
+}

package/dist/validation/spacing-format.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Spacing format validation
+ * Checks for valid CSS spacing units and consistency
+ */
+import type { ValidationResult, TokensForValidation, SpacingFormatIssue } from './types.js';
+/**
+ * Validate all spacing formats
+ */
+export declare function validateSpacingFormat(tokens: TokensForValidation, severity?: 'info' | 'warning' | 'error'): ValidationResult[];
+/**
+ * Get a summary of spacing format issues
+ */
+export declare function getSpacingFormatSummary(issues: SpacingFormatIssue[]): string;
+//# sourceMappingURL=spacing-format.d.ts.map