mm_statics 1.5.4 → 1.5.5

package/index.js

@@ -1,1229 +1,641 @@
-let send = require('koa-send');
-const { EsToAmdConvert } = require('mm_es6_to_amd');
-const { parse } = require('@vue/compiler-sfc');
-
-// 初始化mm_expand模块
-require('mm_expand');
-
-// 确保$对象已初始化
-if (!global.$) {
-  throw new Error('mm_expand模块初始化失败，$对象不存在');
-}
-
-/**
- * 静态文件处理类
- */
-class Static {
-  static config = {
-    index: 'index.html',
-    // 前端缓存时间，单位秒
-    max_age: 7200,
-    // 缓存键前缀
-    key_prefix: 'static:',
-    // 是否开启缓存
-    cache: true,
-    // 后端缓存时间，单位秒
-    cache_age: 7200,
-    // 是否开启immutable缓存头
-    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,
-    // 是否检查文件修改时间（当watch_files为false时生效）
-    check_file_mtime: false
-  };
-
-  /**
-   * 初始化静态文件处理类
-   * @param {object} config 配置
-   */
-  constructor(config) {
-    this.config = { ...Static.config };
-    this.convert = new EsToAmdConvert();
-    this._cache = null;
-    this._cache_config_prefix = this._generateConfigPrefix(); // 初始化配置前缀
-    this._cache_headers = this._generateCacheHeaders(); // 初始化缓存头
-    this.setConfig(config);
-    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');
-    } catch (error) {
-      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) => {
-      // 文件修改时清除缓存
-      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);
-
-  // 统一获取缓存数据 - 缓存模块会自动处理TTL过期
-  let data = await this._cache.get(cache_key);
-
-  if (!data) return null;
-
-  // 仅在未启用文件监听且需要检查文件修改时进行检查
-  // 减少文件系统操作，提高性能
-  if (!this.config.watch_files && this.config.check_file_mtime && 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 stats = file_path.stat();
-    return stats ? stats.mtime.getTime() : null;
-  } 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() // 如果没有提供文件修改时间，使用当前时间
-  };
-
-  // 统一设置缓存数据 - 充分利用缓存模块的TTL机制
-  // 缓存模块会自动处理过期，无需手动检查时间戳
-  await this._cache.set(cache_key, data, this.config.cache_age);
-
-  // 如果启用文件监听，添加文件监听器
-  if (full_path) {
-    this._addFileWatcher(full_path, cache_key);
-  }
-};
-
-/**
- * 生成配置前缀
- * @returns {string} 配置前缀
- */
-Static.prototype._generateConfigPrefix = function () {
-  return `${this.config.convert_amd ? 'amd' : 'noamd'}_${this.config.files.join('-')}_${this.config.path.replace(/[^a-zA-Z0-9]/g, '_')}`;
-};
-
-/**
- * 生成缓存头信息
- * @returns {object} 缓存头对象
- */
-Static.prototype._generateCacheHeaders = function () {
-  let headers = {};
-  
-  if (this.config.max_age) {
-    let cache_control = 'max-age=' + this.config.max_age;
-    if (this.config.immutable) {
-      cache_control += ',immutable';
-    }
-    headers['Cache-Control'] = cache_control;
-  }
-  
-  return headers;
-};
-
-/**
- * 生成包含配置信息和文件内容哈希的缓存键
- * @param {string} path 文件路径
- * @returns {string} 缓存键
- */
-Static.prototype._generateCacheKey = function (path) {
-  // 直接使用缓存的配置前缀
-  return this.config.key_prefix + this._cache_config_prefix + ':' + path.replace(/[^a-zA-Z0-9]/g, '_');
-};
-
-/**
- * 初始化基础配置
- * @param {object} config 配置
- */
-Static.prototype.setConfig = function (config) {
-  if (config) {
-    Object.assign(this.config, config);
-    // 配置改变时，立即重新计算缓存配置前缀和缓存头
-    this._cache_config_prefix = this._generateConfigPrefix();
-    this._cache_headers = this._generateCacheHeaders();
-  }
-  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) {
-  let { 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 文件路径
- */
-Static.prototype._sendBinaryFile = async function (ctx, file_path) {
-  // 处理二进制文件 - 使用koa-send优化大文件传输
-  let relative_path = file_path.startsWith('/') ? file_path.substring(1) : file_path;
-  
-  // 使用koa-send发送文件，支持流式传输、断点续传等优化
-  await send(ctx, relative_path, {
-    root: this.config.root,
-    maxage: this.config.max_age || 7200000, // 2小时缓存
-    immutable: this.config.immutable || false
-  });
-};
-
-/**
- * 从缓存发送文件内容
- * @param {object} ctx 请求上下文
- * @param {string} file_path 文件路径
- * @param {object} data 缓存数据
- */
-Static.prototype._sendFromCache = function (ctx, file_path, data) {
-  // 使用缓存内容
-  ctx.status = 200;
-  ctx.type = data.mime_type;
-  ctx.body = data.content;
-  
-  // 设置缓存头
-  let headers = this._getCacheHeaders();
-  for (let k in headers) {
-    ctx.set(k, headers[k]);
-  }
-};
-
-/**
- * 发送新文件内容并缓存
- * @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();
-  
-  // 检查文件内容是否成功加载
-  if (original_content === undefined) {
-    ctx.status = 404;
-    return;
-  }
-  
-  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.status = 200;
-  ctx.type = mime_type;
-  ctx.body = final_content;
-  
-  // 设置缓存头
-  let headers = this._getCacheHeaders();
-  for (let k in headers) {
-    ctx.set(k, headers[k]);
-  }
-};
-
-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.isFile()) {
-      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 {
-    if (!file_path.hasFile()) return false;
-
-    let stats = file_path.stat();
-    if (!stats || !stats.isFile()) return false;
-
-    let content = file_path.loadText('binary');
-    if (!content) return false;
-
-    let buffer = Buffer.from(content, 'binary');
-    let bytes_read = Math.min(buffer.length, 512);
-
-    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 {
-    if (!file_path.hasFile()) return false;
-
-    let stats = file_path.stat();
-    if (!stats || !stats.isFile()) return false;
-
-    let content = file_path.loadText('binary');
-    if (!content) return false;
-
-    let buffer = Buffer.from(content, 'binary');
-    let bytes_read = Math.min(buffer.length, 512);
-
-    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;
-};
-
-/**
- * 获取缓存头信息
- * @returns {object} 缓存头对象
- */
-Static.prototype._getCacheHeaders = function () {
-  // 直接使用缓存的头对象
-  return this._cache_headers;
-};
-
-/**
- * 读取二进制文件
- * @param {string} file_path 文件路径
- * @returns {Buffer} 文件内容
- */
-Static.prototype._readBinaryFile = async function (file_path) {
-  let relative_path = file_path.startsWith('/') ? file_path.substring(1) : file_path;
-  let full_path = relative_path.fullname(this.config.root);
-  
-  if (full_path.isFile() && full_path.hasFile()) {
-    return full_path.loadText('binary');
-  }
-  
-  return null;
-};
-
-/**
- * 执行静态文件处理
- * @param {object} ctx http请求上下文
- * @param {Function} next 跳过当前执行，先执行后面函数
- * @returns {boolean} 是否执行成功
- */
-Static.prototype.run = async function (ctx, next) {
-  await next();
-  if (!this._shouldProcess(ctx)) return;
-
-  // 处理静态文件请求
-  let result = await this._send(ctx.path);
-  
-  // 设置响应状态和内容
-  ctx.status = result.status;
-  if (result.type) ctx.type = result.type;
-  if (result.body) ctx.body = result.body;
-  if (result.headers) {
-    for (let key in result.headers) {
-      ctx.set(key, result.headers[key]);
-    }
-  }
-};
-
-// 导出Static类用于测试
-module.exports = {
-  Static,
-  static(config) {
-    let instance = new Static(config);
-    return async function (ctx, next) {
-      await instance.main(ctx, next);
-    };
-  }
-};
+let send = require('koa-send');
+const { EsToAmdConvert } = require('mm_es6_to_amd');
+const { parse } = require('@vue/compiler-sfc');
+const { compile } = require('@vue/compiler-dom');
+const prettier = require('prettier');
+
+/**
+ * 静态文件处理类
+ */
+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',
+    compile_vue: true,
+    path: '/src',
+    files: ['.js', '.vue', '.html'],
+    convert_amd: true,
+    watch: false,
+    watch_files: ['.js', '.css', '.html', '.vue', '.json', '.md', '.txt', '.xml']
+  };
+
+  /**
+   * 初始化静态文件处理类
+   * @param {object} config 配置
+   */
+  constructor(config) {
+    this.config = { ...Static.config };
+    this.convert = new EsToAmdConvert();
+    this._cache = null;
+    this._watcher = null;
+    this.setConfig(config);
+    this._init();
+  }
+}
+
+/**
+ * 设置配置
+ * @param {object} config 配置
+ */
+Static.prototype.setConfig = function (config) {
+  Object.assign(this.config, config || {});
+};
+
+/**
+ * 初始化缓存
+ */
+Static.prototype._init = function () {
+  if (!$.cache) {
+    const { cacheAdmin } = require('mm_cache');
+    $.cache = cacheAdmin('sys', this.config);
+  }
+  this._cache = $.cache;
+
+  // 如果配置了文件监听，初始化文件监听器
+  if (this.config.watch && this.config.watch_files.length > 0) {
+    this._initWatcher();
+  }
+};
+
+/**
+ * 检测代码是否包含ES6语法
+ * @param {string} code 代码内容
+ * @returns {boolean} 是否包含ES6语法
+ */
+Static.prototype._isEs6Code = function (code) {
+  if (!code || typeof code !== 'string') {
+    return false;
+  }
+  
+  // ES6语法特征检测
+  const es6_patterns = [
+    /\bimport\s+[^;]+;/g,           // import语句
+    /\bexport\s+[^;]+;/g,           // export语句
+    /\bclass\s+\w+/g,               // class声明
+    /\bconst\s+\w+/g,               // const声明
+    /\blet\s+\w+/g,                 // let声明
+    /\([^)]*\)\s*=>/g,             // 箭头函数
+    /`[^`]*`/g,                     // 模板字符串
+    /\{[^}]*\}\s*=\s*\w+/g,        // 解构赋值
+    /\bPromise\b/g,                 // Promise对象
+    /\basync\s+function\b/g,        // async函数
+    /\bawait\b/g                    // await关键字
+  ];
+  
+  for (let i = 0; i < es6_patterns.length; i++) {
+    if (es6_patterns[i].test(code)) {
+      return true;
+    }
+  }
+  
+  return false;
+};
+
+/**
+ * 格式化代码
+ * @param {string} code 代码内容
+ * @param {string} file_type 文件类型
+ * @returns {Promise<string>} 格式化后的代码
+ */
+Static.prototype._formatCode = async function (code, file_type) {
+  if (!this.config.format || !code || typeof code !== 'string') {
+    return code;
+  }
+  
+  try {
+    // 根据文件类型设置prettier配置
+    let parser = 'babel';
+    let plugins = [];
+    
+    switch (file_type) {
+      case 'js':
+        parser = 'babel';
+        break;
+      case 'html':
+        parser = 'html';
+        break;
+      case 'vue':
+        parser = 'vue';
+        plugins = [require('prettier/parser-html'), require('prettier/parser-babel')];
+        break;
+      default:
+        parser = 'babel';
+    }
+    
+    // prettier.format是异步函数
+    const formatted_code = await prettier.format(code, {
+      parser: parser,
+      plugins: plugins,
+      semi: true,
+      singleQuote: true,
+      trailingComma: 'es5',
+      printWidth: 100,
+      tabWidth: 2,
+      useTabs: false,
+      bracketSpacing: true,
+      arrowParens: 'avoid'
+    });
+    
+    return formatted_code;
+  } catch (error) {
+    // 格式化失败时返回原代码
+    console.warn(`格式化代码失败: ${error.message}`);
+    return code;
+  }
+};
+
+/**
+ * 转换为AMD模块
+ * @param {string} file_type 文件类型
+ * @param {string} text 代码
+ * @returns {Promise<string>} AMD模块代码
+ */
+Static.prototype._toAmd = async function (file_type, text) {
+  let txt = text;
+  if (file_type === 'js') {
+    // 对JS文件，先检测是否为ES6代码，只有ES6代码才进行转换
+    if (this._isEs6Code(txt)) {
+      let code = this.convert.toAmd(txt);
+      // 格式化代码
+      return await this._formatCode(code, file_type);
+    } else {
+      // 格式化非ES6代码
+      return await this._formatCode(txt, file_type);
+    }
+  } else if (file_type === 'html' || file_type === 'vue') {
+    // 获取html或vue中script标签的代码，将ES6语法的代码转换为AMD模块
+    let match = txt.match(/<script[^>]*>([\s\S]*?)<\/script>/g);
+    if (match) {
+      for (let i = 0; i < match.length; i++) {
+        let script = match[i];
+        // 直接提取script标签内容，避免重复匹配
+        let inner_code = script.replace(/^<script[^>]*>([\s\S]*?)<\/script>$/, '$1').trim();
+        if (inner_code) {
+          // 先检测script标签内的代码是否为ES6语法
+          if (this._isEs6Code(inner_code)) {
+            let amd_code = this.convert.toAmd(inner_code);
+            // 移除type="module"属性，因为AMD模块不需要这个属性
+            let new_script = script.replace(/type\s*=\s*["']module["']/g, '').replace(inner_code, amd_code);
+            // 清理多余的空格
+            new_script = new_script.replace(/<script\s+>/, '<script>').replace(/<script\s+([^>]+)>/, '<script $1>');
+            txt = txt.replace(script, new_script);
+          }
+          // 如果不是ES6代码，保持原样不进行转换
+        }
+      }
+    }
+  }
+
+  // 格式化代码后返回
+  return await this._formatCode(txt, file_type);
+};
+
+/**
+ * 处理Vue模板部分
+ * @param {object} desc Vue组件描述符
+ * @returns {string} 编译后的render函数
+ */
+Static.prototype._processTemplate = function (desc) {
+  if (!desc.template) return '';
+  
+  const template_result = compile(desc.template.content, {
+    mode: 'module'
+  });
+  
+  // 提取render函数代码，去除import语句和export语句
+  let render_function = template_result.code
+    .replace(/^import[^;]+;\s*/gm, '')
+    .replace(/^export[^;]+;\s*/gm, '')
+    .trim();
+  
+  // 如果render函数包含函数定义，提取函数体
+  let render_match = render_function.match(/function\s+render\s*\([^)]*\)\s*{([\s\S]*?)}\s*$/);
+  if (render_match) {
+    render_function = `function render(_ctx, _cache) {${render_match[1]}}`;
+  }
+  
+  return render_function;
+};
+
+/**
+ * 处理Vue脚本部分
+ * @param {object} desc Vue组件描述符
+ * @param {string} render_function render函数
+ * @returns {string} 处理后的脚本代码
+ */
+Static.prototype._processScript = function (desc, render_function) {
+  if (!desc.script) {
+    return this._createDefaultComp(render_function);
+  }
+  
+  let script_content = desc.script.content;
+  
+  // 提取import语句
+  let imports = '';
+  let import_match = script_content.match(/import[^;]+;/g);
+  if (import_match) {
+    imports = import_match.join('\n') + '\n';
+  }
+  
+  // 提取export default部分，保留完整的组件定义
+  let export_match = script_content.match(/export\s+default\s*({[\s\S]*?})\s*$/s);
+  if (export_match) {
+    return this._buildCompWithExport(export_match[1], imports, render_function);
+  } else {
+    return this._buildDefaultComp(imports, render_function);
+  }
+};
+
+/**
+ * 创建默认组件结构
+ * @param {string} render_function render函数
+ * @returns {string} 默认组件代码
+ */
+Static.prototype._createDefaultComp = function (render_function) {
+  return `
+export default {
+  name: 'VueComponent',
+  data() {
+    return {}
+  }${render_function ? `,\n  render: ${render_function}` : ''}\n};
+`;
+};
+
+/**
+ * 构建带有export的组件
+ * @param {string} code_lib 组件代码
+ * @param {string} imports import语句
+ * @param {string} render_function render函数
+ * @returns {string} 完整的组件代码
+ */
+Static.prototype._buildCompWithExport = function (code_lib, imports, render_function) {
+  let proc_code = code_lib;
+  
+  // 确保组件字符串是完整的对象结构
+  if (!proc_code.trim().endsWith('}')) {
+    proc_code = proc_code + '\n}';
+  }
+  
+  // 如果render函数存在，将其添加到组件选项中
+  if (render_function) {
+    // 在最后一个属性之前插入render函数
+    if (proc_code.trim().endsWith('}')) {
+      proc_code = proc_code.replace(/}\s*$/, '');
+      // 确保最后一个属性后有逗号
+      if (!proc_code.trim().endsWith(',')) {
+        proc_code += ',';
+      }
+      proc_code += `\n  render: ${render_function}\n}`;
+    }
+  }
+  
+  return `${imports}
+export default ${proc_code};
+`;
+};
+
+/**
+ * 构建默认组件
+ * @param {string} imports import语句
+ * @param {string} render_function render函数
+ * @returns {string} 默认组件代码
+ */
+Static.prototype._buildDefaultComp = function (imports, render_function) {
+  return `${imports}
+export default {
+  name: 'VueComponent',
+  data() {
+    return {}
+  }${render_function ? `,\n  render: ${render_function}` : ''}\n};
+`;
+};
+
+/**
+ * 编译Vue组件
+ * @param {string} code Vue组件代码
+ * @returns {string} 可直接调用的JavaScript组件代码
+ */
+Static.prototype._compileVue = function (code) {
+  let desc = parse(code).descriptor;
+  let render_function = this._processTemplate(desc);
+  return this._processScript(desc, render_function);
+};
+
+/**
+ * 发送文件
+ * @param {object} ctx Koa上下文对象
+ * @param {string} path 文件路径
+ */
+Static.prototype._sendFile = async function (ctx, path) {
+  // koa-send会自动处理查询参数，直接传递路径
+  await send(ctx, path, this.config);
+};
+
+/**
+ * 运行AMD模块
+ * @param {string} path 文件路径
+ * @param {string} file_type 文件类型
+ * @returns {Promise<string>} AMD模块代码
+ */
+Static.prototype._runAmd = async function (path, file_type) {
+  let type = file_type || this._getType(path);
+  let code = null;
+  let text = `.${path}`.fullname(this.config.root).loadText();
+  if (text) {
+    code = await this._toAmd(type, text);
+  }
+  return code;
+};
+
+/**
+ * 运行Vue组件
+ * @param {string} path 文件路径
+ * @returns {string} 编译后的代码
+ */
+Static.prototype._runVue = function (path) {
+  let code = null;
+  let file = `.${path}`.fullname(this.config.root);
+  let text = file.loadText();
+  if (text) {
+    code = this._compileVue(text);
+  }
+  return code;
+};
+
+/**
+ * 返回响应
+ * @param {object} ctx Koa上下文对象
+ * @param {string} body 响应体
+ * @param {object} headers 响应头
+ * @returns {object} 响应对象
+ */
+Static.prototype._return = function (ctx, body, headers) {
+  ctx.body = body;
+  if (headers) {
+    ctx.set(headers);
+  }
+  return { body, headers };
+};
+
+/**
+ * 初始化文件监听器
+ */
+Static.prototype._initWatcher = function () {
+  try {
+    const chokidar = require('chokidar');
+
+    // 构建监听模式，只监听指定类型的文件
+    const watch_patterns = this.config.watch_files.map(ext =>
+      `${this.config.root}/**/*${ext}`
+    );
+
+    // 监听指定类型的文件
+    this._watcher = chokidar.watch(watch_patterns, {
+      ignored: /(^|[\/\\])\\./, // 忽略隐藏文件
+      persistent: true,
+      ignoreInitial: true // 忽略初始扫描事件
+    });
+
+    // 文件变化时的处理逻辑
+    this._watcher.on('all', (event, file_path) => {
+      this._handleFileChange(event, file_path);
+    });
+  } catch (error) {
+    console.error('文件监听初始化失败:', error.message);
+  }
+};
+
+/**
+ * 处理文件变化事件
+ * @param {string} event 事件类型
+ * @param {string} file_path 文件路径
+ */
+Static.prototype._handleFileChange = function (event, file_path) {
+  // 构建缓存键（相对于静态目录的路径）
+  const relative_path = file_path.replace(this.config.root, '').replace(/^[\\\/]/, '');
+  const cache_key = this.config.key_prefix + relative_path;
+
+  // 根据事件类型处理缓存
+  switch (event) {
+    case 'change':
+    case 'add':
+      // 文件修改或新增，删除缓存，下次请求时重新生成
+      this._cache.del(cache_key);
+      break;
+    case 'unlink':
+      // 文件删除，删除缓存
+      this._cache.del(cache_key);
+      break;
+  }
+};
+
+/**
+ * 获取响应头
+ * @param {string} file_type 文件类型
+ * @returns {object} 响应头
+ */
+Static.prototype._getHeaders = function (file_type) {
+  let headers = {};
+
+  // 缓存控制逻辑
+  if (this.config.max_age > 0) {
+    let cache_control = `max-age=${this.config.max_age}`;
+    if (this.config.immutable) {
+      cache_control += ', immutable';
+    }
+    headers['cache-control'] = cache_control;
+  }
+  switch (file_type) {
+    case 'js':
+      headers['content-type'] = 'application/javascript; charset=utf-8';
+      break;
+    case 'vue':
+      if (this.config.convert_amd) {
+        headers['content-type'] = 'text/html; charset=utf-8';
+      }
+      else if (this.config.compile_vue) {
+        headers['content-type'] = 'text/javascript; charset=utf-8';
+      }
+      break;
+    case 'html':
+      headers['content-type'] = 'text/html; charset=utf-8';
+      break;
+    default:
+      headers['content-type'] = 'text/plain; charset=utf-8';
+      break;
+  }
+  return headers;
+};
+
+/**
+ * 设置缓存
+ * @param {string} path 文件路径（包含查询参数）
+ * @param {object} ret 响应体和响应头
+ */
+Static.prototype._setCache = async function (path, ret) {
+  // 使用完整路径（包含查询参数）作为缓存键
+  await this._cache.set(this.config.key_prefix + path, ret, this.config.cache_age);
+};
+
+/**
+ * 获取文件类型
+ * @param {string} path 文件路径
+ * @returns {string} 文件类型（不含点号）
+ */
+Static.prototype._getType = function (path) {
+
+  // 使用mm_expand提供的extname方法获取扩展名
+  const ext = path.extname().toLowerCase();
+  if (ext) {
+    return ext.slice(1); // 去掉点号
+  }
+
+  // 备用方法：处理多扩展名情况
+  const basename = path.basename();
+  const parts = basename.split('.');
+
+  // 如果文件名包含多个点号，取最后一个作为扩展名
+  if (parts.length > 1) {
+    return parts[parts.length - 1];
+  }
+
+  return ''; // 无扩展名
+};
+
+/**
+ * 获取缓存
+ * @param {string} path 文件路径（包含查询参数）
+ * @returns {object} 响应体和响应头
+ */
+Static.prototype._getCache = async function (path) {
+  // 使用完整路径（包含查询参数）作为缓存键
+  return await this._cache.get(this.config.key_prefix + path);
+};
+
+/**
+ * 删除缓存
+ * @param {string} path 文件路径（包含查询参数）
+ */
+Static.prototype._delCache = async function (path) {
+  await this._cache.del(this.config.key_prefix + path);
+};
+
+/**
+ * 处理缓存逻辑
+ * @param {string} url 完整URL
+ * @param {object} ctx Koa上下文对象
+ * @returns {boolean} 是否命中缓存
+ */
+Static.prototype._handleCache = async function (url, ctx) {
+  if (!this.config.cache) return false;
+  
+  let ret = await this._getCache(url);
+  if (ret) {
+    this._return(ctx, ret.body, ret.headers);
+    return true;
+  }
+  return false;
+};
+
+/**
+ * 处理文件编译逻辑
+ * @param {string} path 文件路径
+ * @returns {string|null} 编译后的内容
+ */
+Static.prototype._handleFileCompile = function (path) {
+  if (!path.startsWith(this.config.path)) return null;
+  
+  let file_type = this._getType(path);
+  let { compile_vue, convert_amd } = this.config;
+  
+  if (convert_amd && this.config.files.includes('.' + file_type)) {
+    return this._runAmd(path, file_type);
+  }
+  else if (compile_vue && file_type === 'vue') {
+    return this._runVue(path);
+  }
+  
+  return null;
+};
+
+/**
+ * 处理编译后的文件响应
+ * @param {string} url 完整URL
+ * @param {string} path 文件路径
+ * @param {string} body 响应体
+ * @param {object} ctx Koa上下文对象
+ */
+Static.prototype._handleCompiledResp = async function (url, path, body, ctx) {
+  let file_type = this._getType(path);
+  let headers = this._getHeaders(file_type);
+  let ret = this._return(ctx, body, headers);
+
+  // 只有当缓存启用时才设置缓存
+  if (this.config.cache) {
+    await this._setCache(url, ret);
+  }
+};
+
+/**
+ * 主处理函数
+ * @param {object} ctx Koa上下文对象
+ * @param {Function} next Koa中间件函数
+ */
+Static.prototype.main = async function (ctx, next) {
+  const url = ctx.url; // 使用完整URL（包含查询参数）
+  const path = ctx.path; // 仅用于文件路径检查
+
+  // 检查缓存
+  if (await this._handleCache(url, ctx)) {
+    return;
+  }
+
+  // 处理文件编译
+  let body = this._handleFileCompile(path);
+  if (body) {
+    await this._handleCompiledResp(url, path, body, ctx);
+    return;
+  }
+
+  // 直接发送文件
+  try {
+    await this._sendFile(ctx, path);
+  }
+  catch {
+    await next();
+  }
+};
+
+/**
+ * 关闭文件监听器
+ */
+Static.prototype.closeWatcher = function () {
+  if (this._watcher) {
+    this._watcher.close();
+    this._watcher = null;
+  }
+};
+
+/**
+ * 创建静态文件处理中间件
+ * @param {object} config 配置
+ * @returns {Function} Koa中间件函数
+ */
+function statics(config) {
+  const statics = new Static(config);
+  return async function (ctx, next) {
+    await statics.main(ctx, next);
+  };
+}
+
+module.exports = { Static, statics };