juxscript 1.1.386 → 1.1.388

package/machinery/compiler4.js

@@ -6,6 +6,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { generateErrorCollector } from './errors.js';
 import { autowrap } from './autowrap.js';
+import { validateJuxFiles, printValidationResults } from './validate-jux.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -750,6 +751,18 @@ ${bodyContainers}    <div id="app"></div>
             fs.copyFileSync(errSrc, path.join(this.distDir, 'jux-errors.js'));
         }
 
+        // ── Validate .jux files before compilation ──
+        const packageRoot = path.resolve(__dirname, '..');
+        const juxValidation = validateJuxFiles(this.srcDir, packageRoot);
+        const juxErrorCount = printValidationResults(juxValidation);
+        if (juxErrorCount > 0) {
+            console.error(`\n🛑 BUILD FAILED — ${juxErrorCount} .jux validation error(s)\n`);
+            return { success: false, errors: juxValidation.errors, warnings: juxValidation.warnings };
+        }
+        if (juxValidation.stats.files > 0) {
+            console.log(`✅ Validated ${juxValidation.stats.files} .jux file(s): ${juxValidation.stats.calls} calls, ${juxValidation.stats.vars} tracked vars`);
+        }
+
         this.copyPublicFolder();
 
         const precompileResult = this._validatePrecompile();

package/machinery/validate-jux.js

@@ -0,0 +1,333 @@
+/**
+ * Validates .jux files against the Jux interface and component method signatures.
+ * Shared between run-tests.js (npm test) and compiler4.js (npm run build).
+ *
+ * Returns { errors: [...], warnings: [...], stats: { files, calls, vars } }
+ */
+import fs from 'fs';
+import path from 'path';
+import * as acorn from 'acorn';
+
+const RED = '\x1b[31m';
+const RESET = '\x1b[0m';
+
+/**
+ * @param {string} juxDir - Directory containing .jux files
+ * @param {string} packageRoot - Root of the jux package (contains lib/ or dist/)
+ * @returns {{ errors: Array<{file:string,line:number,message:string}>, warnings: Array, stats: {files:number,calls:number,vars:number} }}
+ */
+export function validateJuxFiles(juxDir, packageRoot) {
+    const errors = [];
+    const warnings = [];
+    const stats = { files: 0, calls: 0, vars: 0 };
+
+    // Find index source: prefer lib/index.ts (dev), fall back to dist/index.js (installed)
+    let INDEX_PATH = path.resolve(packageRoot, 'lib/index.ts');
+    let COMPONENTS_DIR = path.resolve(packageRoot, 'lib/components');
+    let isTypescript = true;
+
+    if (!fs.existsSync(INDEX_PATH)) {
+        INDEX_PATH = path.resolve(packageRoot, 'dist/index.js');
+        COMPONENTS_DIR = path.resolve(packageRoot, 'dist/components');
+        isTypescript = false;
+    }
+
+    if (!fs.existsSync(INDEX_PATH)) {
+        warnings.push({ file: '', line: 0, message: `Neither lib/index.ts nor dist/index.js found in ${packageRoot}` });
+        return { errors, warnings, stats };
+    }
+
+    const indexSource = fs.readFileSync(INDEX_PATH, 'utf8');
+
+    // ── Extract valid Jux interface keys ──
+    let validKeys;
+    const ifaceMatch = indexSource.match(/export\s+interface\s+Jux\s*\{([\s\S]*?)\}/);
+    if (ifaceMatch) {
+        validKeys = new Set(
+            [...ifaceMatch[1].matchAll(/^\s*(\w+)\s*:/gm)].map(m => m[1])
+        );
+    } else {
+        const objMatch = indexSource.match(/(?:const|let|var)\s+jux\s*=\s*\{([\s\S]*?)\};/);
+        if (objMatch) {
+            validKeys = new Set(
+                [...objMatch[1].matchAll(/\b(\w+)\s*[,:]/gm)].map(m => m[1])
+            );
+        }
+    }
+
+    if (!validKeys || validKeys.size === 0) {
+        warnings.push({ file: INDEX_PATH, line: 0, message: 'Could not extract Jux keys from index' });
+        return { errors, warnings, stats };
+    }
+
+    // ── Build factory→component file mapping ──
+    const factoryToFile = {};
+    const importMatches = [...indexSource.matchAll(/import\s+\{([^}]+)\}\s+from\s+['"]\.\/components\/([^'"]+)['"]/g)];
+    for (const [, names, filePath] of importMatches) {
+        const file = isTypescript ? filePath.replace(/\.js$/, '.ts') : filePath;
+        for (const name of names.split(',').map(n => n.trim())) {
+            if (name) factoryToFile[name] = file;
+        }
+    }
+
+    // ── Build factory→valid methods & option keys ──
+    const factoryMethods = {};
+    const factoryOptionKeys = {};
+    const processedFiles = new Set();
+
+    for (const [, componentFile] of Object.entries(factoryToFile)) {
+        if (processedFiles.has(componentFile)) continue;
+        processedFiles.add(componentFile);
+
+        const filePath = path.join(COMPONENTS_DIR, componentFile);
+        if (!fs.existsSync(filePath)) continue;
+
+        const source = fs.readFileSync(filePath, 'utf8');
+
+        // Extract methods — works for both .ts and .js
+        const methods = new Set();
+        // Match methods with balanced parens in params (handles callback types like (fn: (e: Event) => void))
+        const methodRegex = /^\s{4}(\w+)\s*\(/gm;
+        let match;
+        while ((match = methodRegex.exec(source)) !== null) {
+            const name = match[1];
+            if (name === 'constructor' || name.startsWith('_')) continue;
+            // Verify it's actually a method (not just any line starting with a word and paren)
+            // by checking it's followed by a method body pattern
+            const restOfLine = source.substring(match.index + match[0].length);
+            // Skip if it looks like a keyword (if, for, while, etc.)
+            if (['if', 'for', 'while', 'switch', 'catch', 'return', 'throw', 'new', 'delete', 'typeof', 'void'].includes(name)) continue;
+            methods.add(name);
+        }
+        for (const m of source.matchAll(/^\s{4}get\s+(\w+)\s*\(/gm)) {
+            methods.add(m[1]);
+        }
+
+        // Extract option keys — TypeScript interfaces only
+        const optKeys = new Set();
+        if (isTypescript) {
+            for (const [, body] of source.matchAll(/interface\s+\w+Options\s*\{([^}]+)\}/gs)) {
+                for (const m of body.matchAll(/^\s*(\w+)\??:/gm)) {
+                    optKeys.add(m[1]);
+                }
+            }
+        }
+
+        for (const [fn, file] of Object.entries(factoryToFile)) {
+            if (file === componentFile) {
+                factoryMethods[fn] = methods;
+                factoryOptionKeys[fn] = optKeys;
+            }
+        }
+    }
+
+    // ── Find .jux files ──
+    if (!fs.existsSync(juxDir)) return { errors, warnings, stats };
+
+    const juxFiles = findFilesRecursive(juxDir, '.jux');
+    stats.files = juxFiles.length;
+
+    for (const filePath of juxFiles) {
+        const source = fs.readFileSync(filePath, 'utf8');
+        const relPath = path.relative(packageRoot, filePath);
+
+        let ast;
+        try {
+            ast = acorn.parse(source, {
+                ecmaVersion: 2022,
+                sourceType: 'module',
+                allowAwaitOutsideFunction: true,
+            });
+        } catch (err) {
+            errors.push({ file: relPath, line: err.loc?.line || 0, message: `Syntax error: ${err.message}` });
+            continue;
+        }
+
+        // ── Validate jux.xxx() namespace calls ──
+        walkAST(ast, {
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type === 'MemberExpression' &&
+                    callee.object.type === 'Identifier' &&
+                    callee.object.name === 'jux' &&
+                    callee.property.type === 'Identifier') {
+                    stats.calls++;
+                    if (!validKeys.has(callee.property.name)) {
+                        errors.push({
+                            file: relPath,
+                            line: getLine(source, callee.start),
+                            message: `jux.${callee.property.name}() does not exist on Jux interface`
+                        });
+                    }
+                }
+            }
+        });
+
+        // ── Track variable→factory mappings ──
+        const varFactory = {};
+        for (const stmt of ast.body) {
+            if (stmt.type === 'VariableDeclaration') {
+                for (const decl of stmt.declarations) {
+                    if (decl.id.type === 'Identifier' && decl.init) {
+                        const factory = extractJuxFactory(decl.init);
+                        if (factory) varFactory[decl.id.name] = factory;
+                    }
+                }
+            }
+        }
+        stats.vars += Object.keys(varFactory).length;
+
+        // ── Validate inline chains on jux.xxx() initializers ──
+        // e.g. jux.btn('id').onClick(...).abc() — abc is invalid
+        walkAST(ast, {
+            CallExpression(node) {
+                // Only check member calls: something.method()
+                if (node.callee.type !== 'MemberExpression' ||
+                    node.callee.property.type !== 'Identifier') return;
+
+                const methodName = node.callee.property.name;
+                const obj = node.callee.object;
+
+                // Find the root jux.xxx factory by walking down the chain
+                const factory = extractJuxFactory(obj);
+                if (!factory) return;
+
+                // Don't flag the jux.xxx() call itself
+                if (extractJuxFactoryDirect(node)) return;
+
+                const validMethods = factoryMethods[factory];
+                if (validMethods && !validMethods.has(methodName)) {
+                    errors.push({
+                        file: relPath,
+                        line: getLine(source, node.callee.property.start),
+                        message: `.${methodName}() is not a method on jux.${factory}()`
+                    });
+                }
+            }
+        });
+
+        // ── Validate chained method calls on tracked variables ──
+        walkAST(ast, {
+            CallExpression(node) {
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier') {
+                    const methodName = node.callee.property.name;
+                    const varName = resolveRootVar(node.callee.object);
+
+                    if (varName && varFactory[varName]) {
+                        const factory = varFactory[varName];
+                        const validMethods = factoryMethods[factory];
+                        if (validMethods && !validMethods.has(methodName)) {
+                            // Avoid duplicate: skip if this was already caught by inline chain check
+                            if (!extractJuxFactory(node.callee.object)) {
+                                errors.push({
+                                    file: relPath,
+                                    line: getLine(source, node.callee.property.start),
+                                    message: `.${methodName}() is not a method on jux.${factory}()`
+                                });
+                            }
+                        }
+                    }
+                }
+
+                // Validate option keys — only when we have TS interface data
+                const factory = extractJuxFactoryDirect(node);
+                if (factory && factoryOptionKeys[factory] && factoryOptionKeys[factory].size > 0 && node.arguments.length > 1) {
+                    const optsArg = node.arguments[1];
+                    if (optsArg && optsArg.type === 'ObjectExpression') {
+                        const validOpts = factoryOptionKeys[factory];
+                        for (const prop of optsArg.properties) {
+                            if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+                                if (!validOpts.has(prop.key.name)) {
+                                    errors.push({
+                                        file: relPath,
+                                        line: getLine(source, prop.key.start),
+                                        message: `option '${prop.key.name}' is not valid for jux.${factory}()`
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    return { errors, warnings, stats };
+}
+
+/**
+ * Prints validation results to console with colors.
+ * @returns {number} Number of errors
+ */
+export function printValidationResults(result) {
+    if (result.errors.length > 0) {
+        console.error(`\n${RED}═══ .jux Validation Errors ═══${RESET}\n`);
+        for (const err of result.errors) {
+            console.error(`  ${RED}❌ ${err.file}:${err.line}: ${err.message}${RESET}`);
+        }
+        console.error('');
+    }
+    return result.errors.length;
+}
+
+// ── Helpers ──
+
+function findFilesRecursive(dir, ext) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) results.push(...findFilesRecursive(full, ext));
+        else if (entry.name.endsWith(ext)) results.push(full);
+    }
+    return results;
+}
+
+function walkAST(node, visitors) {
+    if (!node || typeof node !== 'object') return;
+    if (Array.isArray(node)) { node.forEach(n => walkAST(n, visitors)); return; }
+    if (visitors[node.type]) visitors[node.type](node);
+    for (const key of Object.keys(node)) {
+        if (['type', 'start', 'end', 'loc', 'raw'].includes(key)) continue;
+        const child = node[key];
+        if (child && typeof child === 'object') walkAST(child, visitors);
+    }
+}
+
+function getLine(source, pos) {
+    let line = 1;
+    for (let i = 0; i < pos; i++) { if (source[i] === '\n') line++; }
+    return line;
+}
+
+function extractJuxFactory(node) {
+    if (!node) return null;
+    if (node.type === 'CallExpression') {
+        const f = extractJuxFactoryDirect(node);
+        if (f) return f;
+        if (node.callee.type === 'MemberExpression') return extractJuxFactory(node.callee.object);
+    }
+    if (node.type === 'AwaitExpression') return extractJuxFactory(node.argument);
+    return null;
+}
+
+function extractJuxFactoryDirect(node) {
+    if (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === 'jux' &&
+        node.callee.property.type === 'Identifier') {
+        return node.callee.property.name;
+    }
+    return null;
+}
+
+function resolveRootVar(node) {
+    if (!node) return null;
+    if (node.type === 'Identifier') return node.name;
+    if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression') {
+        return resolveRootVar(node.callee.object);
+    }
+    if (node.type === 'MemberExpression') return resolveRootVar(node.object);
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juxscript",
-  "version": "1.1.386",
+  "version": "1.1.388",
   "type": "module",
   "description": "A JavaScript UX authorship platform",
   "main": "./dist/index.js",