juxscript 1.1.4 → 1.1.6

package/machinery/doc-generator.js

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,155 @@
+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/ts-shim.js

@@ -0,0 +1,46 @@
+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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juxscript",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "type": "module",
   "description": "A JavaScript UX authorship platform",
   "main": "index.js",
@@ -21,23 +21,16 @@
   "files": [
     "index.js",
     "index.d.ts",
+    "index.d.ts.map",
     "bin",
-    "create/*.jux",
-    "lib/**/*.js",
-    "lib/**/*.d.ts",
-    "machinery/build3.js",
-    "machinery/compiler3.js",
-    "machinery/config.js",
-    "machinery/serve.js",
-    "machinery/watcher.js",
+    "create",
+    "lib",
+    "machinery",
+    "reactivity",
     "types",
     "juxconfig.example.js",
     "README.md",
-    "LICENSE",
-    "!lib/**/*.test.js",
-    "!lib/**/*.spec.js",
-    "!lib/previews/**",
-    "!**/*.map"
+    "LICENSE"
   ],
   "bin": {
     "jux": "./bin/cli.js"
@@ -53,7 +46,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postpublish": "echo '✅ Published successfully. Verify with: npm info juxscript'"
   },
   "dependencies": {
     "acorn": "^8.15.0",