juxscript 1.0.66 → 1.0.67

package/machinery/verifier.js

@@ -1,14 +1,13 @@
 import fs from 'fs';
 import path from 'path';
 import http from 'http';
-import * as acorn from 'acorn'; // Needed to parse main.js
+import * as acorn from 'acorn';
 
 /**
  * Checks the static `distDir` for critical files and valid import map references.
  * Returns true if healthy, false if broken.
  */
 export function verifyStaticBuild(distDir) {
-    // console.log('🕵️  Verifying build integrity...');
     const errors = [];
 
     if (!fs.existsSync(distDir)) {
@@ -17,7 +16,8 @@ export function verifyStaticBuild(distDir) {
     }
 
     // 1. Critical Files Existence
-    const critical = ['index.html', 'main.js', 'lib/jux.js'];
+    // ✅ FIX: Removed lib/jux.js as it is no longer the primary artifact with v2 components
+    const critical = ['index.html', 'main.js'];
     for (const f of critical) {
         if (!fs.existsSync(path.join(distDir, f))) {
             errors.push(`Missing critical artifact: ${f}`);
@@ -41,6 +41,8 @@ export function verifyStaticBuild(distDir) {
                         const fullPath = path.join(distDir, fsPath);
 
                         if (!fs.existsSync(fullPath)) {
+                            // Downgrade missing imports to warnings if they look like vendored libs?
+                            // For now, keep as error to be safe.
                             errors.push(`Broken Import Map: "${key}" -> ${url} (File not found)`);
                         }
                     }
@@ -62,14 +64,10 @@ export function verifyStaticBuild(distDir) {
                 if (node.type === 'ImportDeclaration') {
                     const source = node.source.value;
 
-                    // Allow internal relative paths if they exist
                     if (source.startsWith('/') || source.startsWith('.')) {
-                        // basic existence check (simplified)
                         return;
                     }
 
-                    // Check if bare specifier exists in Import Map
-                    // e.g. import axios from 'axios' -> must be in map
                     if (!importMap[source] && !importMap[source + '/']) {
                         errors.push(`Ghost Dependency: '${source}' is imported in main.js but missing from Import Map.`);
                     }
@@ -87,33 +85,26 @@ export function verifyStaticBuild(distDir) {
         return false;
     }
 
-    // console.log('   ✓ Static verification passed');
     return true;
 }
 
-/**
- * Pings the running server to ensure correct MIME types and Route availability.
- * Detects "serving JS as HTML" (MIME type mismatch) errors.
- */
 export function verifyRuntime(port) {
     return new Promise((resolve) => {
-        console.log('🩺 Performing runtime diagnostics...');
+        // console.log('🩺 Performing runtime diagnostics...');
         const errors = [];
 
         // Helper to check a single URL
         const check = (urlPath, expectedMime) => new Promise(r => {
             const req = http.get(`http://localhost:${port}${urlPath}`, res => {
-                // Check Status
                 if (res.statusCode !== 200 && res.statusCode !== 304) {
                     errors.push(`GET ${urlPath} : Status ${res.statusCode} (Expected 200)`);
                 } else {
-                    // Check MIME type
                     const ct = res.headers['content-type'] || '';
                     if (expectedMime && !ct.includes(expectedMime)) {
-                        errors.push(`GET ${urlPath} : Bad MIME type. Got "${ct}", expected "${expectedMime}". (Did you get index.html fallback?)`);
+                        errors.push(`GET ${urlPath} : Bad MIME type. Got "${ct}", expected "${expectedMime}".`);
                     }
                 }
-                res.resume(); // Consume stream
+                res.resume();
                 r();
             });
 
@@ -125,9 +116,9 @@ export function verifyRuntime(port) {
 
         // Run checks in parallel
         Promise.all([
-            check('/', 'text/html'),                   // Route should be HTML
-            check('/main.js', 'application/javascript'), // Bundle must be JS
-            check('/lib/jux.js', 'application/javascript') // Library must be JS
+            check('/', 'text/html'),
+            check('/main.js', 'application/javascript'),
+            // check('/lib/jux.js', 'application/javascript') // Removed check
         ]).then(() => {
             if (errors.length > 0) {
                 console.error(`\n💥 RUNTIME VERIFICATION FAILED (` + errors.length + ` errors):`);
@@ -135,7 +126,7 @@ export function verifyRuntime(port) {
                 console.log('');
                 resolve(false);
             } else {
-                console.log('   ✓ Runtime health healthy (Routes & MIME types OK)\n');
+                // console.log('   ✓ Runtime health healthy\n');
                 resolve(true);
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juxscript",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "type": "module",
   "description": "A JavaScript UX authorship platform",
   "main": "lib/jux.js",

package/machinery/build.js

@@ -1,467 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import esbuild from 'esbuild';
-import {
-    bundleJuxFilesToRouter,
-    generateRouterIndex
-} from './compiler.js';
-
-/**
- * Generate import map script tag
- */
-function generateImportMapScript() {
-    return `<script type="importmap">
-{
-  "imports": {
-    "juxscript": "./lib/jux.js",
-    "juxscript/": "./lib/",
-    "juxscript/reactivity": "./lib/reactivity/state.js",
-    "juxscript/presets/": "./presets/",
-    "juxscript/components/": "./lib/components/",
-    "juxscript/componentsv2/": "./lib/componentsv2/"
-  }
-}
-</script>`;
-}
-
-/**
- * Compile a .jux file to .js and .html
- * 
- * @param {string} juxFilePath - Path to the .jux file
- * @param {Object} options - Compilation options
- * @param {string} options.distDir - Output directory
- * @param {string} options.projectRoot - Project root directory
- * @param {boolean} options.isServe - Whether serving for development
- * @returns {Promise<{jsOutputPath: string, htmlOutputPath: string}>}
- */
-export async function compileJuxFile(juxFilePath, options = {}) {
-    const { distDir, projectRoot, isServe = false } = options;
-
-    const relativePath = path.relative(projectRoot, juxFilePath);
-    const parsedPath = path.parse(relativePath);
-
-    // Output paths
-    const outputDir = path.join(distDir, parsedPath.dir);
-    const jsOutputPath = path.join(outputDir, `${parsedPath.name}.js`);
-    const htmlOutputPath = path.join(outputDir, `${parsedPath.name}.html`);
-
-    // Ensure output directory exists
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-    }
-
-    console.log(`📝 Compiling: ${relativePath}`);
-
-    // Read the .jux file
-    const juxContent = fs.readFileSync(juxFilePath, 'utf-8');
-
-    // Calculate depth for relative paths
-    const depth = parsedPath.dir.split(path.sep).filter(p => p).length;
-    const libPath = depth === 0 ? './lib/jux.js' : '../'.repeat(depth) + 'lib/jux.js';
-
-    // Transform imports
-    let transformedContent = juxContent;
-
-    // Replace common import patterns with calculated path
-    transformedContent = transformedContent.replace(
-        /from\s+['"]\.\.?\/lib\/jux\.js['"]/g,
-        `from '${libPath}'`
-    );
-
-    // Only inject import if:
-    // 1. File is not empty (ignoring whitespace and comments)
-    // 2. File uses 'jux.' but has no import statement
-    const contentWithoutComments = transformedContent
-        .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
-        .replace(/\/\/.*/g, '')             // Remove line comments
-        .trim();
-
-    const hasContent = contentWithoutComments.length > 0;
-    const usesJux = /\bjux\./g.test(contentWithoutComments);
-    const hasImport = /import\s+.*from/.test(transformedContent);
-
-    if (hasContent && usesJux && !hasImport) {
-        transformedContent = `import { jux } from '${libPath}';\n\n${transformedContent}`;
-    }
-
-    // Write the transformed JS
-    fs.writeFileSync(jsOutputPath, transformedContent);
-
-    console.log(`  ✓ JS: ${path.relative(projectRoot, jsOutputPath)}`);
-
-    // Generate HTML with import map and correct script path
-    const scriptPath = `./${parsedPath.name}.js`;
-    const importMapScript = generateImportMapScript();
-
-    const html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${parsedPath.name}</title>
-</head>
-<body data-theme="">
-  <!-- App container -->
-  <div id="app" data-jux-page="${parsedPath.name}"></div>
-  
-  ${importMapScript}
-  <script type="module" src="${scriptPath}"></script>
-  ${isServe ? `
-  <!-- Hot reload -->
-  <script type="module">
-    const ws = new WebSocket('ws://localhost:3001');
-    ws.onmessage = (msg) => {
-      const data = JSON.parse(msg.data);
-      if (data.type === 'reload') {
-        console.log('🔄 Reloading page...');
-        location.reload();
-      }
-    };
-    ws.onerror = () => console.warn('⚠️  WebSocket connection failed');
-  </script>
-  ` : ''}
-</body>
-</html>`;
-
-    fs.writeFileSync(htmlOutputPath, html);
-    console.log(`  ✓ HTML: ${path.relative(projectRoot, htmlOutputPath)}`);
-
-    return { jsOutputPath, htmlOutputPath };
-}
-
-/**
- * Copy and build the JUX library from TypeScript to JavaScript
- * 
- * @param {string} projectRoot - Root directory containing lib/
- * @param {string} distDir - Destination directory for built files
- */
-export async function copyLibToOutput(projectRoot, distDir) {
-    // Simplified lib path resolution
-    const libSrc = path.resolve(projectRoot, '../lib');
-
-    if (!fs.existsSync(libSrc)) {
-        throw new Error(`lib/ directory not found at ${libSrc}`);
-    }
-
-    const libDest = path.join(distDir, 'lib');
-
-    console.log('📦 Building TypeScript library...');
-    console.log(`   From: ${libSrc}`);
-    console.log(`   To: ${libDest}`);
-
-    if (fs.existsSync(libDest)) {
-        fs.rmSync(libDest, { recursive: true });
-    }
-
-    fs.mkdirSync(libDest, { recursive: true });
-
-    // Find all TypeScript entry points
-    const tsFiles = findFiles(libSrc, '.ts');
-
-    if (tsFiles.length === 0) {
-        console.warn('⚠️  No TypeScript files found in lib/');
-        return;
-    }
-
-    console.log(`   Found ${tsFiles.length} TypeScript files`);
-
-    // Build all TypeScript files with esbuild
-    try {
-        await esbuild.build({
-            entryPoints: tsFiles,
-            bundle: false,
-            format: 'esm',
-            outdir: libDest,
-            outbase: libSrc,
-            platform: 'browser',
-            target: 'es2020',
-            loader: {
-                '.ts': 'ts'
-            },
-            logLevel: 'warning'
-        });
-
-        console.log('   ✓ TypeScript compiled to JavaScript');
-
-        // Copy non-TS files (CSS, HTML, etc.)
-        console.log('   Copying lib assets...');
-        copyNonTsFiles(libSrc, libDest);
-        console.log('   ✓ Lib assets copied');
-
-    } catch (err) {
-        console.error('❌ Failed to build TypeScript:', err.message);
-        throw err;
-    }
-
-    console.log('✅ Library ready\n');
-}
-
-/**
- * Copy project assets (CSS, JS, images) from jux/ to dist/
- * 
- * @param {string} projectRoot - Source directory (jux/)
- * @param {string} distDir - Destination directory (jux-dist/)
- */
-export async function copyProjectAssets(projectRoot, distDir) {
-    console.log('📦 Copying project assets...');
-
-    // Find all CSS and JS files in project root (excluding node_modules, dist, .git)
-    const allFiles = [];
-    findProjectFiles(projectRoot, ['.css', '.js'], allFiles, projectRoot);
-
-    console.log(`   Found ${allFiles.length} asset file(s)`);
-
-    for (const srcPath of allFiles) {
-        const relativePath = path.relative(projectRoot, srcPath);
-        const destPath = path.join(distDir, relativePath);
-        const destDir = path.dirname(destPath);
-
-        // Create destination directory if needed
-        if (!fs.existsSync(destDir)) {
-            fs.mkdirSync(destDir, { recursive: true });
-        }
-
-        // Copy file
-        fs.copyFileSync(srcPath, destPath);
-        console.log(`   ✓ ${relativePath}`);
-    }
-
-    console.log('✅ Project assets copied\n');
-}
-
-/**
- * Transpile TypeScript files from jux/ to jux-dist/, preserving folder structure
- * 
- * @param {string} srcDir - Source directory (jux/)
- * @param {string} destDir - Destination directory (jux-dist/)
- * @example
- * // jux/samples/mypage.ts -> jux-dist/samples/mypage.js
- * await transpileProjectTypeScript('jux/', 'jux-dist/');
- */
-export async function transpileProjectTypeScript(srcDir, destDir) {
-    console.log('🔷 Transpiling TypeScript files...');
-
-    // Find all TypeScript files in the project
-    const tsFiles = findFiles(srcDir, '.ts');
-
-    if (tsFiles.length === 0) {
-        console.log('   No TypeScript files found in project');
-        return;
-    }
-
-    console.log(`   Found ${tsFiles.length} TypeScript file(s)`);
-
-    try {
-        // Build all TypeScript files with esbuild
-        await esbuild.build({
-            entryPoints: tsFiles,
-            bundle: false,
-            format: 'esm',
-            outdir: destDir,
-            outbase: srcDir,
-            platform: 'browser',
-            target: 'es2020',
-            loader: {
-                '.ts': 'ts'
-            },
-            logLevel: 'warning'
-        });
-
-        // Log each transpiled file
-        tsFiles.forEach(tsFile => {
-            const relativePath = path.relative(srcDir, tsFile);
-            const jsPath = relativePath.replace(/\.ts$/, '.js');
-            console.log(`   ✓ ${relativePath} → ${jsPath}`);
-        });
-
-        console.log('✅ TypeScript transpiled\n');
-
-    } catch (err) {
-        console.error('❌ Failed to transpile TypeScript:', err.message);
-        throw err;
-    }
-}
-
-/**
- * Copy presets folder from lib to dist
- * 
- * @param {string} packageRoot - Source package root directory
- * @param {string} distDir - Destination directory
- */
-export async function copyPresetsToOutput(packageRoot, distDir) {
-    console.log('📦 Copying presets...');
-
-    const presetsSrc = path.join(packageRoot, 'presets');
-    const presetsDest = path.join(distDir, 'presets');
-
-    if (!fs.existsSync(presetsSrc)) {
-        console.log('   No presets directory found');
-        return;
-    }
-
-    if (fs.existsSync(presetsDest)) {
-        fs.rmSync(presetsDest, { recursive: true });
-    }
-
-    fs.mkdirSync(presetsDest, { recursive: true });
-
-    // Copy all files in presets directory
-    const files = fs.readdirSync(presetsSrc);
-    let copiedCount = 0;
-
-    for (const file of files) {
-        const srcPath = path.join(presetsSrc, file);
-        const destPath = path.join(presetsDest, file);
-
-        if (fs.statSync(srcPath).isFile()) {
-            fs.copyFileSync(srcPath, destPath);
-            console.log(`   ✓ ${file}`);
-            copiedCount++;
-        }
-    }
-
-    console.log(`✅ Copied ${copiedCount} preset file(s)\n`);
-}
-
-/**
- * Recursively find files with a specific extension
- * 
- * @param {string} dir - Directory to search
- * @param {string} extension - File extension (e.g., '.ts')
- * @param {string[]} fileList - Accumulator for found files
- * @returns {string[]} Array of file paths
- */
-async function findFiles(dir, extension, fileList = []) {
-    const fs = await import('fs');
-    const path = await import('path');
-    const files = fs.readdirSync(dir);
-
-    files.forEach(file => {
-        const filePath = path.join(dir, file);
-        const stat = fs.statSync(filePath);
-
-        if (stat.isDirectory() && !['node_modules', 'jux-dist', '.git', 'lib'].includes(file)) {
-            findFiles(filePath, extension, fileList);
-        } else if (file.endsWith(extension)) {
-            fileList.push(filePath);
-        }
-    });
-
-    return fileList;
-}
-
-/**
- * Copy non-TypeScript files (CSS, JSON, JS, SVG, etc.)
- * 
- * @param {string} src - Source directory
- * @param {string} dest - Destination directory
- */
-function copyNonTsFiles(src, dest) {
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-
-        if (entry.isDirectory()) {
-            if (!fs.existsSync(destPath)) {
-                fs.mkdirSync(destPath, { recursive: true });
-            }
-            copyNonTsFiles(srcPath, destPath);
-        } else if (entry.isFile()) {
-            const ext = path.extname(entry.name);
-            // Copy CSS, JSON, SVG, and JS files (but not .ts files)
-            if (['.css', '.json', '.js', '.svg', '.png', '.jpg', '.jpeg', '.gif', '.webp'].includes(ext)) {
-                fs.copyFileSync(srcPath, destPath);
-            }
-        }
-    }
-}
-
-/**
- * Find project files with specific extensions, excluding certain directories
- * 
- * @param {string} dir - Directory to search
- * @param {string[]} extensions - File extensions to find
- * @param {string[]} fileList - Accumulator for found files
- * @param {string} rootDir - Root directory for relative paths
- * @param {string[]} excludeDirs - Directories to exclude
- * @returns {string[]} Array of file paths
- */
-function findProjectFiles(dir, extensions, fileList = [], rootDir = dir, excludeDirs = ['node_modules', 'jux-dist', '.git', 'lib']) {
-    if (!fs.existsSync(dir)) return fileList;
-
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-            // Skip excluded directories
-            if (excludeDirs.includes(entry.name)) {
-                continue;
-            }
-            findProjectFiles(fullPath, extensions, fileList, rootDir, excludeDirs);
-        } else {
-            // Check if file has one of the desired extensions
-            const hasExtension = extensions.some(ext => entry.name.endsWith(ext));
-            if (hasExtension) {
-                fileList.push(fullPath);
-            }
-        }
-    }
-
-    return fileList;
-}
-
-/**
- * Build a project
- * 
- * @param {string} projectRoot - Root directory containing lib/
- * @param {string} distDir - Destination directory for built files
- * @param {Object} options - Compilation options
- * @param {string} options.routePrefix - Route prefix
- * @returns {Promise<{jsOutputPath: string, htmlOutputPath: string}>}
- */
-export async function buildProject(options = {}) {
-    const { projectRoot, distDir } = options;
-
-    // Ensure project root and dist directory exist
-    if (!fs.existsSync(projectRoot)) {
-        throw new Error(`Project root directory not found: ${projectRoot}`);
-    }
-    if (!fs.existsSync(distDir)) {
-        fs.mkdirSync(distDir, { recursive: true });
-    }
-
-    // Option to use router mode
-    if (options.router) {
-        console.log('🔀 Building in router mode...\n');
-
-        await bundleJuxFilesToRouter(projectRoot, distDir, {
-            routePrefix: options.routePrefix || ''
-        });
-
-        // Get route information for index generation
-        const juxFiles = findFiles(projectRoot, '.jux');
-        const routes = juxFiles.map(juxFile => {
-            const relativePath = path.relative(projectRoot, juxFile);
-            const parsedPath = path.parse(relativePath);
-            const functionName = parsedPath.dir
-                ? `${parsedPath.dir.replace(/\//g, '_')}_${parsedPath.name}`
-                : parsedPath.name;
-            const routePath = (options.routePrefix || '') + '/' +
-                (parsedPath.dir ? `${parsedPath.dir}/` : '') + parsedPath.name;
-            return {
-                path: routePath.replace(/\/+/g, '/'),
-                functionName
-            };
-        });
-
-        generateRouterIndex(distDir, routes);
-    } else {
-        // ...existing individual page compilation...
-    }
-
-    // ...existing code...
-}