@viji-dev/sdk 1.0.0

package/src/cli/utils/scene-compiler.js

@@ -0,0 +1,432 @@
+/**
+ * Scene Compiler - Advanced compilation and bundling for Viji scenes
+ */
+
+import { readFile, writeFile, readdir, stat } from 'fs/promises';
+import { join, dirname, extname, relative, resolve } from 'path';
+import { existsSync } from 'fs';
+
+export class SceneCompiler {
+  constructor(options = {}) {
+    this.options = {
+      minify: false,        // forced off by CLI contract
+      sourceMap: false,     // optional, not used now
+      inlineAssets: false,  // keep simple, no inlining
+      validateScene: false, // minimal validation
+      ...options
+    };
+    this.dependencies = new Map();
+    this.assets = new Map();
+    this.warnings = [];
+    this.errors = [];
+  }
+
+  /**
+   * Compile a project folder-based scene
+   * @param {string} projectPath - Path to the project folder
+   * @param {Object} buildOptions - Build configuration options
+   */
+  async compileProject(projectPath) {
+    console.log('🔄 Starting project compilation (simple bundle)...');
+    const startTime = Date.now();
+
+    try {
+      // Find main scene file (main.js or main.ts)
+      const mainFile = await this.findMainFile(projectPath);
+      if (!mainFile) {
+        throw new Error('No main.js or main.ts file found in project');
+      }
+
+      // Create dist directory
+      const distPath = join(projectPath, 'dist');
+      await this.ensureDirectory(distPath);
+
+      // Set output file path
+      const outputFile = join(distPath, 'scene.js');
+
+      // Read and analyze main scene file
+      const sceneCode = await readFile(mainFile, 'utf8');
+      const analysis = await this.analyzeScene(sceneCode, mainFile);
+      
+      if (this.errors.length > 0) {
+        throw new Error(`Compilation failed: ${this.errors.join(', ')}`);
+      }
+
+      // Bundle local dependencies (very simple: concatenate in order)
+      const bundle = await this.createBundle(sceneCode, analysis, projectPath);
+      const output = await this.generateOutput(bundle, analysis);
+      await writeFile(outputFile, output, 'utf8');
+      
+      // Create metadata
+      const metadata = this.generateMetadata(analysis, {
+        compilationTime: Date.now() - startTime,
+        outputSize: output.length,
+        sourceFile: mainFile,
+        outputFile,
+        projectPath
+      });
+
+      // Write metadata file
+      await writeFile(join(distPath, 'scene.json'), JSON.stringify(metadata, null, 2), 'utf8');
+
+      console.log(`✅ Project compiled successfully: ${outputFile}`);
+      
+      return {
+        success: true,
+        outputFile,
+        metadata,
+        warnings: this.warnings
+      };
+
+    } catch (error) {
+      console.error('💥 Compilation failed:', error.message);
+      return {
+        success: false,
+        error: error.message,
+        warnings: this.warnings,
+        errors: this.errors
+      };
+    }
+  }
+
+  /**
+   * Legacy compile method for backward compatibility
+   */
+  async compile(sceneFile, outputFile) {
+    console.log('🔄 Starting scene compilation...');
+    const startTime = Date.now();
+
+    try {
+      // Read and analyze main scene file
+      const sceneCode = await readFile(sceneFile, 'utf8');
+      const analysis = await this.analyzeScene(sceneCode, sceneFile);
+      
+      if (this.errors.length > 0) {
+        throw new Error(`Compilation failed: ${this.errors.join(', ')}`);
+      }
+
+      const bundle = await this.createBundle(sceneCode, analysis, dirname(sceneFile));
+      const output = await this.generateOutput(bundle, analysis);
+      
+      // Create metadata
+      const metadata = this.generateMetadata(analysis, {
+        compilationTime: Date.now() - startTime,
+        outputSize: output.length,
+        sourceFile: sceneFile,
+        outputFile
+      });
+
+      return {
+        code: output,
+        metadata,
+        warnings: this.warnings,
+        sourceMap: this.options.sourceMap ? this.generateSourceMap(bundle) : null
+      };
+
+    } catch (error) {
+      console.error('💥 Compilation failed:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Find the main scene file (main.js or main.ts) in a project directory
+   */
+  async findMainFile(projectPath) {
+    const possibleFiles = ['main.ts', 'main.js', 'main.tsx', 'main.jsx'];
+    
+    for (const filename of possibleFiles) {
+      const filepath = join(projectPath, filename);
+      if (existsSync(filepath)) {
+        return filepath;
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Ensure a directory exists, create it if it doesn't
+   */
+  async ensureDirectory(dirPath) {
+    try {
+      // In browser environment, this would need to be simulated
+      // For now, we'll use a simple check
+      if (!existsSync(dirPath)) {
+        // In a real implementation: await mkdir(dirPath, { recursive: true });
+        console.log(`📁 Directory would be created: ${dirPath}`);
+      }
+    } catch (error) {
+      console.warn(`Could not create directory: ${dirPath}`, error);
+    }
+  }
+
+  async analyzeScene(code, filePath) {
+    const analysis = {
+      parameters: [],
+      functions: [],
+      imports: [],
+      exports: [],
+      dependencies: [],
+      assets: [],
+      shaders: [],
+      validation: {
+        hasRender: false,
+        hasInit: false,
+        hasParameters: false,
+        isValid: true,
+        issues: []
+      }
+    };
+
+    // Extract exports
+    const exportMatches = [...code.matchAll(/export\s+(?:const|function|class|let|var)\s+(\w+)/g)];
+    analysis.exports = exportMatches.map(match => match[1]);
+
+    // Validate required exports
+    analysis.validation.hasRender = analysis.exports.includes('render');
+    analysis.validation.hasInit = analysis.exports.includes('init');
+    
+    if (!analysis.validation.hasRender) {
+      analysis.validation.issues.push('Missing required export: render');
+      analysis.validation.isValid = false;
+    }
+
+    // Extract parameters
+    const parameterMatch = code.match(/export\s+const\s+parameters\s*=\s*(\[[\s\S]*?\]);/);
+    if (parameterMatch) {
+      try {
+        analysis.parameters = this.parseParameters(parameterMatch[1]);
+        analysis.validation.hasParameters = true;
+      } catch (error) {
+        this.warnings.push(`Could not parse parameters: ${error.message}`);
+      }
+    }
+
+    // Extract imports and resolve dependencies
+    const importMatches = [...code.matchAll(/import\s+.*?from\s+['"]([^'"]+)['"]/g)];
+    for (const match of importMatches) {
+      const importPath = match[1];
+      analysis.imports.push(importPath);
+      
+      if (!importPath.startsWith('.')) {
+        // External dependency
+        analysis.dependencies.push(importPath);
+      } else {
+        // Local file - resolve and analyze
+        const resolvedPath = resolve(dirname(filePath), importPath);
+        if (existsSync(resolvedPath) || existsSync(resolvedPath + '.js')) {
+          const localDep = existsSync(resolvedPath) ? resolvedPath : resolvedPath + '.js';
+          analysis.dependencies.push(localDep);
+        } else {
+          this.warnings.push(`Could not resolve local import: ${importPath}`);
+        }
+      }
+    }
+
+    // Find shader files
+    const shaderExtensions = ['.glsl', '.vert', '.frag', '.vs', '.fs'];
+    const projectDir = dirname(filePath);
+    analysis.shaders = await this.findFiles(projectDir, shaderExtensions);
+
+    // Find assets
+    const assetExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.mp3', '.wav', '.ogg'];
+    analysis.assets = await this.findFiles(projectDir, assetExtensions);
+
+    return analysis;
+  }
+
+  async findFiles(directory, extensions) {
+    const files = [];
+    
+    try {
+      const entries = await readdir(directory, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = join(directory, entry.name);
+        
+        if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+          files.push(...await this.findFiles(fullPath, extensions));
+        } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      // Directory doesn't exist or can't be read
+    }
+    
+    return files;
+  }
+
+  parseParameters(parameterString) {
+    // Safe parameter parsing with error handling
+    try {
+      // Replace template literals and clean up for evaluation
+      const cleanedString = parameterString
+        .replace(/`([^`]*)`/g, '"$1"') // Convert template literals to strings
+        .replace(/\$\{[^}]*\}/g, '""'); // Remove template expressions
+      
+      return eval(cleanedString);
+    } catch (error) {
+      throw new Error(`Invalid parameters syntax: ${error.message}`);
+    }
+  }
+
+  async createBundle(sceneCode, analysis, projectDir) {
+    const bundle = {
+      main: sceneCode,
+      dependencies: new Map(),
+      assets: new Map(),
+      shaders: new Map()
+    };
+
+    // Bundle local dependencies (shallow: only direct relative imports that exist)
+    for (const dep of analysis.dependencies) {
+      if (dep.startsWith('/') || dep.includes(':\\')) {
+        // Absolute path - local file
+        try {
+          const content = await readFile(dep, 'utf8');
+          const relativePath = relative(projectDir, dep);
+          bundle.dependencies.set(relativePath, content);
+        } catch (error) {
+          this.warnings.push(`Could not read dependency: ${dep}`);
+        }
+      }
+    }
+
+    // Skip asset inlining for simple build
+
+    // Bundle shaders
+    for (const shaderPath of analysis.shaders) {
+      try {
+        const content = await readFile(shaderPath, 'utf8');
+        const relativePath = relative(projectDir, shaderPath);
+        bundle.shaders.set(relativePath, content);
+      } catch (error) {
+        this.warnings.push(`Could not read shader: ${shaderPath}`);
+      }
+    }
+
+    return bundle;
+  }
+
+  async generateOutput(bundle, analysis) {
+    const timestamp = new Date().toISOString();
+    
+    let output = `/**
+ * Viji Scene Bundle
+ * Generated: ${timestamp}
+ * Minified: ${this.options.minify}
+ * Platform: Universal
+ */
+
+`;
+
+    // Add bundled dependencies
+    if (bundle.dependencies.size > 0) {
+      output += `// === Bundled Dependencies ===\n`;
+      for (const [path, content] of bundle.dependencies) {
+        output += `// File: ${path}\n`;
+        output += content + '\n\n';
+      }
+    }
+
+    // No assets bundling in simple build
+
+    // No shader bundling in simple build
+
+    // Scene parameters (if present in code via export const parameters) are not transformed
+
+    // Add main scene code
+    output += `// === Main Scene Code ===\n`;
+    output += bundle.main + '\n\n';
+
+    // No compatibility wrapper; emit plain concatenated code
+
+    // Add bundle metadata
+    output += `\n// === Bundle Metadata ===\n`;
+    output += `const BUNDLE_METADATA = {\n`;
+    output += `  version: "1.0.0",\n`;
+    output += `  generatedAt: "${timestamp}",\n`;
+    output += `  parameters: SCENE_PARAMETERS,\n`;
+    output += `  exports: ${JSON.stringify(analysis.exports)},\n`;
+    output += `  hasAssets: ${bundle.assets.size > 0},\n`;
+    output += `  hasShaders: ${bundle.shaders.size > 0},\n`;
+    output += `  minified: ${this.options.minify}\n`;
+    output += `};\n`;
+
+    // Never minify per current contract
+
+    return output;
+  }
+
+  // Removed compatibility wrapper
+
+  // Removed minifier
+
+  // Removed source map generation
+
+  generateMetadata(analysis, buildInfo) {
+    return {
+      version: '1.0.0',
+      buildInfo,
+      scene: {
+        parameters: analysis.parameters,
+        exports: analysis.exports,
+        validation: analysis.validation,
+        dependencies: analysis.dependencies.length,
+        assets: analysis.assets.length,
+        shaders: analysis.shaders.length
+      },
+      compatibility: {
+        vijiCore: '>=0.2.0',
+        platform: 'universal'
+      },
+      performance: {
+        complexity: this.assessComplexity(analysis),
+        estimatedMemory: this.estimateMemoryUsage(analysis),
+        features: this.detectFeatures(analysis)
+      }
+    };
+  }
+
+  assessComplexity(analysis) {
+    let score = 0;
+    
+    if (analysis.exports.includes('onMouseMove')) score += 10;
+    if (analysis.exports.includes('onKeyPress')) score += 5;
+    if (analysis.parameters.length > 10) score += 15;
+    if (analysis.assets.length > 5) score += 10;
+    if (analysis.shaders.length > 0) score += 20;
+    if (analysis.dependencies.length > 3) score += 10;
+    
+    if (score < 20) return 'low';
+    if (score < 50) return 'medium';
+    return 'high';
+  }
+
+  estimateMemoryUsage(analysis) {
+    let size = 100; // Base KB
+    
+    size += analysis.parameters.length * 2;
+    size += analysis.assets.length * 50; // Assume average 50KB per asset
+    size += analysis.shaders.length * 10;
+    size += analysis.dependencies.length * 20;
+    
+    return `~${Math.round(size)}KB`;
+  }
+
+  detectFeatures(analysis) {
+    const features = [];
+    
+    if (analysis.exports.includes('onMouseMove')) features.push('mouse-interaction');
+    if (analysis.exports.includes('onKeyPress')) features.push('keyboard-input');
+    if (analysis.exports.includes('onResize')) features.push('responsive');
+    if (analysis.assets.length > 0) features.push('assets');
+    if (analysis.shaders.length > 0) features.push('shaders');
+    if (analysis.parameters.some(group => group.category === 'audio')) features.push('audio-reactive');
+    
+    return features;
+  }
+}
+