@aetherframework/template-engine 1.0.1 → 1.0.5

package/src/engines/AetherEngine.js

@@ -13,11 +13,12 @@
 import fs from 'fs-extra';
 import path from 'path';
 import crypto from 'crypto';
+import CompressionEngine from './CompressionEngine.js';
 
 class AetherEngine {
   constructor(options = {}) {
     this.name = 'aether';
-    this.version = '1.3.0'; // Version upgraded
+    this.version = '1.3.0';
     this.initialized = false;
     
     this.options = {
@@ -27,14 +28,27 @@ class AetherEngine {
       compileCache: new Map(),
       templateCache: new Map(),
       debug: options.debug || false,
-      csrfToken: options.csrfToken || '', 
+      csrfToken: options.csrfToken || '',
+      
+      // Compression options
+      compressionEnabled: options.compressionEnabled !== false,
+      minifyHTML: options.minifyHTML !== false,
+      minifyCSS: options.minifyCSS !== false,
+      minifyJS: options.minifyJS !== false,
+      mangleJS: options.mangleJS || false,
+      removeComments: options.removeComments || false,
+      collapseWhitespace: options.collapseWhitespace || true,
+      cacheCompressed: options.cacheCompressed !== false,
       ...options
     };
     
+    // Initialize compression engine
+    this.compressionEngine = new CompressionEngine(this.options);
+    
     this.filters = new Map();
     this.functions = new Map();
     this.layouts = new Map();
-    this.routes = {}; 
+    this.routes = {};
     
     this.ensureTemplateDir();
     this.registerDefaultFilters();
@@ -43,10 +57,37 @@ class AetherEngine {
   
   initialize() {
     if (this.initialized) return;
-    console.log(`Aether Engine initialized (v${this.version})`);
     this.initialized = true;
   }
-  
+
+  /**
+   * Process content with compression based on options
+   */
+  processWithCompression(content, options = {}) {
+    if (!this.options.compressionEnabled) return content;
+    
+    const processOptions = {
+      minifyHTML: this.options.minifyHTML,
+      minifyCSS: this.options.minifyCSS,
+      minifyJS: this.options.minifyJS,
+      mangleJS: this.options.mangleJS,
+      removeComments: this.options.removeComments,
+      collapseWhitespace: this.options.collapseWhitespace,
+      cacheCompressed: this.options.cacheCompressed,
+      ...options
+    };
+    
+    return this.compressionEngine.processHTML(content, processOptions);
+  }
+
+  clearCompressionCache() {
+    if (this.compressionEngine) this.compressionEngine.clearCompressionCache();
+  }
+
+  getCompressionStats() {
+    return this.compressionEngine ? this.compressionEngine.getStats() : null;
+  }
+
   ensureTemplateDir() {
     const dirs = [
       this.options.templateDir,
@@ -89,9 +130,7 @@ class AetherEngine {
     });
 
     this.function('class', (classes) => {
-      if (Array.isArray(classes)) {
-        return classes.filter(c => typeof c === 'string').join(' ');
-      }
+      if (Array.isArray(classes)) return classes.filter(c => typeof c === 'string').join(' ');
       return '';
     });
 
@@ -313,12 +352,10 @@ class AetherEngine {
           inSectionBlock = false; currentSectionName = ''; sectionContent = '';
         }
       }
-      // FIX: Enhance @include syntax to support passing data parameters
       else if (token.startsWith('@include')) {
         const includeMatch = token.match(/@include\s*\(\s*'([^']+)'\s*(?:,\s*([\s\S]*?))?\s*\)/);
         if (includeMatch) {
           const viewName = includeMatch[1];
-          // Default to empty object if no params; otherwise evaluate as JS expression
           const dataExpr = includeMatch[2] ? includeMatch[2].trim() : '{}';
           
           if (inSectionBlock) sectionContent += token;
@@ -367,17 +404,22 @@ class AetherEngine {
         return value;
       }
       
-      // FIX: Fully implement __include to support synchronous loading, compiling, and rendering of sub-templates from disk
+      // [CRITICAL FIX] Preserve prototype chain to prevent losing root data variables (like langUrls, t, etc.)
+      // Object.assign only copies own enumerable properties, ignoring the prototype chain where 
+      // the original 'data' object properties reside.
       function __include(name, includeData = {}) {
-        // 1. Merge current scope with passed include data
-        const mergedScope = Object.assign({}, __scope, includeData);
+        // 1. Create a new scope that inherits from the current scope's prototype (the original data)
+        const mergedScope = Object.create(Object.getPrototypeOf(__scope));
         
-        // 2. Prioritize pre-compiled includes (passed via render options)
+        // 2. Copy own properties from current scope (e.g., loop variables) and includeData
+        Object.assign(mergedScope, __scope, includeData);
+        
+        // 3. Prioritize pre-compiled includes (passed via render options)
         if (helpers.includes && helpers.includes[name]) {
             return helpers.includes[name](mergedScope, helpers);
         }
         
-        // 3. Synchronously load and compile template from disk
+        // 4. Synchronously load and compile template from disk
         if (helpers.engine) {
             try {
                 const content = helpers.engine.loadTemplateSync(name);
@@ -489,8 +531,6 @@ class AetherEngine {
     let jsCode = '';
     try {
       jsCode = this.enhancedConvertToJsCode(templateContent);
-      if (this.options.debug) console.log('\n--- Generated JS Code ---\n' + jsCode + '\n-------------------------\n');
-
       const renderFunc = new Function('data', 'helpers', `
         const __output = [];
         const __sections = {};
@@ -519,36 +559,74 @@ class AetherEngine {
     const isFilePath = typeof templateName === 'string' && !templateName.includes('\n') && !templateName.includes('<') && (templateName.endsWith('.aether') || templateName.endsWith('.html') || templateName.includes('/') || templateName.includes('\\'));
     if (isFilePath) templateContent = await this.loadTemplate(templateName);
     
+    // [FIX] Correct regex and match groups for layout inheritance
     const extendsMatch = templateContent.match(/@extends\s*\(\s*'([^']+)'\s*\)/);
     if (extendsMatch) {
-      const layoutName = extendsMatch[1];
+      const layoutName = extendsMatch[1]; 
       try {
         const layoutContent = await this.loadTemplate(layoutName);
         const sections = {};
+        
         const sectionRegex = /@section\s*\(\s*'([^']+)'\s*\)([\s\S]*?)@endsection/g;
         let sectionMatch;
-        while ((sectionMatch = sectionRegex.exec(templateContent)) !== null) sections[sectionMatch[1]] = sectionMatch[2].trim();
+        while ((sectionMatch = sectionRegex.exec(templateContent)) !== null) {
+          sections[sectionMatch[1]] = sectionMatch[2].trim(); 
+        }
         
         const inlineSectionRegex = /@section\s*\(\s*'([^']+)'\s*,\s*'([^']*)'\s*\)/g;
         let inlineMatch;
-        while ((inlineMatch = inlineSectionRegex.exec(templateContent)) !== null) sections[inlineMatch[1]] = inlineMatch[2];
+        while ((inlineMatch = inlineSectionRegex.exec(templateContent)) !== null) {
+          sections[inlineMatch[1]] = inlineMatch[2]; 
+        }
         
         const yieldRegex = /@yield\s*\(\s*'([^']+)'(?:\s*,\s*'([^']*)')?\s*\)/g;
-        templateContent = layoutContent.replace(yieldRegex, (match, name, defaultValue) => sections[name] !== undefined ? sections[name] : (defaultValue || ''));
-      } catch (error) { console.warn(`Warning: Could not load layout '${layoutName}':`, error.message); }
+        templateContent = layoutContent.replace(yieldRegex, (match, name, defaultValue) => 
+          sections[name] !== undefined ? sections[name] : (defaultValue || '')
+        );
+      } catch (error) { 
+        console.warn(`Warning: Could not load layout '${layoutName}':`, error.message); 
+      }
     }
     
     const renderFunc = this.compile(templateContent);
-    // FIX: Pass engine instance to helpers so __include can synchronously call loadTemplateSync
-    return renderFunc(data, { 
-        filters: this.filters, 
-        functions: this.functions, 
-        includes: options.includes || {},
-        engine: this 
+    
+    const renderedContent = renderFunc(data, { 
+      filters: this.filters, 
+      functions: this.functions, 
+      includes: options.includes || {},
+      engine: this 
     });
+    
+    if (this.options.compressionEnabled) {
+      const compressionOptions = {
+        minifyHTML: this.options.minifyHTML,
+        minifyCSS: this.options.minifyCSS,
+        minifyJS: this.options.minifyJS,
+        mangleJS: this.options.mangleJS,
+        removeComments: this.options.removeComments,
+        collapseWhitespace: this.options.collapseWhitespace,
+        removeAttributeQuotes: this.options.removeAttributeQuotes,
+        removeEmptyAttributes: this.options.removeEmptyAttributes,
+        cacheCompressed: this.options.cacheCompressed,
+        ...options.compression 
+      };
+      
+      if (this.compressionEngine) {
+        const compressedContent = this.compressionEngine.processHTML(renderedContent, compressionOptions);
+        
+        if (this.options.debug) {
+          const originalSize = renderedContent.length;
+          const compressedSize = compressedContent.length;
+          const reduction = ((originalSize - compressedSize) / originalSize * 100).toFixed(2);
+        }
+        
+        return compressedContent;
+      }
+    }
+    
+    return renderedContent;
   }
 
-  // FIX: Extract unified path resolution logic, supporting dot notation (e.g., 'partials.header')
   _getTemplatePaths(templateName) {
     const paths = [
       path.join(this.options.templateDir, 'partials', `${templateName}.aether`),
@@ -559,7 +637,6 @@ class AetherEngine {
       templateName 
     ];
     
-    // Support dot notation resolution: 'partials.header' -> 'partials/header.aether'
     if (templateName.includes('.')) {
       const dotPath = templateName.replace(/\./g, path.sep) + '.aether';
       paths.unshift(path.join(this.options.templateDir, dotPath));
@@ -582,34 +659,27 @@ class AetherEngine {
     throw new Error(`Template not found: ${templateName}`);
   }
   
-  // FIX: Add synchronous loading method specifically for runtime @include usage
+  /**
+   * [FIX] Synchronously load template from disk for runtime @include usage
+   */
   loadTemplateSync(templateName) {
     if (this.options.cacheEnabled && this.options.templateCache.has(templateName)) {
-        return this.options.templateCache.get(templateName);
+      return this.options.templateCache.get(templateName);
     }
     
     const possiblePaths = this._getTemplatePaths(templateName);
     for (const templatePath of possiblePaths) {
       try {
-        if (fs.existsSync(templatePath)) {
-            const content = fs.readFileSync(templatePath, 'utf-8');
-            if (this.options.cacheEnabled) this.options.templateCache.set(templateName, content);
-            return content;
-        }
-      } catch (error) {}
+        // Use readFileSync for synchronous loading required by __include
+        const content = fs.readFileSync(templatePath, 'utf-8');
+        if (this.options.cacheEnabled) this.options.templateCache.set(templateName, content);
+        return content;
+      } catch (error) {
+        // Ignore and try next path
+      }
     }
     throw new Error(`Template not found: ${templateName}`);
   }
-  
-  clearCache() { this.options.compileCache.clear(); this.options.templateCache.clear(); }
-  
-  getMetadata() {
-    return {
-      name: this.name, version: this.version, initialized: this.initialized,
-      filters: Array.from(this.filters.keys()), functions: Array.from(this.functions.keys()),
-      layouts: Array.from(this.layouts.keys()), cacheEnabled: this.options.cacheEnabled, templateDir: this.options.templateDir
-    };
-  }
 }
 
 export default AetherEngine;