juxscript 1.0.89 → 1.0.91

package/bin/cli.js

@@ -3,124 +3,275 @@
 import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const command = process.argv[2];
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
 
-function scaffoldProject(targetDir, packageRoot) {
+const [, , command, ...args] = process.argv;
+
+// ═══════════════════════════════════════════════════════════════
+// COMMAND: create <project-name>
+// Creates a new JUX project from the template
+// ═══════════════════════════════════════════════════════════════
+async function createProject(projectName) {
+  if (!projectName) {
+    console.error('❌ Usage: jux create <project-name>');
+    process.exit(1);
+  }
+
+  const targetDir = path.join(process.cwd(), projectName);
+
+  if (fs.existsSync(targetDir)) {
+    console.error(`❌ Directory "${projectName}" already exists.`);
+    process.exit(1);
+  }
+
+  console.log(`\n📦 Creating JUX project: ${projectName}\n`);
+
+  // 1. Create project directory
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  // 2. Copy template from /create folder
+  const templateDir = path.join(PACKAGE_ROOT, 'create');
+  if (fs.existsSync(templateDir)) {
+    copyDirRecursive(templateDir, path.join(targetDir, 'jux'));
+    console.log('   ✓ Copied template files');
+  } else {
+    // Fallback: create minimal starter
+    const juxDir = path.join(targetDir, 'jux');
+    fs.mkdirSync(juxDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(juxDir, 'index.jux'),
+      `import { Element } from 'juxscript';\n\nElement('welcome', { tagName: 'h1' })\n    .text('Welcome to JUX!')\n    .render('app');\n`
+    );
+    console.log('   ✓ Created starter file');
+  }
+
+  // 3. Copy example config
+  const configSrc = path.join(PACKAGE_ROOT, 'juxconfig.example.js');
+  const configDest = path.join(targetDir, 'juxconfig.js');
+  if (fs.existsSync(configSrc)) {
+    fs.copyFileSync(configSrc, configDest);
+    console.log('   ✓ Created juxconfig.js');
+  }
+
+  // 4. Create package.json
+  const pkg = {
+    name: projectName,
+    version: '0.1.0',
+    type: 'module',
+    scripts: {
+      dev: 'jux serve --hot',
+      build: 'jux build',
+      start: 'jux serve'
+    },
+    dependencies: {
+      juxscript: 'latest'
+    }
+  };
+  fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify(pkg, null, 2));
+  console.log('   ✓ Created package.json');
+
+  // 5. Create .gitignore
+  fs.writeFileSync(
+    path.join(targetDir, '.gitignore'),
+    `.jux-dist/\nnode_modules/\n.DS_Store\n.env\n*.log\n`
+  );
+  console.log('   ✓ Created .gitignore');
+
+  // 6. Install dependencies
+  console.log('\n📥 Installing dependencies...\n');
+  try {
+    const { execSync } = await import('child_process');
+    execSync('npm install', { cwd: targetDir, stdio: 'inherit' });
+  } catch (err) {
+    console.warn('⚠️  npm install failed. Run it manually.');
+  }
+
+  console.log(`
+✅ Project created successfully!
+
+   cd ${projectName}
+   npm run dev
+
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════
+// COMMAND: init
+// Initializes JUX in an existing project
+// ═══════════════════════════════════════════════════════════════
+function initProject() {
+  const targetDir = process.cwd();
+
+  console.log('\n📦 Initializing JUX in current directory\n');
+
+  // 1. Copy template to ./jux
+  const templateDir = path.join(PACKAGE_ROOT, 'create');
   const juxDir = path.join(targetDir, 'jux');
-  if (!fs.existsSync(juxDir)) fs.mkdirSync(juxDir, { recursive: true });
-  const presetDir = path.join(packageRoot, 'create');
-  let copied = 0;
-  if (fs.existsSync(presetDir)) {
-    fs.readdirSync(presetDir).forEach(file => {
-      if (file.startsWith('.')) return;
-      if (fs.statSync(path.join(presetDir, file)).isFile()) {
-        fs.copyFileSync(path.join(presetDir, file), path.join(juxDir, file));
-        copied++;
-      }
-    });
+
+  if (!fs.existsSync(juxDir)) {
+    fs.mkdirSync(juxDir, { recursive: true });
   }
-  if (copied === 0 && !fs.existsSync(path.join(juxDir, 'index.jux'))) {
-    fs.writeFileSync(path.join(juxDir, 'index.jux'), `import { Element } from 'juxscript';\nElement('welcome', { tag: 'h1' }).text('Welcome to JUX!').render('app');\n`);
+
+  if (fs.existsSync(templateDir)) {
+    copyDirRecursive(templateDir, juxDir);
+    console.log('   ✓ Copied template files to ./jux');
+  } else {
+    fs.writeFileSync(
+      path.join(juxDir, 'index.jux'),
+      `import { Element } from 'juxscript';\n\nElement('welcome', { tagName: 'h1' })\n    .text('Welcome to JUX!')\n    .render('app');\n`
+    );
+    console.log('   ✓ Created starter file');
   }
-  const configSrc = path.join(packageRoot, 'juxconfig.example.js');
+
+  // 2. Copy config if not exists
   const configDest = path.join(targetDir, 'juxconfig.js');
-  if (fs.existsSync(configSrc) && !fs.existsSync(configDest)) fs.copyFileSync(configSrc, configDest);
-  const gitIgnore = path.join(targetDir, '.gitignore');
-  if (!fs.existsSync(gitIgnore)) fs.writeFileSync(gitIgnore, `.jux-dist/\nnode_modules/\n.DS_Store\n.env\n*.log\n`);
+  if (!fs.existsSync(configDest)) {
+    const configSrc = path.join(PACKAGE_ROOT, 'juxconfig.example.js');
+    if (fs.existsSync(configSrc)) {
+      fs.copyFileSync(configSrc, configDest);
+      console.log('   ✓ Created juxconfig.js');
+    }
+  }
+
+  // 3. Update package.json scripts if exists
   const pkgPath = path.join(targetDir, 'package.json');
   if (fs.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
       pkg.scripts = pkg.scripts || {};
       let modified = false;
-      if (!pkg.scripts.dev) { pkg.scripts.dev = 'jux serve'; modified = true; }
+
+      if (!pkg.scripts.dev) { pkg.scripts.dev = 'jux serve --hot'; modified = true; }
       if (!pkg.scripts.build) { pkg.scripts.build = 'jux build'; modified = true; }
-      if (modified) fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
-    } catch (e) { }
+      if (!pkg.scripts.start) { pkg.scripts.start = 'jux serve'; modified = true; }
+
+      if (modified) {
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+        console.log('   ✓ Updated package.json scripts');
+      }
+    } catch (e) {
+      console.warn('   ⚠️  Could not update package.json');
+    }
   }
+
+  console.log('\n✅ Initialized. Run: npm run dev\n');
 }
 
-if (command === 'create') {
-  const projectName = process.argv[3] || 'my-jux-app';
-  const projectPath = path.join(process.cwd(), projectName);
-  if (fs.existsSync(projectPath)) { console.error(`❌ Directory "${projectName}" already exists.`); process.exit(1); }
-  try {
-    const { execSync } = await import('child_process');
-    fs.mkdirSync(projectPath, { recursive: true });
-    process.chdir(projectPath);
-    const pkg = { name: projectName, version: '0.1.0', type: 'module', scripts: { dev: 'jux serve', build: 'jux build' }, dependencies: { juxscript: 'latest' } };
-    fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
-    const packageRoot = path.resolve(__dirname, '..');
-    scaffoldProject(projectPath, packageRoot);
-    try { execSync('npm install', { stdio: 'inherit' }); } catch (err) { }
-    console.log(`\n✅ Project created! Run: cd ${projectName} && npm run dev\n`);
-  } catch (err) { console.error(`\n❌ Failed:`, err.message); process.exit(1); }
-  process.exit(0);
+// ═══════════════════════════════════════════════════════════════
+// COMMAND: build
+// Delegates to machinery/build3.js
+// ═══════════════════════════════════════════════════════════════
+function runBuild() {
+  const buildScript = path.join(PACKAGE_ROOT, 'machinery', 'build3.js');
+
+  if (!fs.existsSync(buildScript)) {
+    console.error('❌ Build script not found:', buildScript);
+    process.exit(1);
+  }
+
+  const child = spawn('node', [buildScript, ...args], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: process.env
+  });
+
+  child.on('close', (code) => process.exit(code || 0));
 }
 
-import { copyLibToOutput, copyProjectAssets, transpileProjectTypeScript, copyPresetsToOutput, bundleJuxFilesToRouter, generateIndexHtml } from '../machinery/compiler.js';
-import { verifyStaticBuild } from '../machinery/verifier.js';
-import { resolveConfig } from '../machinery/config.js';
-import { start } from '../machinery/server.js';
+// ═══════════════════════════════════════════════════════════════
+// COMMAND: serve [--hot]
+// Delegates to machinery/serve.js
+// ═══════════════════════════════════════════════════════════════
+function runServe() {
+  const serveScript = path.join(PACKAGE_ROOT, 'machinery', 'serve.js');
+
+  if (!fs.existsSync(serveScript)) {
+    console.error('❌ Serve script not found:', serveScript);
+    process.exit(1);
+  }
+
+  // Pass through all args (including --hot)
+  const child = spawn('node', [serveScript, ...args], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: process.env
+  });
 
-async function loadUserConfig(projectRoot) {
-  const configPath = path.join(projectRoot, 'juxconfig.js');
-  let rawConfig = {};
-  if (fs.existsSync(configPath)) { try { const module = await import(configPath); rawConfig = module.default || module.config || {}; } catch (err) { } }
-  return resolveConfig(rawConfig, projectRoot);
+  child.on('close', (code) => process.exit(code || 0));
 }
 
-(async () => {
-  const projectRoot = process.cwd();
-  const config = await loadUserConfig(projectRoot);
-  const PATHS = {
-    packageRoot: path.resolve(__dirname, '..'),
-    projectRoot: projectRoot,
-    get juxSource() { return path.join(this.projectRoot, config.directories?.source || 'jux'); },
-    get juxLib() { return path.resolve(this.packageRoot, 'lib'); },
-    get frontendDist() { return path.join(this.projectRoot, config.directories?.distribution || '.jux-dist'); }
-  };
+// ═══════════════════════════════════════════════════════════════
+// UTILITIES
+// ═══════════════════════════════════════════════════════════════
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
 
-  async function buildProject(isServe = false, wsPort = 3001) {
-    if (!fs.existsSync(PATHS.juxSource)) { console.error(`❌ Source not found: ${PATHS.juxSource}`); process.exit(1); }
-    if (fs.existsSync(PATHS.frontendDist)) fs.rmSync(PATHS.frontendDist, { recursive: true, force: true });
-    fs.mkdirSync(PATHS.frontendDist, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name.startsWith('.')) continue; // Skip hidden files
 
-    // ✅ Clean Log
-    process.stdout.write('🔨 Building JUX... ');
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
 
-    try {
-      await copyLibToOutput(PATHS.juxLib, PATHS.frontendDist);
-      await copyPresetsToOutput(PATHS.packageRoot, PATHS.frontendDist);
-      await copyProjectAssets(PATHS.juxSource, PATHS.frontendDist);
-      await transpileProjectTypeScript(PATHS.juxSource, PATHS.frontendDist);
-      const bundleResult = await bundleJuxFilesToRouter(PATHS.juxSource, PATHS.frontendDist, { routePrefix: '', config });
-      generateIndexHtml(PATHS.frontendDist, bundleResult, { isDev: isServe, wsPort: isServe ? wsPort : undefined });
-      if (!verifyStaticBuild(PATHS.frontendDist)) { console.error('🛑 Critical Build Failure.'); process.exit(1); }
-
-      const fileCount = fs.readdirSync(PATHS.juxSource).filter(f => f.endsWith('.jux')).length; // Approximate check
-      console.log(`✅ Done. (${fileCount} files, ${(fs.statSync(path.join(PATHS.frontendDist, 'main.js')).size / 1024).toFixed(1)}KB)`);
-    } catch (err) {
-      console.log('❌ Failed.');
-      console.error(err.message);
-      process.exit(1);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
     }
   }
+}
 
-  if (command === 'init' || command === 'install') {
-    scaffoldProject(PATHS.projectRoot, PATHS.packageRoot);
-    console.log('✅ Initialized. Next: npm run dev');
-  } else if (command === 'build') {
-    await buildProject(false);
-  } else if (command === 'serve') {
-    const httpPort = parseInt(process.argv[3]) || config.defaults?.httpPort || 3000;
-    const wsPort = parseInt(process.argv[4]) || config.defaults?.wsPort || 3001;
-    await buildProject(true, wsPort);
-    await start(httpPort, wsPort, PATHS.frontendDist, config);
-  } else {
-    console.log(`Usage: npx jux [create|init|build|serve]`);
-  }
-})();
+function showHelp() {
+  console.log(`
+JUX CLI
+
+Usage:
+  jux create <name>    Create a new JUX project
+  jux init             Initialize JUX in current directory
+  jux build            Build for production
+  jux serve            Start production server
+  jux serve --hot      Start dev server with hot reload
+
+Options:
+  --help, -h           Show this help message
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════
+// MAIN ROUTER
+// ═══════════════════════════════════════════════════════════════
+switch (command) {
+  case 'create':
+    createProject(args[0]);
+    break;
+
+  case 'init':
+  case 'install':
+    initProject();
+    break;
+
+  case 'build':
+    runBuild();
+    break;
+
+  case 'serve':
+  case 'dev':
+    runServe();
+    break;
+
+  case '--help':
+  case '-h':
+  case undefined:
+    showHelp();
+    break;
+
+  default:
+    console.error(`❌ Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}

package/index.js

@@ -0,0 +1,22 @@
+/**
+ * JUX - JavaScript UX Authorship Platform
+ * 
+ * Main entry point for the juxscript package.
+ * Re-exports all public components and utilities.
+ */
+
+// Core Components
+export { Element } from './lib/componentsv2/element/component.js';
+export { Grid } from './lib/componentsv2/grid/component.js';
+export { Input } from './lib/componentsv2/input/component.js';
+export { List } from './lib/componentsv2/list/component.js';
+
+// Base Classes (for extension)
+// Note: BaseState is a TypeScript interface, not exported at runtime
+export { BaseEngine } from './lib/componentsv2/base/BaseEngine.js';
+export { BaseSkin } from './lib/componentsv2/base/BaseSkin.js';
+export { State } from './lib/componentsv2/base/State.js';
+export { GlobalBus } from './lib/componentsv2/base/GlobalBus.js';
+
+// Utilities
+export { validateOptions } from './lib/componentsv2/base/OptionsContract.js';

package/lib/globals.d.ts

@@ -1,5 +1,7 @@
-// CSS Module Support
-declare module '*.css' {
-  const content: string;
-  export default content;
-}
+/**
+ * JUX Type Exports
+ * Re-export types for TypeScript consumers
+ */
+export type { BaseState } from './componentsv2/base/BaseEngine.js';
+export type { JuxServiceContract } from './componentsv2/base/BaseEngine.js';
+export type { OptionsContractSchema, OptionDefinition, ValidationResult } from './componentsv2/base/OptionsContract.js';

package/machinery/build3.js

@@ -0,0 +1,21 @@
+import { JuxCompiler } from './compiler3.js';
+import path from 'path';
+
+// Resolve paths relative to CWD (user's project)
+const PROJECT_ROOT = process.cwd();
+
+const compiler = new JuxCompiler({
+    srcDir: path.resolve(PROJECT_ROOT, 'jux'),
+    distDir: path.resolve(PROJECT_ROOT, '.jux-dist')
+});
+
+compiler.build()
+    .then(result => {
+        if (!result.success) {
+            process.exit(1);
+        }
+    })
+    .catch(err => {
+        console.error('❌ Build failed:', err.message);
+        process.exit(1);
+    });