themebooth 0.2.0 → 0.3.0

package/dist/cli/validate.js

@@ -0,0 +1,689 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+const manifest_1 = require("../core/manifest");
+const validation_1 = require("../utils/validation");
+const colors_1 = require("../core/colors");
+const schemas_1 = require("../core/schemas");
+const vscode_1 = require("../exporters/vscode");
+const zed_1 = require("../exporters/zed");
+const notepad_plus_1 = require("../exporters/notepad-plus");
+async function validateCommand(manifestPath, options = {}) {
+    const resolvedPath = path.resolve(manifestPath || "./manifest.json");
+    try {
+        const content = await fs.readFile(resolvedPath, "utf-8");
+        const errors = [];
+        const warnings = [];
+        const conversions = [];
+        let manifest;
+        // Parse JSON
+        const parseResult = (0, validation_1.parseManifestJSON)(content);
+        if (!parseResult.success) {
+            if (options.ci) {
+                console.log(JSON.stringify({
+                    valid: false,
+                    errors: [parseResult.error],
+                    warnings: [],
+                    stats: getStats(undefined),
+                }, null, 2));
+            }
+            else {
+                logger_1.logger.error("manifest.json invalid (1 error)");
+                console.log(`\n  ERROR [line ${parseResult.error.line}, col ${parseResult.error.column}]: ${parseResult.error.message}`);
+                if (parseResult.error.suggestion) {
+                    console.log(`    ${parseResult.error.suggestion}`);
+                }
+            }
+            process.exit(1);
+        }
+        // Pre-validate and normalize colors before schema validation
+        const preValidationData = JSON.parse(JSON.stringify(parseResult.data));
+        normalizeColorsInManifest(preValidationData, conversions);
+        // Validate schema
+        const schemaValidation = (0, manifest_1.validateManifest)(preValidationData);
+        if (!schemaValidation.success) {
+            schemaValidation.errors.forEach((err) => {
+                errors.push({
+                    severity: "error",
+                    field: err.field || "unknown",
+                    message: err.message,
+                });
+            });
+        }
+        else {
+            manifest = schemaValidation.data;
+            // Validate colors with conversion
+            const colorErrors = validateColors(manifest, conversions);
+            errors.push(...colorErrors.errors);
+            warnings.push(...colorErrors.warnings);
+            // Validate variables
+            const varErrors = validateVariables(manifest);
+            errors.push(...varErrors.errors);
+            warnings.push(...varErrors.warnings);
+            // Validate computed colors
+            const computedErrors = validateComputedColors(manifest);
+            errors.push(...computedErrors);
+            // Validate tokens
+            const tokenErrors = validateTokens(manifest);
+            errors.push(...tokenErrors);
+            // Validate semantic tokens
+            const semanticErrors = validateSemanticTokens(manifest);
+            errors.push(...semanticErrors);
+            // Validate language tokens
+            const languageErrors = validateLanguageTokens(manifest);
+            errors.push(...languageErrors);
+            // Validate presets
+            const presetErrors = validatePresets(manifest);
+            errors.push(...presetErrors);
+            // Validate extends
+            if (manifest.extends) {
+                const extendsErrors = await validateExtends(manifest.extends, resolvedPath);
+                errors.push(...extendsErrors);
+            }
+            // Dry-run exporter validation
+            const exporterErrors = validateExporters(manifest);
+            errors.push(...exporterErrors);
+        }
+        // Generate output
+        if (options.ci) {
+            const output = {
+                valid: errors.length === 0,
+                errors,
+                warnings,
+                stats: getStats(manifest),
+            };
+            if (conversions.length > 0) {
+                output.conversions = conversions;
+            }
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            printValidationResult(errors, warnings, manifest, conversions, options.fix);
+        }
+        // Apply fixes if requested
+        if (options.fix && conversions.length > 0) {
+            // preValidationData already has conversions applied
+            await fs.writeFile(resolvedPath, JSON.stringify(preValidationData, null, 2) + "\n");
+            if (!options.ci) {
+                logger_1.logger.success(`manifest.json fixed (${conversions.length} conversions)`);
+                conversions.forEach((c) => {
+                    console.log(`  • ${c.field}: ${c.from} → ${c.to}`);
+                });
+                console.log(`  Written back to manifest.json`);
+            }
+        }
+        // Exit with appropriate code
+        if (errors.length > 0) {
+            process.exit(1);
+        }
+        else if (warnings.length > 0) {
+            process.exit(2);
+        }
+    }
+    catch (error) {
+        if (options.ci) {
+            console.log(JSON.stringify({
+                valid: false,
+                errors: [
+                    {
+                        severity: "error",
+                        field: "manifest.json",
+                        message: `Failed to read manifest: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                warnings: [],
+                stats: getStats(undefined),
+            }, null, 2));
+        }
+        else {
+            logger_1.logger.error(`Failed to read manifest: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exit(1);
+    }
+}
+function validateColors(manifest, conversions) {
+    const errors = [];
+    const warnings = [];
+    if (!manifest.colors)
+        return { errors, warnings };
+    Object.entries(manifest.colors).forEach(([key, value]) => {
+        if (value === null)
+            return;
+        // Skip variable references
+        if (value.startsWith("$")) {
+            return;
+        }
+        // Try to parse and normalize
+        const result = (0, colors_1.parseAndNormalizeColor)(value);
+        if (result) {
+            if (result.changes.length > 0) {
+                conversions.push({
+                    line: 0, // TODO: get actual line number from source
+                    field: `colors.${key}`,
+                    from: value,
+                    to: result.hex,
+                });
+            }
+        }
+        else {
+            const format = (0, colors_1.validateColorFormat)(value);
+            if (!format.valid) {
+                errors.push({
+                    severity: "error",
+                    field: `colors.${key}`,
+                    message: `Invalid color format "${value}"`,
+                    suggestion: format.suggestion || "Use #RRGGBB, rgb(r,g,b), or $variableName",
+                });
+            }
+        }
+    });
+    return { errors, warnings };
+}
+function validateVariables(manifest) {
+    const errors = [];
+    const warnings = [];
+    if (!manifest.variables)
+        return { errors, warnings };
+    // Check for circular dependencies
+    const visited = new Set();
+    const recStack = new Set();
+    const hasCycle = (varName) => {
+        visited.add(varName);
+        recStack.add(varName);
+        const refs = (0, schemas_1.extractVariableReferences)(String(manifest.variables[varName]));
+        for (const ref of refs) {
+            if (!visited.has(ref)) {
+                if (hasCycle(ref)) {
+                    return true;
+                }
+            }
+            else if (recStack.has(ref)) {
+                return true;
+            }
+        }
+        recStack.delete(varName);
+        return false;
+    };
+    for (const varName of Object.keys(manifest.variables)) {
+        visited.clear();
+        recStack.clear();
+        if (hasCycle(varName)) {
+            errors.push({
+                severity: "error",
+                field: `variables.${varName}`,
+                message: `Circular variable dependency detected`,
+                suggestion: "Break the reference cycle in your variable definitions",
+            });
+        }
+    }
+    // Check for unused variables
+    const usedVars = new Set();
+    // Collect all references from colors
+    if (manifest.colors) {
+        Object.values(manifest.colors).forEach((val) => {
+            if (val) {
+                (0, schemas_1.extractVariableReferences)(String(val)).forEach((v) => usedVars.add(v));
+            }
+        });
+    }
+    // Collect from tokens
+    if (manifest.tokens) {
+        Object.values(manifest.tokens).forEach((settings) => {
+            Object.values(settings).forEach((val) => {
+                (0, schemas_1.extractVariableReferences)(String(val)).forEach((v) => usedVars.add(v));
+            });
+        });
+    }
+    // Collect from semantic tokens
+    if (manifest.semanticTokens) {
+        Object.values(manifest.semanticTokens).forEach((settings) => {
+            Object.values(settings).forEach((val) => {
+                (0, schemas_1.extractVariableReferences)(String(val)).forEach((v) => usedVars.add(v));
+            });
+        });
+    }
+    // Collect from language tokens
+    if (manifest.languageTokens) {
+        Object.values(manifest.languageTokens).forEach((langTokens) => {
+            Object.values(langTokens).forEach((settings) => {
+                Object.values(settings).forEach((val) => {
+                    (0, schemas_1.extractVariableReferences)(String(val)).forEach((v) => usedVars.add(v));
+                });
+            });
+        });
+    }
+    // Collect from presets
+    if (manifest.presets) {
+        Object.values(manifest.presets).forEach((preset) => {
+            if (preset.variableOverrides) {
+                Object.values(preset.variableOverrides).forEach((val) => {
+                    (0, schemas_1.extractVariableReferences)(String(val)).forEach((v) => usedVars.add(v));
+                });
+            }
+        });
+    }
+    // Check unused
+    for (const varName of Object.keys(manifest.variables)) {
+        if (!usedVars.has(varName)) {
+            warnings.push({
+                severity: "warning",
+                field: `variables.${varName}`,
+                message: `Unused variable $${varName}`,
+                suggestion: "Safe to remove if not needed",
+            });
+        }
+    }
+    return { errors, warnings };
+}
+function validateComputedColors(manifest) {
+    const errors = [];
+    if (!manifest.computed)
+        return errors;
+    Object.entries(manifest.computed).forEach(([name, entry]) => {
+        // Validate base
+        if (entry.base.startsWith("$")) {
+            if (!manifest.variables?.[entry.base.slice(1)]) {
+                errors.push({
+                    severity: "error",
+                    field: `computed.${name}`,
+                    message: `Base variable ${entry.base} is undefined`,
+                });
+            }
+        }
+        else if (!(0, colors_1.parseAndNormalizeColor)(entry.base)) {
+            errors.push({
+                severity: "error",
+                field: `computed.${name}`,
+                message: `Base color ${entry.base} has invalid format`,
+            });
+        }
+        // Validate transform
+        if (!["darken", "lighten", "alpha"].includes(entry.transform)) {
+            errors.push({
+                severity: "error",
+                field: `computed.${name}`,
+                message: `Invalid transform "${entry.transform}". Use: darken, lighten, alpha`,
+            });
+        }
+        // Validate amount
+        if (entry.amount < 0 || entry.amount > 100) {
+            errors.push({
+                severity: "error",
+                field: `computed.${name}`,
+                message: `Amount must be 0-100, got ${entry.amount}`,
+            });
+        }
+    });
+    return errors;
+}
+function validateTokens(manifest) {
+    const errors = [];
+    if (!manifest.tokens)
+        return errors;
+    Object.entries(manifest.tokens).forEach(([scope, settings]) => {
+        validateTokenProperties(scope, settings, "tokens", errors);
+    });
+    return errors;
+}
+function validateSemanticTokens(manifest) {
+    const errors = [];
+    if (!manifest.semanticTokens)
+        return errors;
+    Object.entries(manifest.semanticTokens).forEach(([scope, settings]) => {
+        validateTokenProperties(scope, settings, "semanticTokens", errors);
+    });
+    return errors;
+}
+function validateLanguageTokens(manifest) {
+    const errors = [];
+    if (!manifest.languageTokens)
+        return errors;
+    Object.entries(manifest.languageTokens).forEach(([language, langTokens]) => {
+        Object.entries(langTokens).forEach(([scope, settings]) => {
+            validateTokenProperties(scope, settings, `languageTokens.${language}`, errors);
+        });
+    });
+    return errors;
+}
+function validateTokenProperties(scope, settings, prefix, errors) {
+    Object.entries(settings).forEach(([prop, value]) => {
+        const strVal = String(value);
+        // Check foreground/background colors
+        if ((prop === "foreground" || prop === "background") && !strVal.startsWith("$")) {
+            const result = (0, colors_1.parseAndNormalizeColor)(strVal);
+            if (!result) {
+                errors.push({
+                    severity: "error",
+                    field: `${prefix}.${scope}.${prop}`,
+                    message: `Invalid color format "${strVal}"`,
+                });
+            }
+        }
+        // Check fontStyle - can be single or space-separated multiple
+        if (prop === "fontStyle" && strVal !== "") {
+            const styles = strVal.split(/\s+/);
+            const invalid = styles.filter((s) => !["bold", "italic", "underline"].includes(s));
+            if (invalid.length > 0) {
+                errors.push({
+                    severity: "error",
+                    field: `${prefix}.${scope}.${prop}`,
+                    message: `Invalid fontStyle "${strVal}". Use: bold, italic, underline (can combine)`,
+                });
+            }
+        }
+        // Check fontWeight
+        if (prop === "fontWeight") {
+            const weight = parseInt(strVal, 10);
+            if (!["normal", "bold"].includes(strVal) &&
+                (isNaN(weight) || weight < 100 || weight > 900 || weight % 100 !== 0)) {
+                errors.push({
+                    severity: "error",
+                    field: `${prefix}.${scope}.${prop}`,
+                    message: `Invalid fontWeight "${strVal}". Use: normal, bold, or 100-900`,
+                });
+            }
+        }
+        // Check opacity
+        if (prop === "opacity") {
+            const opacity = parseFloat(strVal);
+            if (isNaN(opacity) || opacity < 0 || opacity > 1) {
+                errors.push({
+                    severity: "error",
+                    field: `${prefix}.${scope}.${prop}`,
+                    message: `Opacity must be 0-1, got ${strVal}`,
+                });
+            }
+        }
+    });
+}
+function validatePresets(manifest) {
+    const errors = [];
+    if (!manifest.presets)
+        return errors;
+    Object.entries(manifest.presets).forEach(([presetName, preset]) => {
+        // Validate variable overrides reference defined variables
+        if (preset.variableOverrides) {
+            Object.keys(preset.variableOverrides).forEach((varName) => {
+                if (!manifest.variables?.[varName]) {
+                    errors.push({
+                        severity: "error",
+                        field: `presets.${presetName}`,
+                        message: `Preset references undefined variable $${varName}`,
+                        suggestion: `Define $${varName} in variables section`,
+                    });
+                }
+            });
+        }
+    });
+    return errors;
+}
+async function validateExtends(extendsPath, manifestPath) {
+    const errors = [];
+    const resolvedExtends = path.resolve(path.dirname(manifestPath), extendsPath);
+    try {
+        await fs.stat(resolvedExtends);
+    }
+    catch {
+        errors.push({
+            severity: "error",
+            field: "extends",
+            message: `Extends file not found: ${extendsPath}`,
+            suggestion: `Check the path relative to manifest location`,
+        });
+    }
+    return errors;
+}
+function applyColorConversions(data, conversions) {
+    const result = JSON.parse(JSON.stringify(data));
+    conversions.forEach((conv) => {
+        const parts = conv.field.split(".");
+        let obj = result;
+        for (let i = 0; i < parts.length - 1; i++) {
+            obj = obj[parts[i]];
+        }
+        obj[parts[parts.length - 1]] = conv.to;
+    });
+    return result;
+}
+function getStats(manifest) {
+    return {
+        variables: Object.keys(manifest?.variables || {}).length,
+        colors: Object.keys(manifest?.colors || {}).length,
+        tokens: Object.keys(manifest?.tokens || {}).length,
+        semanticTokens: Object.keys(manifest?.semanticTokens || {}).length,
+        languageTokens: Object.keys(manifest?.languageTokens || {}).length,
+        presets: Object.keys(manifest?.presets || {}).length,
+        extends: !!manifest?.extends,
+        computed: Object.keys(manifest?.computed || {}).length,
+        colorConversions: 0,
+    };
+}
+function normalizeColorsInManifest(data, conversions) {
+    // Normalize variables
+    if (data.variables) {
+        Object.entries(data.variables).forEach(([key, value]) => {
+            if (typeof value === "string" && !value.startsWith("$")) {
+                const result = (0, colors_1.parseAndNormalizeColor)(value);
+                if (result && result.changes.length > 0) {
+                    conversions.push({
+                        line: 0,
+                        field: `variables.${key}`,
+                        from: value,
+                        to: result.hex,
+                    });
+                    data.variables[key] = result.hex;
+                }
+            }
+        });
+    }
+    // Normalize colors
+    if (data.colors) {
+        Object.entries(data.colors).forEach(([key, value]) => {
+            if (value !== null && typeof value === "string" && !value.startsWith("$")) {
+                const result = (0, colors_1.parseAndNormalizeColor)(value);
+                if (result && result.changes.length > 0) {
+                    conversions.push({
+                        line: 0,
+                        field: `colors.${key}`,
+                        from: value,
+                        to: result.hex,
+                    });
+                    data.colors[key] = result.hex;
+                }
+            }
+        });
+    }
+    // Normalize tokens
+    if (data.tokens) {
+        Object.entries(data.tokens).forEach(([scope, settings]) => {
+            Object.entries(settings).forEach(([prop, value]) => {
+                if (typeof value === "string" &&
+                    (prop === "foreground" || prop === "background") &&
+                    !value.startsWith("$")) {
+                    const result = (0, colors_1.parseAndNormalizeColor)(value);
+                    if (result && result.changes.length > 0) {
+                        conversions.push({
+                            line: 0,
+                            field: `tokens.${scope}.${prop}`,
+                            from: value,
+                            to: result.hex,
+                        });
+                        data.tokens[scope][prop] = result.hex;
+                    }
+                }
+            });
+        });
+    }
+    // Normalize semanticTokens
+    if (data.semanticTokens) {
+        Object.entries(data.semanticTokens).forEach(([scope, settings]) => {
+            Object.entries(settings).forEach(([prop, value]) => {
+                if (typeof value === "string" &&
+                    (prop === "foreground" || prop === "background") &&
+                    !value.startsWith("$")) {
+                    const result = (0, colors_1.parseAndNormalizeColor)(value);
+                    if (result && result.changes.length > 0) {
+                        conversions.push({
+                            line: 0,
+                            field: `semanticTokens.${scope}.${prop}`,
+                            from: value,
+                            to: result.hex,
+                        });
+                        data.semanticTokens[scope][prop] = result.hex;
+                    }
+                }
+            });
+        });
+    }
+    // Normalize languageTokens
+    if (data.languageTokens) {
+        Object.entries(data.languageTokens).forEach(([lang, langTokens]) => {
+            Object.entries(langTokens).forEach(([scope, settings]) => {
+                Object.entries(settings).forEach(([prop, value]) => {
+                    if (typeof value === "string" &&
+                        (prop === "foreground" || prop === "background") &&
+                        !value.startsWith("$")) {
+                        const result = (0, colors_1.parseAndNormalizeColor)(value);
+                        if (result && result.changes.length > 0) {
+                            conversions.push({
+                                line: 0,
+                                field: `languageTokens.${lang}.${scope}.${prop}`,
+                                from: value,
+                                to: result.hex,
+                            });
+                            data.languageTokens[lang][scope][prop] = result.hex;
+                        }
+                    }
+                });
+            });
+        });
+    }
+    // Normalize presets
+    if (data.presets) {
+        Object.entries(data.presets).forEach(([presetName, preset]) => {
+            if (preset.variableOverrides) {
+                Object.entries(preset.variableOverrides).forEach(([varName, value]) => {
+                    if (typeof value === "string" && !value.startsWith("$")) {
+                        const result = (0, colors_1.parseAndNormalizeColor)(value);
+                        if (result && result.changes.length > 0) {
+                            conversions.push({
+                                line: 0,
+                                field: `presets.${presetName}.variableOverrides.${varName}`,
+                                from: value,
+                                to: result.hex,
+                            });
+                            data.presets[presetName].variableOverrides[varName] = result.hex;
+                        }
+                    }
+                });
+            }
+        });
+    }
+}
+function validateExporters(manifest) {
+    const errors = [];
+    try {
+        (0, vscode_1.exportVSCode)(manifest);
+    }
+    catch (error) {
+        errors.push({
+            severity: "error",
+            field: "exporters.vscode",
+            message: `VS Code export failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+    try {
+        (0, zed_1.exportZed)(manifest);
+    }
+    catch (error) {
+        errors.push({
+            severity: "error",
+            field: "exporters.zed",
+            message: `Zed export failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+    try {
+        (0, notepad_plus_1.exportNotepadPlus)(manifest);
+    }
+    catch (error) {
+        errors.push({
+            severity: "error",
+            field: "exporters.notepad++",
+            message: `Notepad++ export failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+    return errors;
+}
+function printValidationResult(errors, warnings, manifest, conversions, isFixing) {
+    if (errors.length === 0 && warnings.length === 0) {
+        const stats = getStats(manifest);
+        logger_1.logger.success("manifest.json valid");
+        console.log(`  • ${stats.variables} variables, ${stats.colors} colors, ${stats.tokens} tokens`);
+        if (stats.presets > 0)
+            console.log(`  • ${stats.presets} presets`);
+        if (stats.computed > 0)
+            console.log(`  • ${stats.computed} computed colors`);
+        if (conversions.length > 0) {
+            console.log(`  • All colors converted: ${conversions.map((c) => `${c.from} → ${c.to}`).join(", ")}`);
+        }
+        console.log(`  • No issues`);
+    }
+    else {
+        const errorCount = errors.length;
+        const warningCount = warnings.length;
+        logger_1.logger.error(`manifest.json invalid (${errorCount} error${errorCount !== 1 ? "s" : ""}, ${warningCount} warning${warningCount !== 1 ? "s" : ""})`);
+        console.log("");
+        errors.forEach((err) => {
+            console.log(`  ERROR [${err.field}]: ${err.message}`);
+            if (err.suggestion) {
+                console.log(`    ${err.suggestion}`);
+            }
+        });
+        if (warningCount > 0) {
+            console.log("");
+        }
+        warnings.forEach((warn) => {
+            console.log(`  WARNING [${warn.field}]: ${warn.message}`);
+            if (warn.suggestion) {
+                console.log(`    ${warn.suggestion}`);
+            }
+        });
+    }
+}
+//# sourceMappingURL=validate.js.map