mm_statics 1.5.0 → 1.5.2

package/index.js

@@ -1,165 +1,1150 @@
-const fs = require('fs');
-const send = require('koa-send');
-const path = require('path');
-const es6_to_amd = require('mm_es6_to_amd');
-
-
-class Statics {
-	/** 
-	 * 创建静态文件访问器
-	 * @param {String} root 文件根目录
-	 * @param {Object} config 配置
-	 * @param {Object} es6_to_amd 将ES6的js、vue文件转AMD标准, 传入需要转换的后缀名
-	 */
-	constructor(root, config, es6_to_amd) {
-		/**
-		 * @description ES6的js、vue文件转AMD标准配置
-		 */
-		this.es6_to_amd = {
-			/**
-			 * 处理转换的文件路径，当文件属于改路径下的才进行转换
-			 */
-			path: '/src',
-			/**
-			 * @param {Array} 需要转换的文件后缀名
-			 */
-			files: ['.js', '.vue']
-		};
-
-		/**
-		 * 配置参数
-		 */
-		this.config = {
-			index: "index.html",
-			maxage: 7200 * 1000,
-			immutable: true,
-			hidden: false,
-			format: false,
-			extensions: false,
-			brotli: false,
-			gzip: false,
-			root: root ? root : './static'
-		};
-
-		if (config) {
-			if (config.maxAge) {
-				config.maxage = config.maxAge * 1000;
-				delete config.maxAge;
-			} else if (config.maxage) {
-				config.maxage *= 1000;
-			}
-			$.push(this.config, config);
-		}
-
-		if (es6_to_amd) {
-			$.push(this.es6_to_amd, es6_to_amd);
-		}
-	}
-}
-
-
-/**
- * 执行静态文件处理 (转换为ES5标准)
- * @method run
- * @param {Object} ctx http请求上下文
- * @param {Function} next 跳过当前执行，先执行后面函数
- * @return {Boolean} 是否执行成功
- */
-Statics.prototype.main = async function(ctx, next) {
-	await next();
-	if (ctx.method !== 'HEAD' && ctx.method !== 'GET')
-		return;
-	// 已处理响应
-	if (ctx.body != null || ctx.status !== 404)
-		return;
-
-	var path = ctx.path;
-
-	if (path.startWith(this.es6_to_amd.path)) {
-		// 是否需要转换
-		var bl = false;
-		var lt = this.es6_to_amd.files;
-		var len = lt.length;
-		for (var i = 0; i < len; i++) {
-			if (path.endsWith(lt[i])) {
-				bl = true;
-				break;
-			}
-		}
-		if (bl) {
-			var file = this.config.root + path;
-			if (!file.hasFile()) {
-				return;
-			}
-			var code;
-			try {
-				var str = file.loadText();
-				code = es6_to_amd(str);
-			} catch (e) {
-				throw e
-			}
-			if (code) {
-				if (path.endsWith('.js')) {
-					ctx.response.type = "application/javascript; charset=utf-8";
-				}
-				ctx.body = code;
-				if (this.config.maxage) {
-					if (this.config.immutable) {
-						ctx.set('Cache-Control', 'max-age=' + (this.config.maxage / 1000) + ",immutable");
-					} else {
-						ctx.set('Cache-Control', 'max-age=' + (this.config.maxage / 1000));
-					}
-				}
-				return file;
-			}
-		}
-	}
-	try {
-		await send(ctx, path, this.config);
-	} catch (err) {
-		if (err.status !== 404) {
-			throw err;
-		}
-	}
-}
-
-/**
- * 执行静态文件处理
- * @param {Object} ctx http请求上下文
- * @param {Function} next 跳过当前执行，先执行后面函数
- * @return {Boolean} 是否执行成功
- */
-Statics.prototype.run = async function(ctx, next) {
-	await next();
-	if (ctx.method !== 'HEAD' && ctx.method !== 'GET')
-		return;
-	// response is already handled
-	if (ctx.body != null || ctx.status !== 404)
-		return; // eslint-disable-line
-	try {
-		await send(ctx, ctx.path, this.config);
-	} catch (err) {
-		if (err.status !== 404) {
-			throw err;
-		}
-	}
-};
-
-/**
- * 用于处理静态文件
- * @param {Object} ctx http请求上下文
- * @param {Function} next 跳过当前执行，先执行后面函数
- * @return {Boolean} 是否执行成功
- */
-module.exports = function(root, config, es6_to_amd) {
-	var static = new Statics(root, config, es6_to_amd);
-	if (static.es6_to_amd.files.length > 0) {
-		return async function(ctx, next) {
-			await static.main(ctx, next);
-		};
-	} else {
-		return async function(ctx, next) {
-			await static.run(ctx, next);
-		};
-	}
+let send = require('koa-send');
+const { EsToAmdConvert } = require('mm_es6_to_amd');
+const { parse } = require('@vue/compiler-sfc');
+
+/**
+ * 静态文件处理类
+ */
+class Static {
+  static config = {
+    index: 'index.html',
+    // 前端缓存时间，单位秒
+    max_age: 7200,
+    // 缓存键前缀
+    key_prefix: 'static:',
+    // 是否开启缓存
+    cache: true,
+    // 后端缓存时间，单位秒
+    cache_age: 7200,
+    immutable: true,
+    hidden: false,
+    format: true,
+    extensions: false,
+    brotli: false,
+    gzip: false,
+    root: './static',
+    // 编译vue文件，启动后会将vue转为js，可让前端通过 import xxx from './xxx.vue' 引入
+    compile_vue: true,
+    // 指定路径文件需要转换
+    path: '/src',
+    files: ['.js', '.vue'],
+    // 是否将files中的文件的js转换为amd格式
+    convert_amd: true,
+    // 是否启用文件修改监听（实时检测文件修改）
+    watch_files: false
+  };
+
+  /**
+   * 初始化静态文件处理类
+   * @param {object} config 配置
+   */
+  constructor(config) {
+    this.config = { ...Static.config };
+    this.convert = new EsToAmdConvert();
+    this.setConfig(config);
+    this._cache = null;
+    this._init();
+  }
+}
+
+/**
+ * 初始化缓存
+ */
+Static.prototype._init = function () {
+  if (this.config.cache) {
+    try {
+      if (!$.cache) {
+        var { Cache } = require('mm_cache');
+        $.cache = new Cache();
+      }
+      this._cache = $.cache;
+    } catch (_error) {
+      // 如果mm_cache模块不存在，使用简单的内存缓存
+      let map = new Map();
+
+      // 为Map实例添加兼容性包装器，支持统一的异步接口
+      this._cache = {
+        get: async function (key) { return map.get(key); },
+        set: async function (key, value, ttl) {
+          map.set(key, value);
+          // 简单的TTL实现，使用setTimeout清除过期缓存
+          if (ttl) {
+            setTimeout(() => {
+              map.delete(key);
+            }, ttl * 1000);
+          }
+        },
+        del: async function (key) { return map.delete(key); }
+      };
+    }
+  }
+
+  // 初始化文件监听器
+  this._initFileWatcher();
+};
+
+/**
+ * 初始化文件监听器
+ */
+Static.prototype._initFileWatcher = function () {
+  // 存储文件监听器和对应的缓存键
+  this._fileWatchers = new Map();
+  
+  // 如果启用文件监听，设置监听器
+  if (this.config.watch_files) {
+    try {
+      this._chokidar = require('chokidar');
+      console.log('[Static] 文件监听功能已启用（使用chokidar）');
+    } catch (error) {
+      console.error('[Static] 加载chokidar模块失败:', error.message);
+      this.config.watch_files = false;
+    }
+  }
+};
+
+/**
+ * 添加文件监听
+ * @param {string} file_path 文件路径
+ * @param {string} cache_key 缓存键
+ */
+Static.prototype._addFileWatcher = function (file_path, cache_key) {
+  if (!this.config.watch_files || !this._chokidar) return;
+  
+  try {
+    // 如果已经存在监听器，先移除
+    if (this._fileWatchers.has(file_path)) {
+      let watcher = this._fileWatchers.get(file_path);
+      watcher.close();
+      this._fileWatchers.delete(file_path);
+    }
+    
+    // 使用chokidar创建更稳定的文件监听器
+    let watcher = this._chokidar.watch(file_path, {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    
+    // 监听文件修改事件
+    watcher.on('change', (path) => {
+      console.log(`[Static] 检测到文件修改: ${path}`);
+      // 文件修改时清除缓存
+      this._cache.del(cache_key).catch(error => {
+        console.error(`[Static] 清除缓存失败: ${error.message}`);
+      });
+    });
+    
+    // 监听错误事件
+    watcher.on('error', (error) => {
+      console.error(`[Static] 文件监听错误: ${error.message}`);
+    });
+    
+    // 存储监听器
+    this._fileWatchers.set(file_path, watcher);
+    
+  } catch (error) {
+    console.error(`[Static] 创建文件监听器失败: ${error.message}`);
+  }
+};
+
+/**
+ * 移除文件监听
+ * @param {string} file_path 文件路径
+ */
+Static.prototype._removeFileWatcher = function (file_path) {
+  if (!this.config.watch_files) return;
+  
+  if (this._fileWatchers.has(file_path)) {
+    let watcher = this._fileWatchers.get(file_path);
+    watcher.close();
+    this._fileWatchers.delete(file_path);
+  }
+};
+
+/**
+ * 获取缓存内容
+ * @param {string} path 文件路径
+ * @param {string} full_path 完整文件路径（用于检查文件修改时间）
+ * @returns {Promise<object|null>} 缓存内容
+ */
+Static.prototype._getCache = async function (path, full_path) {
+  if (!this._cache) return null;
+
+  // 生成缓存键
+  let cache_key = this._generateCacheKey(path);
+
+  // 统一获取缓存数据
+  let data = await this._cache.get(cache_key);
+
+  if (!data) return null;
+
+  // 简单的缓存过期检查，基于时间戳
+  let current_time = Date.now();
+  if (current_time - data.timestamp > this.config.cache_age * 1000) {
+    // 缓存已过期，清除缓存
+    await this._cache.del(cache_key);
+    return null;
+  }
+
+  // 检查文件是否已修改（仅在未启用文件监听时检查）
+  if (!this.config.watch_files && full_path && data.file_mtime) {
+    let current_mtime = this._getFileMtime(full_path);
+    if (current_mtime && current_mtime !== data.file_mtime) {
+      // 文件已修改，清除缓存
+      await this._cache.del(cache_key);
+      return null;
+    }
+  }
+
+  return data;
+};
+
+/**
+ * 获取文件修改时间戳
+ * @param {string} file_path 文件路径
+ * @returns {number|null} 文件修改时间戳，获取失败返回null
+ */
+Static.prototype._getFileMtime = function (file_path) {
+  try {
+    let fs = require('fs');
+    let stats = fs.statSync(file_path);
+    return stats.mtime.getTime();
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * 设置缓存内容
+ * @param {string} path 文件路径
+ * @param {string} content 文件内容
+ * @param {string} mime_type MIME类型
+ * @param {number} file_mtime 文件修改时间戳
+ * @param {string} full_path 完整文件路径（用于文件监听）
+ */
+Static.prototype._setCache = async function (path, content, mime_type, file_mtime, full_path) {
+  if (!this._cache) return;
+
+  // 生成包含配置信息和内容哈希的缓存键
+  let cache_key = this._generateCacheKey(path);
+
+  let data = {
+    content: content,
+    mime_type: mime_type,
+    timestamp: Date.now(),
+    file_mtime: file_mtime || Date.now() // 如果没有提供文件修改时间，使用当前时间
+  };
+
+  // 统一设置缓存数据
+  await this._cache.set(cache_key, data, this.config.cache_age);
+
+  // 如果启用文件监听，添加文件监听器
+  if (full_path) {
+    this._addFileWatcher(full_path, cache_key);
+  }
+};
+
+/**
+ * 生成包含配置信息和文件内容哈希的缓存键
+ * @param {string} path 文件路径
+ * @returns {string} 缓存键
+ */
+Static.prototype._generateCacheKey = function (path) {
+  // 纯路径标识：使用配置和路径作为缓存键
+  let config_prefix = `${this.config.convert_amd ? 'amd' : 'noamd'}_${this.config.files.join('-')}_${this.config.path.replace(/[^a-zA-Z0-9]/g, '_')}`;
+
+  // 直接使用路径作为唯一标识，不依赖文件内容
+  return this.config.key_prefix + config_prefix + ':' + path.replace(/[^a-zA-Z0-9]/g, '_');
+};
+
+/**
+ * 初始化基础配置
+ * @param {object} config 配置
+ */
+Static.prototype.setConfig = function (config) {
+  if (config) {
+    Object.assign(this.config, config);
+  }
+  if (this.config.extensions && this.config.extensions.length === 0) {
+    this.config.extensions = false;
+  }
+};
+
+/**
+ * 执行静态文件处理 (统一处理流程)
+ * @param {object} ctx http请求上下文
+ * @param {Function} next 跳过当前执行，先执行后面函数
+ * @returns {boolean} 是否执行成功
+ */
+Static.prototype.main = async function (ctx, next) {
+  await next();
+  if (!this._shouldProcess(ctx)) return;
+
+  // 统一使用_send方法处理所有文件，避免重复转换逻辑
+  await this._send(ctx, ctx.path);
+};
+
+/**
+ * 判断是否需要处理请求
+ * @param {object} ctx 上下文
+ * @returns {boolean} 是否需要处理
+ */
+Static.prototype._shouldProcess = function (ctx) {
+  if (ctx.method !== 'HEAD' && ctx.method !== 'GET') return false;
+  if (ctx.body != null || ctx.status !== 404) return false;
+  return true;
+};
+
+/**
+ * 判断是否需要转换ES6到AMD
+ * @param {string} path 文件路径
+ * @returns {boolean} 是否需要转换
+ */
+Static.prototype._convertible = function (path) {
+  let files = this.config.files;
+  let len = files.length;
+  for (let i = 0; i < len; i++) {
+    if (path.endsWith(files[i])) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * 判断是否在指定路径下
+ * @param {string} path 文件路径
+ * @returns {boolean} 是否在指定路径下
+ */
+Static.prototype._inTargetPath = function (path) {
+  return path.startsWith(this.config.path);
+};
+
+/**
+ * 从Vue文件中提取JavaScript代码
+ * @param {string} vue_content Vue文件内容
+ * @returns {string|null} 提取的JavaScript代码
+ */
+Static.prototype._extractJsFromVue = function (vue_content) {
+  // 匹配<script>标签内的内容
+  let script_match = vue_content.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  if (!script_match || !script_match[1]) return null;
+
+  let script_content = script_match[1].trim();
+
+  // 如果包含export default，提取组件定义
+  if (script_content.includes('export default')) {
+    // 提取export default后面的内容
+    let export_match = script_content.match(/export default\s*({[\s\S]*})/);
+    if (export_match && export_match[1]) {
+      // 将Vue组件转换为AMD模块
+      return `define([], function() {\n  return ${export_match[1]};\n});`;
+    }
+  }
+
+  return script_content;
+};
+
+/**
+ * 检查文件是否需要转换
+ * @param {string} file_path 文件路径
+ * @returns {boolean} 是否需要转换
+ */
+Static.prototype._shouldConvert = function (file_path) {
+  // 检查是否启用AMD转换或Vue编译
+  if (!this.config.convert_amd && !this.config.compile_vue) {
+    return false;
+  }
+
+  // 然后检查文件扩展名是否在配置列表中
+  let files = this.config.files;
+  let len = files.length;
+  for (let i = 0; i < len; i++) {
+    if (file_path.endsWith(files[i])) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * 处理Vue文件转换
+ * @param {string} vue_content Vue文件内容
+ * @returns {string} 转换后的代码
+ */
+Static.prototype._handleVueFile = function (vue_content) {
+  // 快速检查是否需要处理
+  if (!this.config.convert_amd && !this.config.compile_vue) {
+    return vue_content;
+  }
+
+  // 使用更高效的正则表达式匹配<script>标签
+  let script_start = vue_content.indexOf('<script');
+  if (script_start === -1) return vue_content;
+
+  let script_end = vue_content.indexOf('</script>', script_start);
+  if (script_end === -1) return vue_content;
+
+  // 提取script标签开始和结束位置
+  let tag_start = vue_content.indexOf('>', script_start) + 1;
+  let script_content = vue_content.substring(tag_start, script_end).trim();
+
+  if (!script_content) return vue_content;
+
+  let conv_script;
+
+  // 根据配置选择不同的转换方式
+  if (this.config.convert_amd) {
+    // 使用完整的AMD转换器处理script内容
+    conv_script = this.convert.toAmd(script_content);
+  } else if (this.config.compile_vue) {
+    // 转换为可直接使用的Vue组件
+    conv_script = this._convertToDirectVueComponent(script_content, vue_content);
+  } else {
+    // 保持原样
+    conv_script = script_content;
+  }
+
+  // 当compile_vue为true时，直接返回转换后的JavaScript代码
+  if (this.config.compile_vue && !this.config.convert_amd) {
+    return conv_script;
+  }
+
+  // 直接替换script内容，避免复杂的正则表达式
+  return vue_content.substring(0, tag_start) +
+    '\n' + conv_script + '\n' +
+    vue_content.substring(script_end);
+};
+
+/**
+ * 将Vue文件转换为可直接使用的组件
+ * @param {string} script_content script标签内容
+ * @param {string} vue_content 完整的Vue文件内容
+ * @returns {string} 可直接使用的Vue组件代码
+ */
+Static.prototype._convertToDirectVueComponent = function (script_content, vue_content) {
+  if (!this._shouldParseVue(vue_content)) {
+    return script_content;
+  }
+
+  try {
+    const desc = this._parseVueDescriptor(vue_content);
+    const script_parsed = desc.script ? desc.script.content.trim() : script_content;
+    const name = this._extractComponentName(script_parsed);
+    const opts = this._cleanScriptContent(script_parsed);
+
+    return this._buildVueComponentCode(name, opts, desc);
+  } catch (error) {
+    // Vue文件解析失败，使用回退方案
+    return this._fallbackVueConversion(script_content, vue_content);
+  }
+};
+
+/**
+ * 检查是否需要解析Vue文件
+ * @param {string} vue_content Vue文件内容
+ * @returns {boolean} 是否需要解析
+ */
+Static.prototype._shouldParseVue = function (vue_content) {
+  if (!this.config.compile_vue) {
+    return false;
+  }
+  return vue_content.includes('<template') || vue_content.includes('<script');
+};
+
+/**
+ * 解析Vue文件描述符
+ * @param {string} vue_content Vue文件内容
+ * @returns {object} Vue描述符
+ */
+Static.prototype._parseVueDescriptor = function (vue_content) {
+  const { descriptor, errors } = parse(vue_content);
+
+  if (errors && errors.length > 0) {
+    // Vue文件解析错误
+    throw new Error('Vue解析错误');
+  }
+
+  return descriptor;
+};
+
+/**
+ * 提取组件名称
+ * @param {string} script_content 脚本内容
+ * @returns {string} 组件名称
+ */
+Static.prototype._extractComponentName = function (script_content) {
+  const name_match = script_content.match(/name:\s*['"]([^'"]+)['"]/);
+  return name_match && name_match[1] ? name_match[1] : 'VueComponent';
+};
+
+/**
+ * 清理脚本内容
+ * @param {string} script_content 脚本内容
+ * @returns {string} 清理后的脚本
+ */
+Static.prototype._cleanScriptContent = function (script_content) {
+  let cleaned = script_content;
+
+  if (cleaned.includes('import ') || cleaned.includes('export default')) {
+    cleaned = cleaned
+      .replace(/^\s*import\s+.*?\s+from\s+['"].*?['"];?\s*$/gm, '')
+      .replace(/^\s*export\s+default\s*/, '')
+      .trim();
+  }
+
+  if (cleaned.includes('ref(') || cleaned.includes('computed(')) {
+    cleaned = cleaned
+      .replace(/\bconst\s+(\w+)\s*=\s*ref\(/g, 'var $1 = Vue.ref(')
+      .replace(/\bconst\s+(\w+)\s*=\s*computed\(/g, 'var $1 = Vue.computed(')
+      .replace(/\bref\(/g, 'Vue.ref(')
+      .replace(/\bcomputed\(/g, 'Vue.computed(')
+      .replace(/Vue\.Vue\./g, 'Vue.');
+  }
+
+  return cleaned;
+};
+
+/**
+ * 构建Vue组件代码
+ * @param {string} name 组件名称
+ * @param {string} opts 组件选项
+ * @param {object} desc Vue描述符
+ * @returns {string} 生成的组件代码
+ */
+Static.prototype._buildVueComponentCode = function (name, opts, desc) {
+  const template_content = desc.template ? desc.template.content.trim() : '';
+  const has_styles = desc.styles && desc.styles.length > 0;
+  const styles_content = has_styles ? desc.styles.map(style => style.content.trim()).join('\n') : '';
+
+  const parts = this._buildVueComponentHeader(name, opts, template_content, styles_content);
+
+  this._addStyleCode(parts, has_styles);
+  this._addVueVersionCode(parts);
+  this._addComponentRegistration(parts, name);
+  this._addComponentExport(parts, name);
+
+  parts.push('  return options;\n', '})();\n');
+
+  return parts.join('');
+};
+
+/**
+ * 添加样式代码
+ * @param {Array} parts 代码部分数组
+ * @param {boolean} has_styles 是否有样式
+ */
+Static.prototype._addStyleCode = function (parts, has_styles) {
+  if (has_styles) {
+    parts.push(
+      '  if (style) {\n',
+      '    // 创建样式元素并添加到文档\n',
+      '    if (typeof document !== \'undefined\') {\n',
+      '      var styleElement = document.createElement(\'style\');\n',
+      '      styleElement.textContent = style;\n',
+      '      document.head.appendChild(styleElement);\n',
+      '    }\n',
+      '  }\n',
+      '  \n'
+    );
+  }
+};
+
+/**
+ * 添加Vue版本适配代码
+ * @param {Array} parts 代码部分数组
+ */
+Static.prototype._addVueVersionCode = function (parts) {
+  parts.push(
+    '  // 如果是Vue 3，使用defineComponent\n',
+    '  if (typeof Vue !== \'undefined\' && Vue.version && Vue.version.startsWith(\'3\')) {\n',
+    '    if (typeof Vue.defineComponent === \'function\') {\n',
+    '      options = Vue.defineComponent(options);\n',
+    '    }\n',
+    '  }\n',
+    '  \n'
+  );
+};
+
+/**
+ * 添加组件注册代码
+ * @param {Array} parts 代码部分数组
+ * @param {string} name 组件名称
+ */
+Static.prototype._addComponentRegistration = function (parts, name) {
+  parts.push(
+    '  // 注册组件\n',
+    '  if (typeof Vue !== \'undefined\') {\n',
+    '    if (typeof Vue.component === \'function\') {\n',
+    '      Vue.component(\'', name, '\', options);\n',
+    '    }\n',
+    '  }\n',
+    '  \n'
+  );
+};
+
+/**
+ * 添加组件导出代码
+ * @param {Array} parts 代码部分数组
+ * @param {string} name 组件名称
+ */
+Static.prototype._addComponentExport = function (parts, name) {
+  parts.push(
+    '  // 导出组件（仅CommonJS和全局变量）\n',
+    '  if (typeof module !== \'undefined\' && module.exports) {\n',
+    '    module.exports = options;\n',
+    '  }\n',
+    '  \n',
+    '  if (typeof window !== \'undefined\') {\n',
+    '    window.', name, ' = options;\n',
+    '  }\n',
+    '  \n'
+  );
+};
+
+/**
+ * 构建Vue组件头部代码
+ * @param {string} name 组件名称
+ * @param {string} opts 组件选项
+ * @param {string} template_content 模板内容
+ * @param {string} styles_content 样式内容
+ * @returns {Array} 代码部分数组
+ */
+Static.prototype._buildVueComponentHeader = function (
+  name, opts, template_content, styles_content
+) {
+  return [
+    '// Vue组件: ', name, ' (使用@vue/compiler-sfc解析)\n',
+    '(function() {\n',
+    '  var template = \`', template_content, '\`;\n',
+    '  var style = \`', styles_content, '\`;\n',
+    '  \n',
+    '  // 组件选项\n',
+    '  var options = ', opts, ';\n',
+    '  \n',
+    '  // 添加template\n',
+    '  if (template) {\n',
+    '    options.template = template;\n',
+    '  }\n',
+    '  \n',
+    '  // 添加样式（如果存在）\n'
+  ];
+};
+
+/**
+ * Vue文件解析失败时的回退转换方案
+ * @param {string} script_content script标签内容
+ * @param {string} vue_content 完整的Vue文件内容
+ * @returns {string} 可直接使用的Vue组件代码
+ */
+Static.prototype._fallbackVueConversion = function (script_content, vue_content) {
+  const template_content = this._extractTemplateContent(vue_content);
+  const style_content = this._extractStyleContent(vue_content);
+  const name = this._extractComponentName(script_content);
+  const clean_opts = this._simplifyComponentOptions(script_content);
+
+  return this._buildFallbackVueCode(name, clean_opts, template_content, style_content);
+};
+
+/**
+ * 提取模板内容
+ * @param {string} vue_content Vue文件内容
+ * @returns {string} 模板内容
+ */
+Static.prototype._extractTemplateContent = function (vue_content) {
+  if (!vue_content.includes('<template>')) {
+    return '';
+  }
+
+  const template_start = vue_content.indexOf('<template>');
+  const template_end = vue_content.indexOf('</template>', template_start);
+
+  if (template_start !== -1 && template_end !== -1) {
+    return vue_content.substring(template_start + 10, template_end).trim();
+  }
+
+  return '';
+};
+
+/**
+ * 提取样式内容
+ * @param {string} vue_content Vue文件内容
+ * @returns {string} 样式内容
+ */
+Static.prototype._extractStyleContent = function (vue_content) {
+  if (!vue_content.includes('<style')) {
+    return '';
+  }
+
+  const style_start = vue_content.indexOf('<style');
+  const style_end = vue_content.indexOf('</style>', style_start);
+
+  if (style_start !== -1 && style_end !== -1) {
+    return vue_content.substring(vue_content.indexOf('>', style_start) + 1, style_end).trim();
+  }
+
+  return '';
+};
+
+/**
+ * 简化组件选项
+ * @param {string} script_content 脚本内容
+ * @returns {string} 简化后的选项
+ */
+Static.prototype._simplifyComponentOptions = function (script_content) {
+  let clean_opts = script_content
+    .replace(/^\s*import\s+.*?from\s+['"].*?['"];?\s*$/gm, '')
+    .trim();
+
+  if (clean_opts.includes('export default')) {
+    clean_opts = clean_opts.replace(/^\s*export\s+default\s*/, '').trim();
+  }
+
+  return clean_opts
+    .replace(/setup\(\)\s*\{[\s\S]*?\}/, 'setup() { return {}; }')
+    .replace(/ref\([^)]*\)/g, '0')
+    .replace(/computed\([^)]*\)/g, 'function() { return 0; }')
+    .replace(/ChildComponent/g, 'null');
+};
+
+/**
+ * 构建回退方案Vue代码
+ * @param {string} name 组件名称
+ * @param {string} clean_opts 清理后的选项
+ * @param {string} template_content 模板内容
+ * @param {string} style_content 样式内容
+ * @returns {string} 生成的代码
+ */
+Static.prototype._buildFallbackVueCode = function (
+  name, clean_opts, template_content, style_content
+) {
+  const parts = this._buildFallbackHeader(name, clean_opts, template_content, style_content);
+
+  this._addFallbackStyleCode(parts, style_content);
+  this._addComponentRegistration(parts, name);
+  this._addComponentExport(parts, name);
+
+  parts.push('  return options;\n', '})();\n');
+
+  return parts.join('');
+};
+
+/**
+ * 构建回退方案头部代码
+ * @param {string} name 组件名称
+ * @param {string} clean_opts 清理后的选项
+ * @param {string} template_content 模板内容
+ * @param {string} style_content 样式内容
+ * @returns {Array} 代码部分数组
+ */
+Static.prototype._buildFallbackHeader = function (
+  name, clean_opts, template_content, style_content
+) {
+  return [
+    '// Vue组件: ', name, ' (回退方案)\n',
+    '(function() {\n',
+    '  var template = \`', template_content, '\`;\n',
+    '  var style = \`', style_content, '\`;\n',
+    '  \n',
+    '  // 组件选项\n',
+    '  var options = ', clean_opts, ';\n',
+    '  \n',
+    '  // 添加template\n',
+    '  if (template) {\n',
+    '    options.template = template;\n',
+    '  }\n',
+    '  \n'
+  ];
+};
+
+/**
+ * 添加回退方案样式代码
+ * @param {Array} parts 代码部分数组
+ * @param {string} style_content 样式内容
+ */
+Static.prototype._addFallbackStyleCode = function (parts, style_content) {
+  if (style_content) {
+    parts.push(
+      '  // 添加样式（如果存在）\n',
+      '  if (style) {\n',
+      '    // 创建样式元素并添加到文档\n',
+      '    if (typeof document !== \'undefined\') {\n',
+      '      var styleElement = document.createElement(\'style\');\n',
+      '      styleElement.textContent = style;\n',
+      '      document.head.appendChild(styleElement);\n',
+      '    }\n',
+      '  }\n',
+      '  \n'
+    );
+  }
+};
+
+/**
+ * 处理HTML文件，转换其中的script标签
+ * @param {string} html_content HTML文件内容
+ * @returns {string} 转换后的HTML文件
+ */
+Static.prototype._handleHtmlFile = function (html_content) {
+  // 快速检查是否需要处理
+  if (!this.config.convert_amd && !this.config.compile_vue) {
+    return html_content;
+  }
+
+  // 使用更高效的正则表达式匹配<script>标签
+  let script_regex = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+  let conv_html = html_content;
+  let match;
+
+  while ((match = script_regex.exec(html_content)) !== null) {
+    let script_content = match[1].trim();
+
+    // 跳过空内容和已转换的内容
+    if (!script_content || script_content.includes('define(')) {
+      continue;
+    }
+
+    // 转换script内容
+    let conv_script = this.convert.toAmd(script_content);
+
+    // 直接替换，避免多次字符串操作
+    conv_html = conv_html.replace(match[0], `<script>\n${conv_script}\n</script>`);
+  }
+
+  return conv_html;
+};
+
+
+
+/**
+ * 获取MIME类型
+ * @param {string} path 文件路径
+ * @returns {string} MIME类型
+ */
+Static.prototype._getMimeType = function (path) {
+  if (path.endsWith('.js')) {
+    return 'application/javascript; charset=utf-8';
+  } else if (path.endsWith('.css')) {
+    return 'text/css; charset=utf-8';
+  } else if (path.endsWith('.html')) {
+    return 'text/html; charset=utf-8';
+  } else if (path.endsWith('.vue')) {
+    return 'application/javascript; charset=utf-8';
+  } else {
+    return 'text/plain; charset=utf-8';
+  }
+};
+
+/**
+ * 设置响应头
+ * @param {object} ctx 上下文
+ * @param {string} path 文件路径
+ */
+Static.prototype._setHeaders = function (ctx, path) {
+  if (!ctx.response.type) {
+    ctx.response.type = this._getMimeType(path);
+  }
+
+  if (this.config.max_age) {
+    let cache_control = 'max-age=' + this.config.max_age;
+    if (this.config.immutable) {
+      cache_control += ',immutable';
+    }
+    ctx.set('Cache-Control', cache_control);
+  }
+};
+
+/**
+ * 发送静态文件
+ * @param {object} ctx 上下文
+ * @param {string} file_path 文件路径
+ */
+/**
+ * 发送二进制文件
+ * @param {object} ctx 请求上下文
+ * @param {string} file_path 文件路径
+ */
+Static.prototype._sendBinaryFile = async function (ctx, file_path) {
+  // 处理二进制文件
+  await send(ctx, file_path, {
+    root: this.config.root,
+    maxage: this.config.max_age,
+    immutable: this.config.immutable,
+    hidden: this.config.hidden,
+    format: this.config.format,
+    extensions: this.config.extensions,
+    brotli: this.config.brotli,
+    gzip: this.config.gzip
+  });
+};
+
+/**
+ * 从缓存发送文件内容
+ * @param {object} ctx 请求上下文
+ * @param {string} file_path 文件路径
+ * @param {object} data 缓存数据
+ */
+Static.prototype._sendFromCache = function (ctx, file_path, data) {
+  // 使用缓存内容
+  ctx.response.type = data.mime_type;
+  ctx.body = data.content;
+  this._setHeaders(ctx, file_path);
+};
+
+/**
+ * 发送新文件内容并缓存
+ * @param {object} ctx 请求上下文
+ * @param {string} file_path 文件路径
+ * @param {string} full_path 完整文件路径
+ */
+Static.prototype._sendNewContent = async function (ctx, file_path, full_path) {
+  let original_content = full_path.loadText();
+  let mime_type = this._getMimeType(file_path);
+
+  // 检查是否需要转换
+  let final_content = original_content;
+  if (this._shouldConvert(file_path)) {
+    if (file_path.endsWith('.vue')) {
+      final_content = this._handleVueFile(original_content);
+    } else if (file_path.endsWith('.html')) {
+      final_content = this._handleHtmlFile(original_content);
+    } else if (this.config.convert_amd) {
+      // 只有启用AMD转换时才转换JS文件
+      final_content = this.convert.toAmd(original_content);
+    }
+    // 如果convert_amd为false但compile_vue为true，JS文件保持原样
+  }
+
+  // 获取文件修改时间戳
+   let file_mtime = this._getFileMtime(full_path);
+   
+   // 缓存转换后的内容（包含文件修改时间戳和文件监听）
+   await this._setCache(file_path, final_content, mime_type, file_mtime, full_path);
+
+  ctx.response.type = mime_type;
+  ctx.body = final_content;
+  this._setHeaders(ctx, file_path);
+};
+
+Static.prototype._send = async function (ctx, file_path) {
+  try {
+    let relative_path = file_path.startsWith('/') ? file_path.substring(1) : file_path;
+    let full_path = relative_path.fullname(this.config.root);
+
+    if (!full_path.hasFile()) {
+      ctx.status = 404;
+      return;
+    }
+
+    let is_text = this.isTextFile(file_path);
+
+    if (!is_text) {
+      await this._sendBinaryFile(ctx, file_path);
+      return;
+    }
+
+    // 先检查基于路径的缓存（不读取文件内容）
+    let data = await this._getCache(file_path, full_path);
+    if (data) {
+      this._sendFromCache(ctx, file_path, data);
+      return;
+    }
+
+    // 处理新内容并设置缓存
+    await this._sendNewContent(ctx, file_path, full_path);
+  } catch (error) {
+    ctx.status = 500;
+    ctx.body = 'Internal Server Error: ' + error.message;
+  }
+};
+
+/**
+ * 获取文本文件扩展名列表
+ * @returns {Array<string>} 文本文件扩展名数组
+ */
+Static.prototype._getTextExtensions = function () {
+  return [
+    // 代码文件
+    '.js', '.jsx', '.ts', '.tsx', '.vue', '.html', '.htm', '.css', '.scss', '.less',
+    '.json', '.xml', '.yaml', '.yml', '.md', '.markdown',
+
+    // 配置文件
+    '.config', '.conf', '.ini', '.properties', '.env', '.gitignore',
+
+    // 脚本文件
+    '.sh', '.bash', '.zsh', '.ps1', '.bat', '.cmd',
+
+    // 模板文件
+    '.ejs', '.pug', '.jade', '.handlebars', '.hbs',
+
+    // 数据文件
+    '.csv', '.txt', '.log', '.sql', '.graphql',
+
+    // 其他文本格式
+    '.rtf', '.tex', '.rst', '.adoc'
+  ];
+};
+
+/**
+ * 通过扩展名判断是否为文本文件
+ * @param {string} file_path 文件路径
+ * @returns {boolean} 是否为文本文件
+ */
+Static.prototype._isTextByExtension = function (file_path) {
+  let lower_path = file_path.toLowerCase();
+  let text_exts = this._getTextExtensions();
+  return text_exts.some(ext => lower_path.endsWith(ext));
+};
+
+/**
+ * 通过文件内容判断是否为文本文件
+ * @param {string} file_path 文件路径
+ * @returns {boolean} 是否为文本文件
+ */
+Static.prototype._isTextByContent = function (file_path) {
+  try {
+    let fs = require('fs');
+    if (!fs.existsSync(file_path)) return false;
+
+    let stats = fs.statSync(file_path);
+    if (!stats.isFile()) return false;
+
+    let fd = fs.openSync(file_path, 'r');
+    let buffer = Buffer.alloc(512);
+    let bytes_read = fs.readSync(fd, buffer, 0, 512, 0);
+    fs.closeSync(fd);
+
+    let count = 0;
+    for (let i = 0; i < bytes_read; i++) {
+      if ((buffer[i] >= 32 && buffer[i] <= 126) ||
+        buffer[i] === 9 || buffer[i] === 10 || buffer[i] === 13) {
+        count++;
+      }
+    }
+
+    return (count / bytes_read) > 0.9;
+  } catch (error) {
+    return false;
+  }
+};
+
+Static.prototype.isTextFile = function (file_path) {
+  let is_text_by_content = this._isTextByContent(file_path);
+  let is_text_by_ext = this._isTextByExtension(file_path);
+
+  return is_text_by_content || is_text_by_ext;
+};
+
+/**
+ * 获取二进制文件扩展名列表
+ * @returns {Array<string>} 二进制文件扩展名数组
+ */
+Static.prototype._getBinaryExtensions = function () {
+  return [
+    // 图片文件
+    '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.ico', '.svg',
+    '.tiff', '.tif', '.psd', '.ai', '.eps', '.raw',
+
+    // 视频文件
+    '.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm', '.mkv', '.m4v',
+    '.3gp', '.mpeg', '.mpg', '.ts', '.m2ts',
+
+    // 音频文件
+    '.mp3', '.wav', '.ogg', '.aac', '.flac', '.wma', '.m4a', '.ape',
+
+    // 字体文件
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+
+    // 文档和压缩文件
+    '.pdf', '.zip', '.rar', '.7z', '.tar', '.gz', '.bz2', '.xz',
+    '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+
+    // 可执行文件和安装包
+    '.exe', '.dll', '.so', '.dmg', '.msi', '.deb', '.rpm', '.apk',
+
+    // 数据文件
+    '.db', '.sqlite', '.dat', '.bin', '.iso', '.img'
+  ];
+};
+
+/**
+ * 通过扩展名判断是否为二进制文件
+ * @param {string} file_path 文件路径
+ * @returns {boolean} 是否为二进制文件
+ */
+Static.prototype._isBinaryByExtension = function (file_path) {
+  let lower_path = file_path.toLowerCase();
+  let binary_exts = this._getBinaryExtensions();
+  return binary_exts.some(ext => lower_path.endsWith(ext));
+};
+
+/**
+ * 通过文件内容判断是否为二进制文件
+ * @param {string} file_path 文件路径
+ * @returns {boolean} 是否为二进制文件
+ */
+Static.prototype._isBinaryByContent = function (file_path) {
+  try {
+    let fs = require('fs');
+    if (!fs.existsSync(file_path)) return false;
+
+    let stats = fs.statSync(file_path);
+    if (!stats.isFile()) return false;
+
+    let fd = fs.openSync(file_path, 'r');
+    let buffer = Buffer.alloc(512);
+    let bytes_read = fs.readSync(fd, buffer, 0, 512, 0);
+    fs.closeSync(fd);
+
+    let has_binary_chars = false;
+    for (let i = 0; i < bytes_read; i++) {
+      if (buffer[i] === 0 ||
+        (buffer[i] < 32 && buffer[i] !== 9 && buffer[i] !== 10 && buffer[i] !== 13)) {
+        has_binary_chars = true;
+        break;
+      }
+    }
+
+    return has_binary_chars;
+  } catch (error) {
+    return false;
+  }
+};
+
+Static.prototype.isBinaryFile = function (file_path) {
+  if (this.isTextFile(file_path)) {
+    return false;
+  }
+
+  let is_binary_by_content = this._isBinaryByContent(file_path);
+  let is_binary_by_ext = this._isBinaryByExtension(file_path);
+
+  return is_binary_by_content || is_binary_by_ext;
+};
+
+/**
+ * 执行静态文件处理
+ * @param {object} ctx http请求上下文
+ * @param {Function} next 跳过当前执行，先执行后面函数
+ * @returns {boolean} 是否执行成功
+ */
+Static.prototype.run = async function (ctx, next) {
+  await next();
+  if (!this._shouldProcess(ctx)) return;
+
+  // 直接使用koa-send处理路径映射
+  await this._send(ctx, ctx.path);
+};
+
+// 导出Static类用于测试
+module.exports = {
+  Static,
+  static(config) {
+    let instance = new Static(config);
+    return async function (ctx, next) {
+      await instance.main(ctx, next);
+    };
+  }
 };