@ngcorex/css 0.1.6 → 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"spacing-format.d.ts","sourceRoot":"","sources":["../../src/validation/spacing-format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAgKpB;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,GAAE,MAAM,GAAG,SAAS,GAAG,OAAmB,GACjD,gBAAgB,EAAE,CAqBpB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAe5E"}

package/dist/validation/spacing-format.js

@@ -0,0 +1,173 @@
+/**
+ * Spacing format validation
+ * Checks for valid CSS spacing units and consistency
+ */
+/**
+ * Validation code for spacing format
+ */
+const SPACING_FORMAT_CODE = 'SPACING_FORMAT';
+/**
+ * Common CSS spacing units
+ */
+const VALID_SPACING_UNITS = new Set([
+    'px', 'rem', 'em', '%', 'vh', 'vw', 'vmin', 'vmax', 'ch', 'ex', 'fr'
+]);
+/**
+ * Recommended spacing units for design systems
+ */
+const RECOMMENDED_SPACING_UNITS = new Set(['rem', 'px']);
+/**
+ * Parse a spacing value to extract numeric value and unit
+ */
+function parseSpacingValue(value) {
+    let raw;
+    let numericValue;
+    let unit;
+    if (typeof value === 'number') {
+        raw = value.toString();
+        numericValue = value;
+        unit = '';
+    }
+    else {
+        raw = value;
+        const match = value.match(/^(-?\d*\.?\d+)(px|rem|em|%|vh|vw|vmin|vmax|ch|ex|fr)?$/);
+        if (!match)
+            return null;
+        numericValue = parseFloat(match[1]);
+        unit = match[2] || '';
+    }
+    return { value: numericValue, unit, raw };
+}
+/**
+ * Check if a spacing unit is valid
+ */
+function isValidSpacingUnit(unit) {
+    if (unit === '')
+        return true; // Unitless values are valid
+    return VALID_SPACING_UNITS.has(unit);
+}
+/**
+ * Check if a spacing unit is recommended
+ */
+function isRecommendedSpacingUnit(unit) {
+    if (unit === '')
+        return false; // Unitless values are not recommended for spacing
+    return RECOMMENDED_SPACING_UNITS.has(unit);
+}
+/**
+ * Validate a single spacing value
+ */
+function validateSpacingValue(path, value, severity = 'warning') {
+    const parsed = parseSpacingValue(value);
+    if (!parsed) {
+        return {
+            severity: 'error',
+            code: SPACING_FORMAT_CODE,
+            message: `Invalid spacing value: "${value}"`,
+            path,
+            suggestion: 'Use a valid CSS spacing value: number, or number with unit (px, rem, em, etc.).',
+            example: `// Examples:\n// "${path}": "1rem"\n// "${path}": "16px"\n// "${path}": "0.5rem"`
+        };
+    }
+    const { value: numericValue, unit } = parsed;
+    // Check for negative values (not typically valid for spacing)
+    if (numericValue < 0) {
+        return {
+            severity: 'warning',
+            code: SPACING_FORMAT_CODE,
+            message: `Negative spacing value: "${value}"`,
+            path,
+            suggestion: 'Spacing values should typically be positive. Use negative values only for specific use cases.',
+            example: `// Change from:\n// "${path}": "${value}"\n// To:\n// "${path}": "${Math.abs(numericValue)}${unit}"`
+        };
+    }
+    // Check for valid unit
+    if (!isValidSpacingUnit(unit)) {
+        return {
+            severity: 'error',
+            code: SPACING_FORMAT_CODE,
+            message: `Invalid spacing unit: "${unit}"`,
+            path,
+            suggestion: `Use a valid CSS spacing unit: ${Array.from(VALID_SPACING_UNITS).join(', ')}.`,
+            example: `// Examples:\n// "${path}": "1rem"\n// "${path}": "16px"`
+        };
+    }
+    // Check for recommended unit
+    if (unit !== '' && !isRecommendedSpacingUnit(unit)) {
+        return {
+            severity: 'info',
+            code: SPACING_FORMAT_CODE,
+            message: `Using non-recommended spacing unit: "${unit}"`,
+            path,
+            suggestion: `Consider using recommended units (${Array.from(RECOMMENDED_SPACING_UNITS).join(', ')}) for better consistency.`,
+            example: `// Change from:\n// "${path}": "${value}"\n// To:\n// "${path}": "${numericValue}rem"`
+        };
+    }
+    return null;
+}
+/**
+ * Check for inconsistent spacing units
+ */
+function checkSpacingUnitConsistency(spacing, severity = 'warning') {
+    const results = [];
+    const units = new Map(); // unit -> count
+    for (const [key, value] of Object.entries(spacing)) {
+        const parsed = parseSpacingValue(value);
+        if (parsed) {
+            const { unit } = parsed;
+            const count = units.get(unit) || 0;
+            units.set(unit, count + 1);
+        }
+    }
+    // Check if there are mixed units
+    if (units.size > 1) {
+        const unitList = Array.from(units.entries())
+            .map(([unit, count]) => `${unit || 'unitless'} (${count})`)
+            .join(', ');
+        results.push({
+            severity,
+            code: SPACING_FORMAT_CODE,
+            message: `Mixed spacing units detected: ${unitList}`,
+            path: 'spacing',
+            suggestion: 'Use consistent spacing units for better maintainability. Consider using rem for responsive design.',
+            example: `// Example - use rem for all spacing:\n// "spacing.xs": "0.25rem"\n// "spacing.sm": "0.5rem"\n// "spacing.md": "1rem"`
+        });
+    }
+    return results;
+}
+/**
+ * Validate all spacing formats
+ */
+export function validateSpacingFormat(tokens, severity = 'warning') {
+    const results = [];
+    if (!tokens.spacing) {
+        return results;
+    }
+    const spacing = tokens.spacing;
+    // Validate each spacing value
+    for (const [key, value] of Object.entries(spacing)) {
+        const result = validateSpacingValue(`spacing.${key}`, value, severity);
+        if (result) {
+            results.push(result);
+        }
+    }
+    // Check for unit consistency
+    results.push(...checkSpacingUnitConsistency(spacing, severity));
+    return results;
+}
+/**
+ * Get a summary of spacing format issues
+ */
+export function getSpacingFormatSummary(issues) {
+    if (issues.length === 0) {
+        return 'No spacing format issues found.';
+    }
+    const summary = [];
+    summary.push(`Found ${issues.length} spacing 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/token-duplicates.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Duplicate token detection
+ * Checks for duplicate token names WITHIN the same category
+ * Cross-category duplicates are allowed (e.g., radius.sm, typography.fontSize.sm)
+ */
+import type { ValidationResult, TokensForValidation, DuplicateToken } from './types.js';
+/**
+ * Find all duplicate tokens within each category
+ * Cross-category duplicates are NOT flagged (per spec X1)
+ */
+export declare function findDuplicateTokens(tokens: TokensForValidation, file?: string): DuplicateToken[];
+/**
+ * Convert duplicate tokens to validation results
+ */
+export declare function duplicateTokensToValidationResults(duplicates: DuplicateToken[], severity?: 'info' | 'warning' | 'error'): ValidationResult[];
+/**
+ * Validate tokens for duplicates
+ */
+export declare function validateDuplicateTokens(tokens: TokensForValidation, file?: string, severity?: 'info' | 'warning' | 'error'): ValidationResult[];
+/**
+ * Get a summary of duplicate tokens
+ */
+export declare function getDuplicateTokensSummary(duplicates: DuplicateToken[]): string;
+//# sourceMappingURL=token-duplicates.d.ts.map

package/dist/validation/token-duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-duplicates.d.ts","sourceRoot":"","sources":["../../src/validation/token-duplicates.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EAEnB,cAAc,EACf,MAAM,YAAY,CAAC;AAOpB;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,GAAE,MAAsB,GAAG,cAAc,EAAE,CA+B/G;AAqFD;;GAEG;AACH,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,cAAc,EAAE,EAC5B,QAAQ,GAAE,MAAM,GAAG,SAAS,GAAG,OAAmB,GACjD,gBAAgB,EAAE,CAmBpB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,GAAE,MAAsB,EAC5B,QAAQ,GAAE,MAAM,GAAG,SAAS,GAAG,OAAmB,GACjD,gBAAgB,EAAE,CAGpB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,cAAc,EAAE,GAAG,MAAM,CAgB9E"}

package/dist/validation/token-duplicates.js

@@ -0,0 +1,149 @@
+/**
+ * Duplicate token detection
+ * Checks for duplicate token names WITHIN the same category
+ * Cross-category duplicates are allowed (e.g., radius.sm, typography.fontSize.sm)
+ */
+/**
+ * Validation code for duplicate tokens
+ */
+const DUPLICATE_TOKEN_CODE = 'DUPLICATE_TOKEN';
+/**
+ * Find all duplicate tokens within each category
+ * Cross-category duplicates are NOT flagged (per spec X1)
+ */
+export function findDuplicateTokens(tokens, file = 'tokens.json') {
+    const duplicates = [];
+    // Process each category separately
+    const categories = [
+        { name: 'spacing' },
+        { name: 'radius' },
+        { name: 'zIndex' },
+        { name: 'shadows' },
+        { name: 'colors', isNested: true },
+        { name: 'typography', isNested: true }
+    ];
+    for (const { name, isNested } of categories) {
+        const category = tokens[name];
+        if (!category)
+            continue;
+        if (isNested) {
+            // Handle nested token structures (colors, typography)
+            if (typeof category === 'object' && category !== null) {
+                duplicates.push(...findDuplicatesInNested(category, name, file));
+            }
+        }
+        else {
+            // Handle flat token structures (spacing, radius, zIndex, shadows)
+            if (typeof category === 'object' && category !== null) {
+                duplicates.push(...findDuplicatesInFlat(category, name, file));
+            }
+        }
+    }
+    return duplicates;
+}
+/**
+ * Find duplicates in flat token structures
+ */
+function findDuplicatesInFlat(obj, category, file) {
+    const duplicates = [];
+    const keyMap = new Map();
+    for (const [key, value] of Object.entries(obj)) {
+        const location = {
+            file,
+            category,
+            key,
+            path: `${category}.${key}`
+        };
+        if (!keyMap.has(key)) {
+            keyMap.set(key, []);
+        }
+        keyMap.get(key).push(location);
+    }
+    // Find duplicates within this category
+    for (const [name, locations] of keyMap.entries()) {
+        if (locations.length > 1) {
+            duplicates.push({ name, locations });
+        }
+    }
+    return duplicates;
+}
+/**
+ * Find duplicates in nested token structures
+ * Checks for duplicates at each nesting level separately
+ */
+function findDuplicatesInNested(obj, category, file, path = category) {
+    const duplicates = [];
+    if (typeof obj !== 'object' || obj === null)
+        return duplicates;
+    const keyMap = new Map();
+    // Check for duplicates at current level
+    for (const [key, value] of Object.entries(obj)) {
+        const location = {
+            file,
+            category,
+            key,
+            path: `${path}.${key}`
+        };
+        if (!keyMap.has(key)) {
+            keyMap.set(key, []);
+        }
+        keyMap.get(key).push(location);
+    }
+    // Add duplicates found at this level
+    for (const [name, locations] of keyMap.entries()) {
+        if (locations.length > 1) {
+            duplicates.push({ name, locations });
+        }
+    }
+    // Recursively check nested levels
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            duplicates.push(...findDuplicatesInNested(value, category, file, `${path}.${key}`));
+        }
+    }
+    return duplicates;
+}
+/**
+ * Convert duplicate tokens to validation results
+ */
+export function duplicateTokensToValidationResults(duplicates, severity = 'warning') {
+    const results = [];
+    for (const duplicate of duplicates) {
+        const locationsStr = duplicate.locations
+            .map(loc => loc.path)
+            .join(', ');
+        results.push({
+            severity,
+            code: DUPLICATE_TOKEN_CODE,
+            message: `Duplicate token name "${duplicate.name}" found in multiple locations`,
+            path: duplicate.locations[0].path,
+            suggestion: `Rename one of the tokens to avoid conflicts. Found in: ${locationsStr}`,
+            example: `// Example:\n// Rename ${duplicate.locations[0].path} to "${duplicate.name}Alt"\n// or rename ${duplicate.locations[1].path} to "${duplicate.name}Alt"`
+        });
+    }
+    return results;
+}
+/**
+ * Validate tokens for duplicates
+ */
+export function validateDuplicateTokens(tokens, file = 'tokens.json', severity = 'warning') {
+    const duplicates = findDuplicateTokens(tokens, file);
+    return duplicateTokensToValidationResults(duplicates, severity);
+}
+/**
+ * Get a summary of duplicate tokens
+ */
+export function getDuplicateTokensSummary(duplicates) {
+    if (duplicates.length === 0) {
+        return 'No duplicate tokens found.';
+    }
+    const summary = [];
+    summary.push(`Found ${duplicates.length} duplicate token name${duplicates.length > 1 ? 's' : ''}:`);
+    for (const duplicate of duplicates) {
+        summary.push(`  • "${duplicate.name}" appears ${duplicate.locations.length} times:`);
+        for (const loc of duplicate.locations) {
+            summary.push(`    - ${loc.path}`);
+        }
+    }
+    return summary.join('\n');
+}

package/dist/validation/types.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Types and interfaces for non-blocking token validation
+ */
+import type { TokenScale, NestedTokenScale } from '../tokens/types.js';
+/**
+ * Validation severity level
+ */
+export type ValidationSeverity = 'info' | 'warning' | 'error';
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    severity: ValidationSeverity;
+    code: string;
+    message: string;
+    path: string;
+    suggestion?: string;
+    example?: string;
+}
+/**
+ * Validation report containing all validation results
+ */
+export interface ValidationReport {
+    valid: boolean;
+    results: ValidationResult[];
+    summary: {
+        info: number;
+        warning: number;
+        error: number;
+    };
+}
+/**
+ * Token location for validation
+ */
+export interface TokenLocation {
+    file: string;
+    category: string;
+    key: string;
+    path: string;
+}
+/**
+ * Duplicate token entry
+ */
+export interface DuplicateToken {
+    name: string;
+    locations: TokenLocation[];
+}
+/**
+ * Scale consistency check result
+ */
+export interface ScaleConsistencyIssue {
+    scaleName: string;
+    category: string;
+    issue: 'non_monotonic' | 'gaps' | 'unexpected_values';
+    details: string;
+    suggestion: string;
+}
+/**
+ * Color format validation result
+ */
+export interface ColorFormatIssue {
+    path: string;
+    value: string;
+    issue: 'invalid_format' | 'inconsistent_format' | 'deprecated_format';
+    details: string;
+    suggestion: string;
+}
+/**
+ * Spacing format validation result
+ */
+export interface SpacingFormatIssue {
+    path: string;
+    value: string;
+    issue: 'invalid_unit' | 'inconsistent_units' | 'mixed_units';
+    details: string;
+    suggestion: string;
+}
+/**
+ * Shadow format validation result
+ */
+export interface ShadowFormatIssue {
+    path: string;
+    value: string;
+    issue: 'invalid_syntax' | 'invalid_color' | 'invalid_offset' | 'invalid_blur' | 'invalid_spread';
+    details: string;
+    suggestion: string;
+}
+/**
+ * Z-index logic validation result
+ */
+export interface ZIndexLogicIssue {
+    path: string;
+    issue: 'inconsistent_layering' | 'overlapping_values' | 'negative_values';
+    details: string;
+    suggestion: string;
+}
+/**
+ * Validation configuration
+ */
+export interface ValidationConfig {
+    /**
+     * Enable/disable specific validations
+     */
+    enabled: {
+        duplicateTokens: boolean;
+        scaleConsistency: boolean;
+        colorFormat: boolean;
+        spacingFormat: boolean;
+        shadowFormat: boolean;
+        zIndexLogic: boolean;
+    };
+    /**
+     * Severity level for non-blocking validations
+     * Note: These are non-blocking and will only produce warnings/info
+     */
+    severity: ValidationSeverity;
+    /**
+     * Custom validators
+     */
+    customValidators?: CustomValidator[];
+}
+/**
+ * Custom validator interface
+ */
+export interface CustomValidator {
+    name: string;
+    validate: (tokens: TokensForValidation) => ValidationResult[];
+}
+/**
+ * Tokens structure for validation
+ */
+export interface TokensForValidation {
+    spacing?: TokenScale;
+    colors?: NestedTokenScale;
+    radius?: TokenScale;
+    zIndex?: TokenScale;
+    typography?: {
+        fontSize?: TokenScale;
+        fontWeight?: TokenScale;
+        lineHeight?: TokenScale;
+    };
+    shadows?: TokenScale;
+}
+/**
+ * Validation context
+ */
+export interface ValidationContext {
+    file: string;
+    tokens: TokensForValidation;
+    config: ValidationConfig;
+}
+/**
+ * Expected scale order for consistency checks
+ */
+export interface ScaleOrder {
+    category: string;
+    expectedOrder: string[];
+    isNumeric?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/validation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/validation/types.ts"],"names":[],"mappings":"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"}

package/dist/validation/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types and interfaces for non-blocking token validation
+ */
+export {};

package/dist/validation/z-index-logic.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Z-index logic validation
+ * Checks for logical layering and value consistency
+ */
+import type { ValidationResult, TokensForValidation, ZIndexLogicIssue } from './types.js';
+/**
+ * Validate all z-index logic
+ */
+export declare function validateZIndexLogic(tokens: TokensForValidation, severity?: 'info' | 'warning' | 'error'): ValidationResult[];
+/**
+ * Get a summary of z-index logic issues
+ */
+export declare function getZIndexLogicSummary(issues: ZIndexLogicIssue[]): string;
+//# sourceMappingURL=z-index-logic.d.ts.map

package/dist/validation/z-index-logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"z-index-logic.d.ts","sourceRoot":"","sources":["../../src/validation/z-index-logic.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAyOpB;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,GAAE,MAAM,GAAG,SAAS,GAAG,OAAmB,GACjD,gBAAgB,EAAE,CA2BpB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAexE"}