juxscript 1.1.3 → 1.1.4

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/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;
-}

package/machinery/validators/file-validator.js

@@ -1,123 +0,0 @@
-/**
- * File validation utilities for Jux compiler
- * Validates file types and content security
- */
-export class FileValidator {
-  constructor() {
-    this.cssExtensions = /\.(css|scss|sass|less)$/i;
-    this.jsExtensions = /\.(js|mjs|ts|tsx|jsx)$/i;
-    this.imageExtensions = /\.(png|jpg|jpeg|gif|svg|webp|ico|bmp)$/i;
-  }
-
-  /**
-   * Check if file is a CSS file
-   */
-  isCSSFile(filepath) {
-    return this.cssExtensions.test(filepath);
-  }
-
-  /**
-   * Check if file is a JavaScript file
-   */
-  isJavaScriptFile(filepath) {
-    return this.jsExtensions.test(filepath);
-  }
-
-  /**
-   * Check if file is an image file
-   */
-  isImageFile(filepath) {
-    return this.imageExtensions.test(filepath);
-  }
-
-  /**
-   * Validate CSS content for security issues
-   * Detects <script> tags that could be injected
-   */
-  validateStyleContent(content, source = 'unknown') {
-    if (/<script/i.test(content)) {
-      throw new Error(
-        `🚨 Security Error: <script> tag detected in ${source}\n` +
-        `CSS content must not contain script tags.`
-      );
-    }
-    
-    if (/<\/script/i.test(content)) {
-      throw new Error(
-        `🚨 Security Error: </script> tag detected in ${source}\n` +
-        `CSS content must not contain script tags.`
-      );
-    }
-    
-    return content;
-  }
-
-  /**
-   * Determine import type based on file extension
-   * Returns: 'css' | 'js' | 'image' | 'unknown'
-   */
-  validateImportPath(importPath) {
-    // Handle URLs
-    if (importPath.startsWith('http://') || importPath.startsWith('https://')) {
-      // Try to infer from URL
-      if (this.isCSSFile(importPath)) return { type: 'css', path: importPath };
-      if (this.isJavaScriptFile(importPath)) return { type: 'js', path: importPath };
-      if (this.isImageFile(importPath)) return { type: 'image', path: importPath };
-      
-      // Default to unknown for CDN URLs without clear extensions
-      return { type: 'unknown', path: importPath };
-    }
-
-    // Local files
-    if (this.isCSSFile(importPath)) {
-      return { type: 'css', path: importPath };
-    }
-    
-    if (this.isJavaScriptFile(importPath)) {
-      return { type: 'js', path: importPath };
-    }
-    
-    if (this.isImageFile(importPath)) {
-      return { type: 'image', path: importPath };
-    }
-
-    return { type: 'unknown', path: importPath };
-  }
-
-  /**
-   * Validate array of imports and categorize them
-   * Returns categorized imports with warnings
-   */
-  categorizeImports(imports) {
-    const categorized = {
-      css: [],
-      js: [],
-      images: [],
-      unknown: []
-    };
-
-    const warnings = [];
-
-    for (const importPath of imports) {
-      const result = this.validateImportPath(importPath);
-      
-      if (result.type === 'unknown') {
-        warnings.push(
-          `⚠️  Unknown import type: ${importPath}\n` +
-          `   Supported: .css/.scss/.sass, .js/.ts, .png/.jpg/.svg`
-        );
-      }
-      
-      categorized[result.type === 'unknown' ? 'unknown' : result.type].push(result.path);
-    }
-
-    return { categorized, warnings };
-  }
-
-  /**
-   * Check if inline style content is empty or whitespace-only
-   */
-  isEmptyStyle(styleContent) {
-    return !styleContent || styleContent.trim().length === 0;
-  }
-}