npm - @aetherframework/template-engine - Versions diffs - 1.0.0 - Mend

@aetherframework/template-engine 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/LICENSE +21 -0
package/README.md +662 -0
package/examples/basic-usage.js +217 -0
package/examples/dist/basic-usage-result.html +31 -0
package/examples/dist/layout-example-result.html +210 -0
package/examples/dist/templates/layouts/main.aether +58 -0
package/examples/dist/templates/pages/home.aether +116 -0
package/examples/layout-example.js +404 -0
package/examples/ssr-example.js +180 -0
package/index.js +179 -0
package/package.json +42 -0
package/src/core/CacheManager.js +245 -0
package/src/core/EngineRegistry.js +148 -0
package/src/core/ModeManager.js +231 -0
package/src/core/TemplateEngineFactory.js +373 -0
package/src/engines/AetherEngine.js +582 -0
package/src/engines/BaseEngine.js +101 -0
package/src/engines/SSRModeEngine.js +139 -0
package/src/engines/TemplateModeEngine.js +320 -0
package/src/utils/ConfigLoader.js +279 -0
package/src/utils/ErrorHandler.js +276 -0

package/index.js ADDED Viewed

@@ -0,0 +1,179 @@
+/**
+ * Aether Template Engine - Main Entry Point
+ * Provides a unified interface to access the Template Engine Factory
+ */
+import TemplateEngineFactory from './src/core/TemplateEngineFactory.js';
+import ConfigLoader from './src/utils/ConfigLoader.js';
+// Export main factory class
+export { TemplateEngineFactory };
+// Export utility classes
+export { ConfigLoader };
+// Export engine classes
+export { default as AetherEngine } from './src/engines/AetherEngine.js';
+export { default as SSRModeEngine } from './src/engines/SSRModeEngine.js';
+export { default as TemplateModeEngine } from './src/engines/TemplateModeEngine.js';
+export { default as BaseEngine } from './src/engines/BaseEngine.js';
+// Export core components
+export { default as EngineRegistry } from './src/core/EngineRegistry.js';
+export { default as ModeManager } from './src/core/ModeManager.js';
+export { default as CacheManager } from './src/core/CacheManager.js';
+/**
+ * Create a template engine factory with default configuration
+ * @param {Object} options - Configuration options
+ * @returns {Promise<TemplateEngineFactory>} Template engine factory instance
+ */
+export async function createEngine(options = {}) {
+  // Create factory instance
+  const factory = new TemplateEngineFactory(options);
+  // Initialize the factory (this will register engines)
+  await factory.initialize();
+  return factory;
+}
+/**
+ * Create a template engine factory from environment configuration
+ * @returns {Promise<TemplateEngineFactory>} Template engine factory instance
+ */
+export async function createEngineFromEnv() {
+  const configLoader = new ConfigLoader();
+  const config = await configLoader.load();
+  // Validate configuration
+  const validation = configLoader.validate();
+  if (!validation.valid) {
+    console.warn('⚠️ Configuration validation warnings:', validation.warnings);
+    if (validation.errors.length > 0) {
+      throw new Error(`Configuration errors: ${validation.errors.join(', ')}`);
+    }
+  }
+  const factory = new TemplateEngineFactory(config);
+  await factory.initialize();
+  return factory;
+}
+/**
+ * Quick start function for common use cases
+ * @param {Object} options - Quick start options
+ * @returns {Promise<Object>} Engine instance and utilities
+ */
+export async function quickStart(options = {}) {
+  const defaultOptions = {
+    mode: 'template',
+    templateDir: './templates',
+    cacheEnabled: true,
+    debug: process.env.NODE_ENV === 'development'
+  };
+  const config = { ...defaultOptions, ...options };
+  const factory = new TemplateEngineFactory(config);
+  await factory.initialize();
+  // Create default directory structure
+  const fs = await import('fs-extra');
+  const dirs = [
+    config.templateDir,
+    `${config.templateDir}/layouts`,
+    `${config.templateDir}/pages`,
+    `${config.templateDir}/components`,
+    `${config.templateDir}/partials`
+  ];
+  for (const dir of dirs) {
+    await fs.ensureDir(dir);
+  }
+  // Create default layout
+  const defaultLayout = `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>@yield('title', 'Aether Framework')</title>
+    <meta name="description" content="@yield('description', '下一代轻量级全栈解决方案')">
+    <meta name="keywords" content="@yield('keywords', 'Aether,Framework,Web')">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <script src="https://cdn.tailwindcss.com"></script>
+    @yield('head')
+</head>
+<body class="antialiased bg-[#020617] text-white">
+    @yield('content')
+    @yield('scripts')
+</body>
+</html>`;
+  const layoutPath = `${config.templateDir}/layouts/default.aether`;
+  await fs.writeFile(layoutPath, defaultLayout, 'utf-8');
+  // Create example page
+  const examplePage = `@extends('layouts/default')
+@section('title', 'Welcome to Aether Framework')
+@section('description', 'A modern template engine for Node.js applications')
+@section('keywords', 'template, engine, nodejs, javascript')
+@section('content')
+<div class="min-h-screen flex items-center justify-center">
+    <div class="text-center">
+        <h1 class="text-4xl font-bold mb-6">Welcome to Aether Framework</h1>
+        <p class="text-xl text-gray-300 mb-8">Your template engine is ready to use!</p>
+        <div class="bg-gray-800 rounded-lg p-6 max-w-md mx-auto">
+            <h2 class="text-2xl font-semibold mb-4">Quick Start</h2>
+            <p class="mb-4">This is an example page created with Aether Template Engine.</p>
+            <div class="space-y-3">
+                <div class="flex items-center justify-between">
+                    <span>Mode:</span>
+                    <code class="bg-gray-900 px-2 py-1 rounded">{{mode}}</code>
+                </div>
+                <div class="flex items-center justify-between">
+                    <span>Cache:</span>
+                    <span class="{{cacheEnabled ? 'text-green-500' : 'text-red-500'}}">{{cacheEnabled ? 'Enabled' : 'Disabled'}}</span>
+                </div>
+                <div class="flex items-center justify-between">
+                    <span>Template Dir:</span>
+                    <code class="bg-gray-900 px-2 py-1 rounded">{{templateDir}}</code>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+@endsection
+@section('scripts')
+<script>
+    console.log('Aether Template Engine loaded successfully!');
+</script>
+@endsection`;
+  const pagePath = `${config.templateDir}/pages/welcome.aether`;
+  await fs.writeFile(pagePath, examplePage, 'utf-8');
+  // Create renderer
+  const renderer = factory.createRenderer('aether');
+  return {
+    factory,
+    renderer,
+    config
+  };
+}
+export default {
+  createEngine,
+  createEngineFromEnv,
+  quickStart,
+  TemplateEngineFactory
+};

package/package.json ADDED Viewed

@@ -0,0 +1,42 @@
+{
+  "name": "@aetherframework/template-engine",
+  "version": "1.0.0",
+  "description": "A lightweight, high-performance template engine with SSR support and custom syntax",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node examples/basic-usage.js",
+    "test:basic": "node examples/basic-usage.js",
+    "test:layout": "node examples/layout-example.js",
+    "test:ssr": "node examples/ssr-example.js",
+    "clean": "rm -rf templates/cache"
+  },
+  "author": "Aether Framework Team",
+   "license": "MIT",
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/aetherjs/aetherframework-template-engine.git"
+   },
+   "bugs": {
+      "url": "https://github.com/aetherjs/aetherframework-template-engine/issues",
+      "email": "support@aetherjs.org"
+   },
+   "homepage": "https://www.aetherjs.org",
+  "files": [
+    "index.js",
+    "README.md",
+    "src",
+    "examples",
+    "LICENSE"
+  ],
+  "keywords": [
+    "template",
+    "engine",
+    "ssr",
+    "aether",
+    "html"
+  ],
+  "dependencies": {
+    "fs-extra": "^11.2.0"
+  }
+}

package/src/core/CacheManager.js ADDED Viewed

@@ -0,0 +1,245 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/template-engine/src/core/CacheManager
+ */
+/**
+ * Cache Manager - Manages template and compilation cache
+ */
+class CacheManager {
+  constructor(options = {}) {
+    this.options = {
+      enabled: options.enabled !== false,
+      ttl: options.ttl || 300000, // 5 minutes default
+      maxSize: options.maxSize || 1000,
+      ...options
+    };
+    this.cache = new Map();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      sets: 0,
+      deletes: 0,
+      size: 0
+    };
+  }
+  /**
+   * Set cache entry
+   * @param {string} key - Cache key
+   * @param {any} value - Cache value
+   * @param {number} ttl - Time to live in milliseconds
+   * @returns {CacheManager} This instance for chaining
+   */
+  set(key, value, ttl = this.options.ttl) {
+    if (!this.options.enabled) return this;
+    // Check cache size limit
+    if (this.cache.size >= this.options.maxSize) {
+      this.evictOldest();
+    }
+    const entry = {
+      value,
+      timestamp: Date.now(),
+      ttl,
+      expiresAt: Date.now() + ttl
+    };
+    this.cache.set(key, entry);
+    this.stats.sets++;
+    this.stats.size = this.cache.size;
+    return this;
+  }
+  /**
+   * Get cache entry
+   * @param {string} key - Cache key
+   * @returns {any} Cached value or undefined
+   */
+  get(key) {
+    if (!this.options.enabled) return undefined;
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      return undefined;
+    }
+    // Check if entry has expired
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.stats.misses++;
+      this.stats.size = this.cache.size;
+      return undefined;
+    }
+    this.stats.hits++;
+    return entry.value;
+  }
+  /**
+   * Check if cache has key
+   * @param {string} key - Cache key
+   * @returns {boolean} True if key exists and is not expired
+   */
+  has(key) {
+    if (!this.options.enabled) return false;
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.stats.size = this.cache.size;
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Delete cache entry
+   * @param {string} key - Cache key
+   * @returns {boolean} True if entry was deleted
+   */
+  delete(key) {
+    const deleted = this.cache.delete(key);
+    if (deleted) {
+      this.stats.deletes++;
+      this.stats.size = this.cache.size;
+    }
+    return deleted;
+  }
+  /**
+   * Clear all cache entries
+   * @returns {CacheManager} This instance for chaining
+   */
+  clear() {
+    this.cache.clear();
+    this.stats.size = 0;
+    this.stats.deletes++;
+    return this;
+  }
+  /**
+   * Get cache size
+   * @returns {number} Number of cache entries
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * Get cache statistics
+   * @returns {Object} Cache statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      enabled: this.options.enabled,
+      ttl: this.options.ttl,
+      maxSize: this.options.maxSize,
+      currentSize: this.cache.size,
+      hitRate: this.stats.hits + this.stats.misses > 0
+        ? (this.stats.hits / (this.stats.hits + this.stats.misses) * 100).toFixed(2) + '%'
+        : '0%'
+    };
+  }
+  /**
+   * Evict oldest cache entries
+   * @private
+   */
+  evictOldest() {
+    if (this.cache.size === 0) return;
+    // Find oldest entry
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache) {
+      if (entry.timestamp < oldestTime) {
+        oldestTime = entry.timestamp;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+      this.stats.deletes++;
+      this.stats.size = this.cache.size;
+    }
+  }
+  /**
+   * Clean expired cache entries
+   * @returns {number} Number of entries cleaned
+   */
+  cleanExpired() {
+    let cleaned = 0;
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+    this.stats.size = this.cache.size;
+    return cleaned;
+  }
+  /**
+   * Enable cache
+   * @returns {CacheManager} This instance for chaining
+   */
+  enable() {
+    this.options.enabled = true;
+    return this;
+  }
+  /**
+   * Disable cache
+   * @returns {CacheManager} This instance for chaining
+   */
+  disable() {
+    this.options.enabled = false;
+    this.clear();
+    return this;
+  }
+  /**
+   * Set cache TTL
+   * @param {number} ttl - Time to live in milliseconds
+   * @returns {CacheManager} This instance for chaining
+   */
+  setTTL(ttl) {
+    this.options.ttl = ttl;
+    return this;
+  }
+  /**
+   * Set cache max size
+   * @param {number} maxSize - Maximum cache size
+   * @returns {CacheManager} This instance for chaining
+   */
+  setMaxSize(maxSize) {
+    this.options.maxSize = maxSize;
+    // Evict entries if current size exceeds new max
+    while (this.cache.size > maxSize) {
+      this.evictOldest();
+    }
+    return this;
+  }
+}
+export default CacheManager;

package/src/core/EngineRegistry.js ADDED Viewed

@@ -0,0 +1,148 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/template-engine/src/core/EngineRegistry
+ */
+/**
+ * Engine Registry - Manages template engine registration and retrieval
+ */
+class EngineRegistry {
+  constructor() {
+    this.engines = new Map();
+    this.defaultEngine = null;
+  }
+  /**
+   * Register a template engine
+   * @param {string} name - Engine name
+   * @param {BaseEngine} engine - Engine instance
+   * @param {boolean} isDefault - Whether to set as default engine
+   */
+  register(name, engine, isDefault = false) {
+    if (this.engines.has(name)) {
+      console.warn(`⚠️ Engine "${name}" already registered, overwriting...`);
+    }
+    this.engines.set(name, engine);
+    if (isDefault || this.engines.size === 1) {
+      this.defaultEngine = name;
+    }
+    return this;
+  }
+  /**
+   * Get engine by name
+   * @param {string} name - Engine name
+   * @returns {BaseEngine} Engine instance
+   */
+  get(name) {
+    if (!this.engines.has(name)) {
+      throw new Error(`Engine "${name}" not found. Available engines: ${Array.from(this.engines.keys()).join(', ')}`);
+    }
+    return this.engines.get(name);
+  }
+  /**
+   * Check if engine exists
+   * @param {string} name - Engine name
+   * @returns {boolean} True if engine exists
+   */
+  has(name) {
+    return this.engines.has(name);
+  }
+  /**
+   * Remove engine by name
+   * @param {string} name - Engine name
+   * @returns {boolean} True if engine was removed
+   */
+  unregister(name) {
+    const removed = this.engines.delete(name);
+    if (removed && this.defaultEngine === name) {
+      this.defaultEngine = this.engines.keys().next().value || null;
+    }
+    return removed;
+  }
+  /**
+   * Get default engine
+   * @returns {BaseEngine} Default engine instance
+   */
+  getDefault() {
+    if (!this.defaultEngine) {
+      throw new Error('No default engine set');
+    }
+    return this.get(this.defaultEngine);
+  }
+  /**
+   * Set default engine
+   * @param {string} name - Engine name
+   */
+  setDefault(name) {
+    if (!this.engines.has(name)) {
+      throw new Error(`Cannot set default: Engine "${name}" not found`);
+    }
+    this.defaultEngine = name;
+    return this;
+  }
+  /**
+   * List all registered engines
+   * @returns {Array} List of engine names
+   */
+  listEngines() {
+    return Array.from(this.engines.keys());
+  }
+  /**
+   * Get engine metadata
+   * @param {string} name - Engine name
+   * @returns {Object} Engine metadata
+   */
+  getEngineInfo(name) {
+    const engine = this.get(name);
+    return engine ? engine.getMetadata() : null;
+  }
+  /**
+   * Clear all engine caches
+   */
+  clearCaches() {
+    for (const [name, engine] of this.engines) {
+      if (typeof engine.clearCache === 'function') {
+        engine.clearCache();
+      }
+    }
+  }
+  /**
+   * Get engine statistics
+   * @returns {Object} Statistics
+   */
+  getStats() {
+    const stats = {
+      totalEngines: this.engines.size,
+      defaultEngine: this.defaultEngine,
+      engines: []
+    };
+    for (const [name, engine] of this.engines) {
+      stats.engines.push({
+        name,
+        initialized: engine.initialized || false,
+        metadata: engine.getMetadata ? engine.getMetadata() : {}
+      });
+    }
+    return stats;
+  }
+}
+export default EngineRegistry;