@kezh/my-custom-js-converter 1.6.3 → 1.8.0

package/core/decode/index.js

@@ -97,7 +97,18 @@ function decoding$0(inPath, outPath, config, settingDir, libDirs, conflicts) {
             mapContext.writeToLocalDir(settingDir);
         }
         (0, ast_1.importMods)(path_1.default.dirname(outPath), srcAst, mapContext, config.encode.useAlias);
-        (0, ast_1.deleteModMethods)(srcAst, mapContext);
+        // 稽核内联工具方法体是否与源文件一致（忽略注释）
+        const mismatches = (0, ast_1.auditModMethods)(srcAst, mapContext);
+        const skipMethodKeys = new Set();
+        if (mismatches.length) {
+            logger.warn(`检测到 ${mismatches.length} 个内联工具方法与源文件不一致，将保留其内联形态不还原:`);
+            mismatches.forEach((m) => {
+                logger.warn(`  - ${m.methodKey}（源文件: ${m.srcPath}）`);
+                skipMethodKeys.add(m.methodKey);
+            });
+            logger.warn(`请检查上述方法，确认 coded.js 与源文件差异后手动处理或重新 encode。`);
+        }
+        (0, ast_1.deleteModMethods)(srcAst, mapContext, skipMethodKeys);
         // 从onFormReady方法中提取版本日志并移除
         extractAndRemoveVersionLog(srcAst, settingDir);
         let { code: dist } = (0, generator_1.default)(srcAst, { compact: true });

package/core/encode/index.js

@@ -11,6 +11,7 @@ const map_context_1 = require("../context/map_context");
 const ast_1 = require("../util/ast");
 const version_1 = require("../util/version");
 const core_1 = require("@babel/core");
+const parent_path_1 = require("../util/parent_path");
 const logger_1 = require("../util/logger");
 const logger = (0, logger_1.createLogger)("encode");
 (function encoding(config) {
@@ -26,6 +27,13 @@ const logger = (0, logger_1.createLogger)("encode");
         const settingDir = path_1.default.join(workDir, config.settingDir);
         logger.step(`编码处理 [${index + 1}/${codeFiles.length}]`);
         logger.info(`源文件: ${inPath}`);
+        // 防护检测：源文件 mount 对象内若残留 __mod 后缀方法，说明用户复用了 decode 产物
+        // 作为二开源文件。此时禁止通过 require 引入工具方法，只做无依赖编码。
+        const guardResult = guardInlinedModMethods(inPath, encodeConfig.entry, config);
+        if (guardResult) {
+            logger.error(guardResult);
+            return;
+        }
         const mapContext = new map_context_1.MapContext(inPath, encodeConfig.entry, settingDir, true);
         const methods = encoding$0(mapContext, encodeConfig.entry);
         totalMethods += methods.length;
@@ -109,3 +117,43 @@ function reorderMethods(methods) {
     methods.length = 0;
     methods.push(...priorityMethods, ...restMethods);
 }
+/**
+ * 防护检测：源文件 mount 对象内若残留 `__mod` 后缀方法，且同时通过 require 引入了
+ * 工具方法依赖，则禁止编码。
+ *
+ * 场景：用户把 decode 产物（含未还原的 `validate__util` 等内联方法）复制为 index.js
+ * 进行二开，同时又保留了 `const util = require(...)`。此时若继续 encode，会导致
+ * 方法重复定义、mod.map 错乱。应提示用户移除 require 引入，只做无依赖编码。
+ *
+ * @param inPath - 源文件路径
+ * @param entry - 入口对象名
+ * @param config - 主配置
+ * @returns 错误提示字符串（检测到连规时返回，未连规返回 null）
+ */
+function guardInlinedModMethods(inPath, entry, config) {
+    const srcAst = (0, ast_1.parseSrcAst)(inPath);
+    if (!srcAst) {
+        return null;
+    }
+    const inlinedNames = (0, ast_1.getInlinedModMethodNames)(srcAst, entry);
+    if (!inlinedNames.length) {
+        return null;
+    }
+    // 检测是否存在 require 引入的工具方法依赖
+    const rootDir = config.encode.useAlias
+        ? (0, parent_path_1.getParentRootDir)() || config.baseDir
+        : undefined;
+    const requireModPaths = (0, ast_1.getRequireModPaths)(path_1.default.dirname(inPath), srcAst, undefined, rootDir);
+    if (!requireModPaths.size) {
+        // 有 __mod 方法但无 require 依赖：允许无依赖编码
+        return null;
+    }
+    const depNames = [...requireModPaths.keys()];
+    return (`检测到源文件 mount 对象内残留工具方法后缀（${inlinedNames.join(", ")}），` +
+        `同时存在 require 依赖引入（${depNames.join(", ")}）。\n` +
+        `此场景不允许编码：请移除源文件中的 require 工具方法引入（${depNames
+            .map((n) => `const ${n} = require(...)`)
+            .join("; ")}），` +
+        `仅保留 mount 对象内的 __mod 后缀方法做无依赖编码；` +
+        `或将 __mod 后缀方法抽为独立工具文件后再 encode。`);
+}

package/core/util/ast.js

@@ -16,6 +16,8 @@ exports.importMods = importMods;
 exports.deleteModMethods = deleteModMethods;
 exports.getInlineMethodsByMethodName = getInlineMethodsByMethodName;
 exports.getUnknownDepNames = getUnknownDepNames;
+exports.auditModMethods = auditModMethods;
+exports.getInlinedModMethodNames = getInlinedModMethodNames;
 const fs_1 = __importDefault(require("fs"));
 const parser_1 = require("@babel/parser");
 const traverse_1 = __importDefault(require("@babel/traverse"));
@@ -57,9 +59,18 @@ function fixMisplacedLineComments(code) {
 function outputObjectMethods(outPath, methods) {
     let dist = methods
         .map((m) => {
-        // 保留 leadingComments：原代码会删除方法前置注释，但 Babel 会把上一个方法/属性
-        // 的行尾注释挂到当前方法的 leadingComments，删除会导致这些注释丢失。
-        // 改由 fixMisplacedLineComments 在生成后修正错位。
+        var _a;
+        // 区分处理 leadingComments：
+        // - CommentBlock（/** ... */ JSDoc）：属于方法自身的文档注释，encode 扁平化时应删除。
+        // - CommentLine（// ...）：Babel 会把上一属性/方法的行尾注释错挂到当前方法的
+        //   leadingComments，删除会导致行尾注释丢失，因此保留，交由 fixMisplacedLineComments
+        //   在生成后还原到上一属性行尾。
+        if ((_a = m.leadingComments) === null || _a === void 0 ? void 0 : _a.length) {
+            m.leadingComments = m.leadingComments.filter((c) => c.type === "CommentLine");
+            if (!m.leadingComments.length) {
+                m.leadingComments = undefined;
+            }
+        }
         return m;
     })
         .map((m) => (0, generator_1.default)(m))
@@ -390,8 +401,12 @@ function importMods(outDir, srcAst, mapContext, useAlias = false) {
 /**
  * 去除第三方模块方法
  * @param srcAst - 源码AST
+ * @param mapContext
+ * @param skipMethodKeys - 需要跳过（不删除、不还原）的方法完整名集合，
+ *   元素形如 `method__mod`。用于稽核出方法体不一致的工具方法：
+ *   保留其内联定义与 this.method__mod 调用，交由用户人工处理。
  */
-function deleteModMethods(srcAst, mapContext) {
+function deleteModMethods(srcAst, mapContext, skipMethodKeys = new Set()) {
     const deps = new Set();
     mapContext
         .getModNames()
@@ -408,6 +423,10 @@ function deleteModMethods(srcAst, mapContext) {
                 return;
             }
             const depName = split.length ? split[split.length - 1] : "";
+            // 稽核不一致的方法：保留内联定义，不删除
+            if (skipMethodKeys.has(methodName)) {
+                return;
+            }
             deps.has(depName) && path.remove();
         }
     });
@@ -423,6 +442,10 @@ function deleteModMethods(srcAst, mapContext) {
             }
             const depName = split[split.length - 1];
             if (deps.has(depName)) {
+                // 稽核不一致的方法：保留 this.method__mod 调用形态，不还原
+                if (skipMethodKeys.has(methodName)) {
+                    return;
+                }
                 path.node.property.name = methodName.replace(`__${depName}`, "");
                 if (core_1.types.isThisExpression(path.node.object)) {
                     path.node.object = core_1.types.identifier(depName);
@@ -509,3 +532,217 @@ function getUnknownDepNames(srcAst, knownDeps) {
     });
     return [...depNames];
 }
+/**
+ * 递归清除节点及其子树上所有 comments 字段（leading/inner/trailing），
+ * 用于“忽略注释”的代码比对。
+ */
+function stripCommentsDeep(node) {
+    if (!node || typeof node !== "object") {
+        return;
+    }
+    // 处理数组节点
+    if (Array.isArray(node)) {
+        node.forEach((child) => stripCommentsDeep(child));
+        return;
+    }
+    const n = node;
+    n.leadingComments = null;
+    n.innerComments = null;
+    n.trailingComments = null;
+    for (const key of Object.keys(n)) {
+        const val = n[key];
+        if (val && typeof val === "object") {
+            stripCommentsDeep(val);
+        }
+    }
+}
+/**
+ * 生成节点的归一化代码：去注释 + generate + 压缩空白/换行，
+ * 使仅注释或排版差异的代码视为相同。
+ */
+function normalizeNodeCode(node) {
+    // 克隆避免污染原 AST
+    const cloned = JSON.parse(JSON.stringify(node));
+    stripCommentsDeep(cloned);
+    const { code } = (0, generator_1.default)(cloned, { compact: true });
+    // 压缩连续空白与换行，统一比较基准
+    return code.replace(/\s+/g, " ").trim();
+}
+/**
+ * 对单个克隆的方法节点，在其方法体内应用与 encode `modifyObjectMethods`
+ * （非 root 分支）一致的调用重命名，使其与 coded.js 内联方法体可比对：
+ *   - `this.method`（method 属于该 mod 自身方法集）→ `this.method__entry`
+ *   - `dep.method`（dep 属于 mod.dependencies 且 method 在 dep.methods）→ `this.method__dep`
+ * 同时把方法 key 由 `method` 重命名为 `method__entry`。
+ *
+ * 注意：仅作用于传入的方法节点子树，不污染原 AST（调用方需传入克隆节点）。
+ */
+function renameCallsInsideMethod(methodNode, entry, selfMethods, deps) {
+    // 重命名方法 key：method → method__entry
+    if (core_1.types.isIdentifier(methodNode.key)) {
+        methodNode.key.name = `${methodNode.key.name}__${entry}`;
+    }
+    // 在方法体内遍历 MemberExpression 做调用重命名
+    // 使用 path 作用域限定在该方法节点内
+    const selfSet = new Set(selfMethods);
+    const depMap = new Map();
+    deps.forEach((d) => depMap.set(d.name, new Set(d.methods)));
+    // 手动遍历方法体（避免引入完整 traverse 的作用域问题）
+    const visit = (node) => {
+        if (!node || typeof node !== "object") {
+            return;
+        }
+        if (Array.isArray(node)) {
+            node.forEach((child) => visit(child));
+            return;
+        }
+        if (core_1.types.isMemberExpression(node)) {
+            // this.method → this.method__entry（method 属于自身方法集）
+            if (core_1.types.isThisExpression(node.object) &&
+                core_1.types.isIdentifier(node.property) &&
+                selfSet.has(node.property.name)) {
+                node.property.name = `${node.property.name}__${entry}`;
+            }
+            // dep.method → this.method__dep
+            if (core_1.types.isIdentifier(node.object) &&
+                core_1.types.isIdentifier(node.property) &&
+                depMap.has(node.object.name) &&
+                depMap.get(node.object.name).has(node.property.name)) {
+                const depName = node.object.name;
+                node.object = core_1.types.thisExpression();
+                node.property.name = `${node.property.name}__${depName}`;
+            }
+        }
+        for (const key of Object.keys(node)) {
+            if (key === "loc" || key === "start" || key === "end" || key === "range") {
+                continue;
+            }
+            const val = node[key];
+            if (val && typeof val === "object") {
+                visit(val);
+            }
+        }
+    };
+    visit(methodNode);
+}
+/**
+ * 稽核 coded.js 中内联工具方法的方法体是否与源文件一致（忽略注释）。
+ *
+ * 比对基准：对源文件中对应方法应用与 encode 一致的重命名后，生成归一化代码，
+ * 与 coded.js 内联方法体的归一化代码比对。若不一致，说明 coded.js 被手动修改
+ * 或源文件已漂移，应跳过该方法的 decode（保留内联定义与 this.method__mod 调用）。
+ *
+ * @param srcAst - coded.js 的 AST（已包裹为 mount 对象）
+ * @param mapContext - mod.map 上下文
+ * @returns 不一致的方法列表
+ */
+function auditModMethods(srcAst, mapContext) {
+    const mismatches = [];
+    // 所有已知依赖名并集（与 deleteModMethods 一致）
+    const deps = new Set();
+    mapContext
+        .getModNames()
+        .flatMap((name) => { var _a; return Object.keys((_a = mapContext.getMod(name)) === null || _a === void 0 ? void 0 : _a.dependencies); })
+        .forEach((dep) => deps.add(dep));
+    // 缓存源文件 AST，避免重复解析
+    const srcAstCache = new Map();
+    const getSrcAst = (modName) => {
+        if (srcAstCache.has(modName)) {
+            return srcAstCache.get(modName);
+        }
+        const srcPath = mapContext.getAbsoluteSrcPathByMod(modName);
+        const ast = srcPath ? parseSrcAst(srcPath) : undefined;
+        srcAstCache.set(modName, ast);
+        return ast;
+    };
+    (0, traverse_1.default)(srcAst, {
+        ObjectMethod(path) {
+            if (!core_1.types.isIdentifier(path.node.key)) {
+                return;
+            }
+            const fullMethodName = path.node.key.name;
+            const split = fullMethodName.split("__");
+            if (split.length < 2) {
+                return;
+            }
+            const depName = split[split.length - 1];
+            if (!deps.has(depName)) {
+                return;
+            }
+            // 原始方法名：去掉 __depName 后缀
+            const originalName = fullMethodName.slice(0, fullMethodName.length - depName.length - 2);
+            const srcPath = mapContext.getAbsoluteSrcPathByMod(depName);
+            const depSrcAst = getSrcAst(depName);
+            if (!depSrcAst || !srcPath) {
+                // 源文件不可读，无法稽核，跳过（不视为不一致）
+                return;
+            }
+            // 从源文件取出对应方法节点
+            const srcMethods = getObjectMethodsByEntryAndMethodNames(depSrcAst, depName, [originalName]);
+            if (!srcMethods.length) {
+                // 源文件中找不到该方法，视为不一致（源文件已变更）
+                mismatches.push({
+                    methodKey: fullMethodName,
+                    methodName: originalName,
+                    modName: depName,
+                    srcPath
+                });
+                return;
+            }
+            // 克隆源方法节点，应用 encode 重命名，归一化
+            // 自身方法集取源文件中该 entry 对象的所有方法名（与 encode modifyObjectMethods 一致），
+            // 而非 mod.map 的引用集（补充依赖场景下引用集可能为空）
+            const allSrcMethods = getObjectMethodsByEntryAndMethodNames(depSrcAst, depName);
+            const selfMethodNames = getObjectMethodNames(allSrcMethods);
+            const srcCloned = JSON.parse(JSON.stringify(srcMethods[0]));
+            const mod = mapContext.getMod(depName);
+            const depEntries = mod
+                ? Object.keys(mod.dependencies).map((name) => ({
+                    name,
+                    methods: mod.dependencies[name].methods
+                }))
+                : [];
+            renameCallsInsideMethod(srcCloned, depName, selfMethodNames, depEntries);
+            const srcNormalized = normalizeNodeCode(srcCloned);
+            // coded.js 内联方法节点归一化（直接比对，已是重命名后形态）
+            const codedCloned = JSON.parse(JSON.stringify(path.node));
+            const codedNormalized = normalizeNodeCode(codedCloned);
+            if (srcNormalized !== codedNormalized) {
+                mismatches.push({
+                    methodKey: fullMethodName,
+                    methodName: originalName,
+                    modName: depName,
+                    srcPath
+                });
+            }
+        }
+    });
+    return mismatches;
+}
+/**
+ * 检测入口对象内是否含有 `__mod` 后缀的方法定义。
+ *
+ * 用于 encode 防护：当源文件（index.js）的 mount 对象内残留带 `__mod` 后缀的方法时，
+ * 说明用户直接复用了 decode 产物（含未还原的内联工具方法）作为二开源文件。
+ * 此类源文件不应再通过 require 引入工具方法做依赖编码，否则会导致方法重复定义、
+ * mod.map 错乱。encode 检测到此场景应禁止 require 引入，只做无依赖编码。
+ *
+ * @param srcAst - 源码AST
+ * @param entry - 入口对象名
+ * @returns 含 `__mod` 后缀的方法名列表（如 `["validate__util", "fetchData__util"]`）
+ */
+function getInlinedModMethodNames(srcAst, entry) {
+    const inlinedNames = [];
+    // 取入口对象的所有方法，筛选出 key 含 __ 后缀的
+    const methods = getObjectMethodsByEntryAndMethodNames(srcAst, entry);
+    methods.forEach((method) => {
+        if (!core_1.types.isIdentifier(method.key)) {
+            return;
+        }
+        const name = method.key.name;
+        if (name.split("__").length >= 2) {
+            inlinedNames.push(name);
+        }
+    });
+    return inlinedNames;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kezh/my-custom-js-converter",
-  "version": "1.6.3",
+  "version": "1.8.0",
   "description": "自定义代码转换器",
   "main": "index.js",
   "files": [