juxscript 1.0.89 → 1.0.90

package/machinery/diagnose.js

@@ -1,72 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import { bundleJuxFilesToRouter, generateIndexHtml } from './compiler.js';
-import { verifyStaticBuild } from './verifier.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const FIXTURES_DIR = path.join(__dirname, 'fixtures');
-const DIST_DIR = path.join(__dirname, '.temp_dist_test');
-
-// Setup temp dir
-if (!fs.existsSync(DIST_DIR)) fs.mkdirSync(DIST_DIR);
-
-async function runTest(fileName, description) {
-    console.log(`\n🧪 TEST: ${description} (${fileName})`);
-    console.log('   Context: Trying to build a broken file...');
-
-    const srcFile = path.join(FIXTURES_DIR, fileName);
-
-    // Mock finding files by explicitly passing our bad file as the "source"
-    // Since bundleJuxFilesToRouter takes a directory, we need to create a temp source dir
-    const tempSrcDir = path.join(__dirname, '.temp_src_' + Date.now());
-    fs.mkdirSync(tempSrcDir);
-    fs.copyFileSync(srcFile, path.join(tempSrcDir, 'index.jux'));
-
-    let buildSuccess = false;
-
-    try {
-        // 1. Attempt Bundle
-        const result = await bundleJuxFilesToRouter(tempSrcDir, DIST_DIR, { routePrefix: '' });
-
-        // 2. Generate HTML (needed for verifier to check import map)
-        generateIndexHtml(DIST_DIR, result);
-
-        // 3. Run Verifier
-        const verified = verifyStaticBuild(DIST_DIR);
-
-        if (!verified) {
-            console.log('   ✅ SUCCESS: Verifier correctly caught the error!');
-            buildSuccess = false;
-        } else {
-            console.log('   ❌ FAILURE: Build passed but should have failed verification.');
-            buildSuccess = true;
-        }
-
-    } catch (e) {
-        console.log(`   ✅ SUCCESS: Compiler threw error as expected:`);
-        console.log(`      "${e.message.split('\n')[0]}"`);
-        buildSuccess = false;
-    } finally {
-        // Cleanup
-        fs.rmSync(tempSrcDir, { recursive: true, force: true });
-    }
-
-    return !buildSuccess;
-}
-
-async function main() {
-    console.log('🩺 JUX FAILURE DIAGNOSTICS\n');
-
-    // Test 1: bad_syntax.jux (Should throw during compile)
-    await runTest('bad_syntax.jux', 'Syntax Error Detection');
-
-    // Test 2: ghost_dep.jux (Should pass compile, fail verification)
-    await runTest('ghost_dep.jux', 'Ghost Dependency Detection');
-
-    // Cleanup Dist
-    fs.rmSync(DIST_DIR, { recursive: true, force: true });
-    console.log('\n🏁 Diagnostics Complete');
-}
-
-main();

package/machinery/doc-generator.js

@@ -1,136 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { glob } from 'glob';
-
-/**
- * Generate documentation from TypeScript component files
- * 
- * @param {string} juxLibPath - Absolute path to jux/lib directory
- */
-export async function generateDocs(juxLibPath) {
-  const componentsDir = path.join(juxLibPath, 'components');
-  
-  if (!fs.existsSync(componentsDir)) {
-    throw new Error(`Components directory not found: ${componentsDir}`);
-  }
-  
-  console.log(`  Scanning: ${componentsDir}`);
-  
-  // Find all component TypeScript files
-  const componentFiles = glob.sync('*.ts', {
-    cwd: componentsDir,
-    absolute: true,
-    ignore: ['reactivity.ts', 'error-handler.ts']
-  });
-
-  console.log(`  Found ${componentFiles.length} component files`);
-
-  const components = [];
-
-  for (const filePath of componentFiles) {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const componentDoc = parseComponentFile(content, filePath);
-    
-    if (componentDoc) {
-      components.push(componentDoc);
-      console.log(`    ✓ ${componentDoc.name}`);
-    }
-  }
-
-  // Sort by category and name
-  components.sort((a, b) => {
-    const categoryCompare = (a.category || 'ZZZ').localeCompare(b.category || 'ZZZ');
-    if (categoryCompare !== 0) return categoryCompare;
-    return a.name.localeCompare(b.name);
-  });
-
-  // Generate the docs data
-  const docsData = {
-    components,
-    version: '1.0.0',
-    lastUpdated: new Date().toISOString()
-  };
-
-  // Write to JSON file
-  const outputPath = path.join(componentsDir, 'docs-data.json');
-  fs.writeFileSync(outputPath, JSON.stringify(docsData, null, 2));
-  
-  console.log(`  Generated: ${outputPath}`);
-  
-  return docsData;
-}
-
-/**
- * Parse a single component file
- */
-function parseComponentFile(content, filePath) {
-  const fileName = path.basename(filePath, '.ts');
-  const className = fileName.charAt(0).toUpperCase() + fileName.slice(1);
-  
-  const category = inferCategory(className, content);
-  const descMatch = content.match(/\/\*\*\s*\n\s*\*\s*([^\n*]+)/);
-  const description = descMatch ? descMatch[1].trim() : `${className} component`;
-  const factoryMatch = content.match(/export function\s+\w+\(([^)]*)\)/);
-  const constructorSig = factoryMatch 
-    ? `jux.${fileName}(${factoryMatch[1]})`
-    : `new ${className}()`;
-  const fluentMethods = extractFluentMethods(content, className);
-  const exampleMatch = content.match(/\*\s+Usage:\s*\n\s*\*\s+(.+?)(?:\n|$)/);
-  let example = exampleMatch 
-    ? exampleMatch[1].trim()
-    : `jux.${fileName}('id').render()`;
-  
-  return {
-    name: className,
-    category,
-    description,
-    constructor: constructorSig,
-    fluentMethods,
-    example
-  };
-}
-
-/**
- * Extract fluent API methods from class
- */
-function extractFluentMethods(content, className) {
-  const methods = [];
-  const methodRegex = /^\s*(\w+)\(([^)]*)\):\s*this\s*\{/gm;
-  let match;
-  
-  while ((match = methodRegex.exec(content)) !== null) {
-    const methodName = match[1];
-    const params = match[2];
-    if (methodName.startsWith('_') || methodName === 'constructor') continue;
-    const cleanParams = params.split(',').map(p => p.trim().split(':')[0].trim()).filter(p => p).join(', ');
-    methods.push({
-      name: methodName,
-      params: cleanParams ? `(${cleanParams})` : '()',
-      returns: 'this',
-      description: `Set ${methodName}`
-    });
-  }
-  
-  const renderMatch = content.match(/^\s*render\(([^)]*)\):\s*(\w+)/m);
-  if (renderMatch && !methods.find(m => m.name === 'render')) {
-    methods.push({
-      name: 'render',
-      params: renderMatch[1] ? `(${renderMatch[1]})` : '()',
-      returns: renderMatch[2],
-      description: 'Render component to DOM'
-    });
-  }
-  
-  return methods;
-}
-
-/**
- * Infer category from component name or content
- */
-function inferCategory(name, content) {
-  const dataComponents = ['Table', 'List', 'Chart', 'Data'];
-  const coreComponents = ['App', 'Layout', 'Theme', 'Style', 'Script', 'Import'];
-  if (dataComponents.some(dc => name.includes(dc))) return 'Data Components';
-  if (coreComponents.includes(name)) return 'Core';
-  return 'UI Components';
-}

package/machinery/imports.js

@@ -1,155 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const REGISTRY_PATH = path.join(__dirname, '../lib/registry/packages.json');
-
-/**
- * Load package registry
- */
-function loadRegistry() {
-  if (!fs.existsSync(REGISTRY_PATH)) {
-    return {};
-  }
-  return JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf-8'));
-}
-
-/**
- * Parse @import directives from Jux code
- */
-export function parseImports(juxCode) {
-  const imports = [];
-  const lines = juxCode.split('\n');
-  
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    
-    // Stop parsing when we hit actual code (non-directive, non-comment)
-    if (line && !line.startsWith('@') && !line.startsWith('//') && !line.startsWith('/*')) {
-      break;
-    }
-    
-    // Match @import directive
-    const importMatch = line.match(/^@import\s+(.+)$/);
-    if (importMatch) {
-      const importSpec = importMatch[1].trim();
-      imports.push({
-        line: i + 1,
-        raw: importSpec,
-        resolved: resolveImport(importSpec)
-      });
-      
-      if (process.env.JUX_VERBOSE) {
-        console.log(`  [Line ${i + 1}] Found @import: ${importSpec}`);
-      }
-    }
-  }
-  
-  return imports;
-}
-
-/**
- * Resolve import specification to URL/path
- */
-export function resolveImport(importSpec) {
-  // Remove quotes if present
-  const cleaned = importSpec.replace(/^['"]|['"]$/g, '');
-  
-  // Direct URL (starts with http:// or https://)
-  if (cleaned.startsWith('http://') || cleaned.startsWith('https://')) {
-    return {
-      type: 'cdn',
-      url: cleaned,
-      source: 'direct'
-    };
-  }
-  
-  // Local file (starts with ./ or ../ or /)
-  if (cleaned.startsWith('./') || cleaned.startsWith('../') || cleaned.startsWith('/')) {
-    return {
-      type: 'local',
-      path: cleaned,
-      source: 'file'
-    };
-  }
-  
-  // Unknown/unsupported
-  return {
-    type: 'unknown',
-    name: cleaned,
-    error: `Import "${cleaned}" must be a URL (https://...) or relative path (./...)`
-  };
-}
-
-/**
- * Auto-detect component dependencies
- */
-function detectComponentDependencies(usedComponents) {
-  const componentDeps = {
-    'chart': 'chart.js'
-    // Add more mappings as needed
-  };
-  
-  const deps = new Set();
-  
-  usedComponents.forEach(comp => {
-    if (componentDeps[comp]) {
-      deps.add(componentDeps[comp]);
-    }
-  });
-  
-  return Array.from(deps).map(pkg => ({
-    auto: true,
-    resolved: resolveImport(pkg)
-  }));
-}
-
-/**
- * Generate HTML script tags from resolved imports
- */
-export function generateImportTags(imports) {
-  const tags = [];
-  const seen = new Set();
-  
-  for (const imp of imports) {
-    const resolved = imp.resolved;
-    
-    if (resolved.type === 'unknown') {
-      tags.push(`<!-- ERROR: ${resolved.error} -->`);
-      continue;
-    }
-    
-    const key = resolved.url || resolved.path;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    
-    if (resolved.type === 'cdn') {
-      tags.push(`  <script src="${resolved.url}"></script>`);
-    } else if (resolved.type === 'local') {
-      tags.push(`  <script type="module" src="${resolved.path}"></script>`);
-    }
-  }
-  
-  return tags.join('\n');
-}
-
-/**
- * Validate all imports are resolvable
- */
-export function validateImports(imports) {
-  const errors = [];
-  
-  imports.forEach(imp => {
-    if (imp.resolved.type === 'unknown') {
-      errors.push({
-        line: imp.line,
-        message: imp.resolved.error,
-        raw: imp.raw
-      });
-    }
-  });
-  
-  return errors;
-}

package/machinery/jux-module-pattern.md

@@ -1,118 +0,0 @@
-# JUX Module Pattern
-
-## Overview
-A `.jux` file can export a component-like interface with:
-- Configuration options
-- Public API methods
-- Event emissions (EDR pattern)
-- Internal/shared state
-- Props (getters)
-
-## Pattern Structure
-
-```javascript
-// calendar.jux
-import { jux, state } from 'juxscript';
-
-// ═══════════════════════════════════════════════════════════════════
-// MODULE DEFINITION
-// ═══════════════════════════════════════════════════════════════════
-
-export default function Calendar(id, options = {}) {
-    // Internal state
-    const today = new Date();
-    const currentMonth = state(options.initialMonth ?? today.getMonth());
-    const currentYear = state(options.initialYear ?? today.getFullYear());
-    const selectedDate = state(null);
-    
-    // Event emitters (EDR pattern)
-    const events = {
-        dateSelect: [],
-        monthChange: [],
-        yearChange: []
-    };
-    
-    // Emit helper
-    const emit = (eventName, data) => {
-        events[eventName]?.forEach(handler => handler(data));
-    };
-    
-    // Public API
-    const api = {
-        // Props (getters)
-        get currentMonth() { return currentMonth.value; },
-        get currentYear() { return currentYear.value; },
-        get selectedDate() { return selectedDate.value; },
-        
-        // Methods
-        nextMonth() {
-            let month = currentMonth.value + 1;
-            let year = currentYear.value;
-            if (month > 11) { month = 0; year++; }
-            currentMonth.set(month);
-            currentYear.set(year);
-            emit('monthChange', { month, year });
-            return api;
-        },
-        
-        prevMonth() {
-            let month = currentMonth.value - 1;
-            let year = currentYear.value;
-            if (month < 0) { month = 11; year--; }
-            currentMonth.set(month);
-            currentYear.set(year);
-            emit('monthChange', { month, year });
-            return api;
-        },
-        
-        selectDate(date) {
-            selectedDate.set(date);
-            emit('dateSelect', { date });
-            return api;
-        },
-        
-        // Event binding (EDR consumer registration)
-        on(eventName, handler) {
-            if (events[eventName]) {
-                events[eventName].push(handler);
-            }
-            return api;
-        },
-        
-        // Render
-        render(targetId) {
-            // Build UI components...
-            return api;
-        },
-        
-        // Expose for chaining
-        id
-    };
-    
-    return api;
-}
-```
-
-## Usage
-
-```javascript
-// app.jux
-import Calendar from './calendar.jux';
-
-const cal = Calendar('my-calendar', {
-    initialMonth: 11,
-    initialYear: 2024
-})
-.on('dateSelect', ({ date }) => {
-    console.log('Date selected:', date);
-})
-.on('monthChange', ({ month, year }) => {
-    console.log('Month changed:', month, year);
-})
-.render('#app');
-
-// Public API
-cal.nextMonth();
-cal.prevMonth();
-console.log(cal.currentMonth); // getter
-```

package/machinery/server.js

@@ -1,86 +0,0 @@
-import express from 'express';
-import http from 'http';
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import { startWatcher } from './watcher.js';
-import { verifyRuntime } from './verifier.js';
-import { WebSocketServer } from 'ws';
-
-const __filename = fileURLToPath(import.meta.url);
-
-/**
- * Try to start a server on a port, with fallback to next port if busy
- * Returns the actual port that was successfully allocated
- */
-async function tryPort(startPort, maxAttempts = 5, reservedPorts = []) {
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const port = startPort + attempt;
-    if (reservedPorts.includes(port)) continue;
-    try {
-      await new Promise((resolve, reject) => {
-        const testServer = http.createServer();
-        testServer.once('error', reject);
-        testServer.once('listening', () => { testServer.close(); resolve(port); });
-        testServer.listen(port);
-      });
-      return port;
-    } catch (err) { if (err.code !== 'EADDRINUSE') throw err; }
-  }
-  throw new Error(`Could not find available port`);
-}
-
-async function serve(httpPort = 3000, wsPort = 3001, distDir = './.jux-dist', config = {}) {
-  const app = express();
-  const absoluteDistDir = path.resolve(distDir);
-  const projectRoot = path.resolve('.');
-
-  app.use(express.json());
-  if (!fs.existsSync(absoluteDistDir)) { process.exit(1); }
-
-  app.use((req, res, next) => {
-    res.setHeader('Cache-Control', 'no-store');
-    if (req.path.endsWith('.js')) res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
-    next();
-  });
-  app.get('/favicon.ico', (req, res) => res.status(204).end());
-  app.use(express.static(absoluteDistDir));
-  app.use((req, res) => {
-    if (/\.[a-zA-Z0-9]+$/.test(req.path)) return res.status(404).send('Not found');
-    if (req.accepts('html')) res.sendFile(path.join(absoluteDistDir, 'index.html'));
-    else res.status(404).send('Not found');
-  });
-
-  const availableHttpPort = await tryPort(httpPort);
-  const availableWsPort = await tryPort(wsPort, 5, [availableHttpPort]);
-  const server = http.createServer(app);
-  const wss = new WebSocketServer({ port: availableWsPort });
-  const clients = [];
-
-  wss.on('connection', (ws) => {
-    clients.push(ws);
-    ws.on('close', () => { const i = clients.indexOf(ws); if (i > -1) clients.splice(i, 1); });
-  });
-
-  server.listen(availableHttpPort, async () => {
-    console.log(`🚀 Server: http://localhost:${availableHttpPort}`);
-    const isHealthy = await verifyRuntime(availableHttpPort);
-    if (!isHealthy) { console.error('🛑 Runtime Check Failed.'); process.exit(1); }
-  });
-
-  const sourceName = config?.directories?.source || 'jux';
-  const juxSource = path.join(projectRoot, sourceName);
-  if (fs.existsSync(juxSource)) {
-    startWatcher(juxSource, absoluteDistDir, clients, config, availableWsPort);
-  }
-
-  const shutdown = async () => { wss.close(); server.close(); process.exit(0); };
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-
-  return { server, httpPort: availableHttpPort, wsPort: availableWsPort };
-}
-
-export async function start(httpPort = 3000, wsPort = 3001, distDir = './.jux-dist', config = {}) {
-  return serve(httpPort, wsPort, distDir, config);
-}

package/machinery/ts-shim.js

@@ -1,46 +0,0 @@
-import esbuild from 'esbuild';
-
-/**
- * TypeScript Shim - Strips type annotations using esbuild
- * This is rock-solid and handles ALL TypeScript syntax correctly
- */
-
-/**
- * Strip TypeScript type annotations from code using esbuild
- * 
- * @param {string} code - TypeScript source code
- * @returns {string} - JavaScript code with types removed
- */
-export function stripTypes(code) {
-    try {
-        // ✅ Use esbuild to transform TypeScript → JavaScript
-        const result = esbuild.transformSync(code, {
-            loader: 'ts',
-            format: 'esm',
-            target: 'es2020'
-        });
-
-        return result.code;
-    } catch (err) {
-        console.error('❌ Failed to strip TypeScript:', err.message);
-        // Return original code if transformation fails
-        return code;
-    }
-}
-
-/**
- * Check if a file is TypeScript based on extension
- */
-export function isTypeScript(filePath) {
-    return filePath.endsWith('.ts') || filePath.endsWith('.tsx');
-}
-
-/**
- * Load and parse a file, automatically stripping types if it's TypeScript
- */
-export function loadAndStripTypes(filePath, fileContent) {
-    if (isTypeScript(filePath)) {
-        return stripTypes(fileContent);
-    }
-    return fileContent;
-}