pug-site-core 3.0.24 → 3.0.26

package/lib/generate.js

@@ -26,7 +26,58 @@ import { fetchABTestInfo } from "./utils.js";
 const { config } = await import(paths.config);
 
 /**
- * 将pages目录下的pug模板编译为JS函数
+ * 编译单个 pug 文件
+ * @param {string} fileName - pug 文件名（相对于 template/pages）
+ * @param {string} filePath - 完整文件路径
+ * @returns {Promise<string>} 编译后的函数代码
+ */
+async function compileSinglePugFile(fileName, filePath) {
+  const funName = fileName
+    .split(pathSymbol)
+    .join("_")
+    .slice(0, -4)
+    .replaceAll(/[-]/g, "_");
+
+  // 读取并编译pug文件
+  const pugValue = await fse.readFile(filePath, "utf8");
+
+  const fnStr = pug.compileClient(pugValue, {
+    filename: filePath,
+    basedir: paths.template.root,
+    compileDebug: true,
+    name: funName,
+    filters: getCompilePugFilter()
+  });
+
+  // 提取函数定义部分
+  const functionStart = fnStr.indexOf(`function ${funName}(locals)`);
+  const functionEnd = fnStr.lastIndexOf("}") + 1;
+
+  if (functionStart === -1) {
+    throw new Error(`无法在编译结果中找到函数 ${funName}`);
+  }
+
+  // 只提取函数定义部分并转换为ES模块格式
+  let functionBody = fnStr.slice(functionStart, functionEnd);
+
+  if (config.isScopeIsolation) {
+    // 修改函数体，在返回HTML之前添加作用域处理
+    functionBody = functionBody.replace(
+      /return\s+(.*?);?\s*}$/,
+      `const html = $1;return addTemplateScopeIsolation(html);}`
+    );
+  }
+
+  const exportFn = functionBody.replace(
+    `function ${funName}(locals)`,
+    `export function ${funName}(locals)`
+  );
+
+  return exportFn;
+}
+
+/**
+ * 将pages目录下的pug模板编译为JS函数（原有逻辑，全量编译）
  * @param {string} pugPath - 指定编译的pug文件路径(相对于/template/pages)
  * @throws {Error} 当路径不存在或编译失败时抛出错误
  * @returns {Promise<void>}
@@ -214,11 +265,13 @@ export async function fetchDataToJsonFile(args) {
 
     let saveJsonData = async (filePath, data) => {
       let finalPath = paths.resolveRoot("jsonData", filePath);
-      // await fse.remove(finalPath);
+
       // 如果 路径存在，跳过写入
-      if (await fse.pathExists(finalPath)) {
+      if (args.includes("skip") && await fse.pathExists(finalPath)) {
         return;
       }      
+      
+      await fse.remove(finalPath);
       await fse.outputJson(finalPath, data);
     };
 
@@ -253,8 +306,8 @@ export async function fetchDataToJsonFile(args) {
       return Promise.resolve();
     };
 
-    // 如果没有过滤条件，清空输出目录
-    if (!filterFun.length && !filterLang.length) {
+    // 如果没有过滤条件且不是skip模式，清空输出目录
+    if (!filterFun.length && !filterLang.length && !args.includes("skip")) {
       await fse.remove(paths.resolveRoot("jsonData"));
     }
 
@@ -557,6 +610,387 @@ export async function buildFn() {
   console.log("打包完成花费:", (Date.now() - starTime) / 1000, "s");
 }
 
+// ============================================
+// buildSrc 专用函数（增量构建、依赖追踪、跳过压缩）
+// ============================================
+
+/**
+ * 获取编译缓存文件路径（buildSrc 专用）
+ * @returns {string} 缓存文件路径
+ */
+function getCompileCachePath() {
+  return paths.resolveRoot("pagesPugFn", ".compile-cache.json");
+}
+
+/**
+ * 加载编译缓存（buildSrc 专用）
+ * @returns {Promise<Object>} 缓存对象 { [fileName]: { mtime: number, depMtime: number, code: string } }
+ */
+async function loadCompileCache() {
+  const cachePath = getCompileCachePath();
+  try {
+    if (await fse.pathExists(cachePath)) {
+      return await fse.readJSON(cachePath);
+    }
+  } catch (error) {
+    console.warn("读取编译缓存失败，将全量编译:", error.message);
+  }
+  return {};
+}
+
+/**
+ * 保存编译缓存（buildSrc 专用）
+ * @param {Object} cache - 缓存对象
+ * @returns {Promise<void>}
+ */
+async function saveCompileCache(cache) {
+  const cachePath = getCompileCachePath();
+  try {
+    await fse.ensureFile(cachePath);
+    await fse.writeJSON(cachePath, cache, { spaces: 2 });
+  } catch (error) {
+    console.warn("保存编译缓存失败:", error.message);
+  }
+}
+
+/**
+ * 获取文件的修改时间（buildSrc 专用）
+ * @param {string} filePath - 文件路径
+ * @returns {Promise<number>} 修改时间戳（毫秒）
+ */
+async function getFileMtime(filePath) {
+  try {
+    const stats = await fse.stat(filePath);
+    return stats.mtimeMs || stats.mtime.getTime();
+  } catch (error) {
+    return 0;
+  }
+}
+
+/**
+ * 解析 pug 文件中的依赖关系（extends, include）（buildSrc 专用）
+ * @param {string} filePath - pug 文件路径
+ * @param {string} content - pug 文件内容
+ * @param {string} baseDir - 基础目录（template 根目录）
+ * @returns {string[]} 依赖的文件路径数组（相对于 template 根目录）
+ */
+function parsePugDependencies(filePath, content, baseDir) {
+  const dependencies = [];
+  const lines = content.split('\n');
+  
+  for (const line of lines) {
+    const trimmed = line.trim();
+    
+    // 匹配 extends 语句: extends /common/base.pug
+    const extendsMatch = trimmed.match(/^extends\s+(.+)$/);
+    if (extendsMatch) {
+      const depPath = extendsMatch[1].trim();
+      const resolvedPath = resolvePugPath(depPath, baseDir);
+      if (resolvedPath) {
+        dependencies.push(resolvedPath);
+      }
+    }
+    
+    // 匹配 include 语句: include /components/ga_head.pug 或 include ./header.pug
+    const includeMatch = trimmed.match(/^include(?::\w+)?\s+(.+)$/);
+    if (includeMatch) {
+      const depPath = includeMatch[1].trim();
+      const resolvedPath = resolvePugPath(depPath, baseDir, path.dirname(filePath));
+      if (resolvedPath) {
+        dependencies.push(resolvedPath);
+      }
+    }
+  }
+  
+  return dependencies;
+}
+
+/**
+ * 解析 pug 路径为相对于 template 根目录的路径（buildSrc 专用）
+ * @param {string} depPath - 依赖路径（可能是绝对路径或相对路径）
+ * @param {string} baseDir - template 根目录
+ * @param {string} currentDir - 当前文件所在目录（用于解析相对路径）
+ * @returns {string|null} 解析后的路径（相对于 template 根目录），如果不是 pug 文件则返回 null
+ */
+function resolvePugPath(depPath, baseDir, currentDir = null) {
+  depPath = depPath.replace(/^["']|["']$/g, '').trim();
+  
+  if (!depPath.endsWith('.pug')) {
+    return null;
+  }
+  
+  let resolvedPath;
+  if (depPath.startsWith('/')) {
+    resolvedPath = path.join(baseDir, depPath);
+  } else if (currentDir) {
+    resolvedPath = path.resolve(currentDir, depPath);
+  } else {
+    resolvedPath = path.join(baseDir, depPath);
+  }
+  
+  const relativePath = path.relative(baseDir, resolvedPath);
+  return relativePath.replace(/\\/g, '/');
+}
+
+/**
+ * 获取文件的所有依赖（递归）（buildSrc 专用）
+ * @param {string} filePath - 文件路径（相对于 template/pages）
+ * @param {Set<string>} visited - 已访问的文件集合（防止循环依赖）
+ * @param {Map<string, string[]>} dependencyCache - 依赖缓存
+ * @returns {Promise<Set<string>>} 所有依赖的文件路径集合（相对于 template 根目录）
+ */
+async function getAllDependencies(filePath, visited = new Set(), dependencyCache = new Map()) {
+  const templateRoot = paths.resolveRoot(paths.template.root);
+  const cacheKey = filePath;
+  
+  if (visited.has(cacheKey)) {
+    return new Set();
+  }
+  visited.add(cacheKey);
+  
+  let fullPath;
+  if (filePath.startsWith('common/') || filePath.startsWith('components/')) {
+    fullPath = paths.resolveRoot(paths.template.root, filePath);
+  } else {
+    fullPath = paths.resolveRoot(paths.template.pages, filePath);
+  }
+  
+  if (dependencyCache.has(cacheKey)) {
+    const deps = dependencyCache.get(cacheKey);
+    const allDeps = new Set(deps);
+    for (const dep of deps) {
+      const depDeps = await getAllDependencies(dep, visited, dependencyCache);
+      depDeps.forEach(d => allDeps.add(d));
+    }
+    return allDeps;
+  }
+  
+  let content;
+  try {
+    if (!await fse.pathExists(fullPath)) {
+      return new Set();
+    }
+    content = await fse.readFile(fullPath, 'utf8');
+  } catch (error) {
+    console.warn(`无法读取文件 ${filePath}:`, error.message);
+    return new Set();
+  }
+  
+  const currentDir = path.dirname(fullPath);
+  const dependencies = parsePugDependencies(fullPath, content, templateRoot);
+  dependencyCache.set(cacheKey, dependencies);
+  
+  const allDependencies = new Set(dependencies);
+  for (const dep of dependencies) {
+    const depDeps = await getAllDependencies(dep, visited, dependencyCache);
+    depDeps.forEach(d => allDependencies.add(d));
+  }
+  
+  return allDependencies;
+}
+
+/**
+ * 将pages目录下的pug模板编译为JS函数（buildSrc 专用：增量构建、依赖追踪、跳过压缩）
+ * @param {string} pugPath - 指定编译的pug文件路径(相对于/template/pages)
+ * @throws {Error} 当路径不存在或编译失败时抛出错误
+ * @returns {Promise<void>}
+ */
+async function compilePagesPugToFnForBuildSrc(pugPath) {
+  try {
+    const pagesPugFilePathArr = await getPagesPugFilePathArr();
+
+    if (
+      pugPath &&
+      !fse.pathExistsSync(paths.resolveRoot(paths.template.pages, pugPath))
+    ) {
+      throw new Error("路径不存在! 注意路径前面会自动拼接/template/pages");
+    }
+
+    const filesToProcess = pagesPugFilePathArr.filter(
+      (fileName) => !pugPath || pathIsSame(pugPath, fileName)
+    );
+
+    const cache = await loadCompileCache();
+    const newCache = {};
+    const filesToCompile = [];
+    const cachedCode = {};
+    const dependencyCache = new Map();
+
+    // 第一步：检查文件本身的修改时间（并行）
+    const checkStartTime = Date.now();
+    console.log("检查文件修改状态...");
+    const fileMtimes = new Map();
+    await async.eachLimit(
+      filesToProcess,
+      20,
+      async (fileName) => {
+        const filePath = paths.resolveRoot(paths.template.pages, fileName);
+        const mtime = await getFileMtime(filePath);
+        fileMtimes.set(fileName, mtime);
+      }
+    );
+    const checkTime = Date.now() - checkStartTime;
+
+    // 第二步：检查依赖文件的修改时间（并行）
+    const depStartTime = Date.now();
+    console.log("分析文件依赖关系...");
+    const dependencyMtimes = new Map();
+    const depFileMtimeCache = new Map();
+    
+    await async.eachLimit(
+      filesToProcess,
+      10,
+      async (fileName) => {
+        try {
+          const dependencies = await getAllDependencies(fileName, new Set(), dependencyCache);
+          
+          let maxDepMtime = 0;
+          for (const dep of dependencies) {
+            const depPath = paths.resolveRoot(paths.template.root, dep);
+            
+            let depMtime;
+            if (depFileMtimeCache.has(depPath)) {
+              depMtime = depFileMtimeCache.get(depPath);
+            } else {
+              depMtime = await getFileMtime(depPath);
+              depFileMtimeCache.set(depPath, depMtime);
+            }
+            
+            if (depMtime > 0) {
+              maxDepMtime = Math.max(maxDepMtime, depMtime);
+            }
+          }
+          
+          if (maxDepMtime > 0) {
+            dependencyMtimes.set(fileName, maxDepMtime);
+          }
+        } catch (error) {
+          console.warn(`分析文件 ${fileName} 的依赖关系失败:`, error.message);
+        }
+      }
+    );
+    const depTime = Date.now() - depStartTime;
+
+    // 第三步：决定哪些文件需要重新编译
+    for (const fileName of filesToProcess) {
+      const mtime = fileMtimes.get(fileName);
+      const depMtime = dependencyMtimes.get(fileName) || 0;
+      const cached = cache[fileName];
+
+      const needsRecompile = !cached || 
+                            cached.mtime !== mtime || 
+                            (depMtime > 0 && (!cached.depMtime || cached.depMtime < depMtime));
+
+      if (needsRecompile) {
+        filesToCompile.push(fileName);
+      } else {
+        cachedCode[fileName] = cached.code;
+        newCache[fileName] = cached;
+      }
+    }
+
+    const compileCount = filesToCompile.length;
+    const cacheCount = Object.keys(cachedCode).length;
+
+    if (compileCount > 0) {
+      console.log(`需要编译 ${compileCount} 个文件，使用缓存 ${cacheCount} 个文件`);
+      console.log(`  检查文件耗时: ${(checkTime / 1000).toFixed(2)}s, 分析依赖耗时: ${(depTime / 1000).toFixed(2)}s`);
+    } else {
+      console.log(`所有文件均使用缓存，跳过编译 (${cacheCount} 个文件)`);
+      console.log(`  检查文件耗时: ${(checkTime / 1000).toFixed(2)}s, 分析依赖耗时: ${(depTime / 1000).toFixed(2)}s`);
+    }
+
+    const lastPugFnStr = await fse.readFile(paths.pugRuntime, "utf8");
+    let compiledCode = lastPugFnStr;
+    if (config.isScopeIsolation) {
+      const scopeIsolationFn = `${addTemplateScopeIsolation.toString()}`;
+      compiledCode = compiledCode + scopeIsolationFn;
+    }
+
+    // 并发编译需要重新编译的文件
+    const compileStartTime = Date.now();
+    if (filesToCompile.length > 0) {
+      await async.eachLimit(
+        filesToCompile,
+        20,
+        async (fileName) => {
+          const filePath = paths.resolveRoot(paths.template.pages, fileName);
+          const mtime = fileMtimes.get(fileName);
+
+          try {
+            const exportFn = await compileSinglePugFile(fileName, filePath);
+            compiledCode += exportFn;
+
+            const depMtime = dependencyMtimes.get(fileName) || 0;
+            newCache[fileName] = {
+              mtime: mtime,
+              depMtime: depMtime,
+              code: exportFn
+            };
+          } catch (error) {
+            console.error(`编译文件 ${fileName} 失败:`, error);
+            throw error;
+          }
+        }
+      );
+    }
+    const compileTime = Date.now() - compileStartTime;
+    if (compileCount > 0) {
+      console.log(`  编译文件耗时: ${(compileTime / 1000).toFixed(2)}s`);
+    }
+
+    // 添加缓存的代码
+    for (const fileName of filesToProcess) {
+      if (cachedCode[fileName] && !filesToCompile.includes(fileName)) {
+        compiledCode += cachedCode[fileName];
+        if (!newCache[fileName]) {
+          newCache[fileName] = cache[fileName];
+        }
+      }
+    }
+
+    // 保存新的缓存
+    await saveCompileCache(newCache);
+
+    // buildSrc 专用：跳过压缩以提升开发环境构建速度
+    console.log(`跳过代码压缩（buildSrc 模式，可节省 ~4-5 秒）`);
+
+    // 写入最终文件
+    const outputPath = paths.resolveRoot("pagesPugFn", "index.js");
+    await fse.ensureFile(outputPath);
+    await fse.writeFile(outputPath, compiledCode);
+
+    if (compileCount > 0) {
+      console.log(`编译完成: 新编译 ${compileCount} 个，缓存 ${cacheCount} 个`);
+    }
+  } catch (error) {
+    console.error("编译PUG模板失败:", error);
+    throw error;
+  }
+}
+
+/**
+ * 构建 pages.js 到 src/ 目录
+ * 用于开发环境，让 wrangler 可以只监听 src/ 目录的变化
+ * 注意：common.json 的生成逻辑在 build-src.js 中实现，不在此处
+ * @returns {Promise<void>}
+ */
+export async function buildSrc() {
+  console.log("开始构建 src/ 目录...");
+  let starTime = Date.now();
+  
+  // 编译 pug 模板到函数（buildSrc 专用：增量构建、依赖追踪、跳过压缩）
+  await compilePagesPugToFnForBuildSrc();
+  
+  // 复制编译后的 pages.js 到 src/pages.js
+  await fse.copy(
+    paths.resolveRoot("pagesPugFn/index.js"),
+    paths.resolveRoot("src/pages.js")
+  );
+  
+  console.log("构建 src/ 目录完成，花费:", (Date.now() - starTime) / 1000, "s");
+}
+
 //html文件打包
 export async function buildStatic() {
   let jsonDataPath = paths.resolveRoot("jsonData");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pug-site-core",
-  "version": "3.0.24",
+  "version": "3.0.26",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -52,7 +52,7 @@
     "ws": "^8.18.0"
   },
   "license": "ISC",
-  "description": "getData不删旧数据，增量写文件",
+  "description": "重构 Pug 模板编译流程以支持增量构建和依赖追踪，并新增开发环境专用的 `buildSrc` 函数。",
   "files": [
     "lib/",
     "index.js"