mp-weixin-back 0.0.16 → 0.0.18

package/dist/index.mjs

@@ -3,399 +3,10 @@ import fs from 'fs';
 import JSON5 from 'json5';
 import { white, red, green } from 'kolorist';
 import { createRequire } from 'module';
-import generate from '@babel/generator';
 import MagicString from 'magic-string';
-import { babelParse, walkAST } from 'ast-kit';
-
-const virtualFileId = "mp-weixin-back-helper";
-
-const pageContainerComp = '  <page-container :show="__MP_BACK_SHOW_PAGE_CONTAINER__" :overlay="false" @beforeleave="onBeforeLeave" :z-index="1" :duration="false"></page-container>\n';
-function isArrowFunction(func) {
-  if (typeof func !== "function")
-    return false;
-  return !func.hasOwnProperty("prototype") && func.toString().includes("=>");
-}
-function compositionWalk(context, code, sfc, id) {
-  const codeMs = new MagicString(code);
-  const setupAst = babelParse(sfc.scriptSetup.loc.source, sfc.scriptSetup.lang);
-  let pageInfo = {
-    hasPageBack: false,
-    pageBackFnName: "onPageBack",
-    hasImportRef: false,
-    backConfig: { ...context.config },
-    onPageBackBodyAst: [],
-    onPageBackCallNodeToRemove: null,
-    activeFnName: "activeMpBack",
-    inActiveFnName: "inactiveMpBack"
-  };
-  const activeFnCallsToModify = [];
-  const inActiveFnCallsToModify = [];
-  if (setupAst) {
-    walkAST(setupAst, {
-      enter(node) {
-        if (node.type === "ImportDeclaration") {
-          if (node.source.value.includes(virtualFileId)) {
-            const importDefaultSpecifiers = node.specifiers.filter(
-              (i) => i.type === "ImportDefaultSpecifier"
-            );
-            const importDefaultSpecifier = importDefaultSpecifiers[0];
-            pageInfo.hasPageBack = true;
-            pageInfo.pageBackFnName = importDefaultSpecifier.local.name;
-            const importSpecifiers = node.specifiers.filter((i) => i.type === "ImportSpecifier");
-            importSpecifiers.map((specifiers) => {
-              if (specifiers.imported.type === "Identifier" && specifiers.imported.name === "activeMpBack") {
-                pageInfo.activeFnName = specifiers.local.name;
-              }
-              if (specifiers.imported.type === "Identifier" && specifiers.imported.name === "inactiveMpBack") {
-                pageInfo.inActiveFnName = specifiers.local.name;
-              }
-            });
-          }
-          if (node.source.value === "vue") {
-            node.specifiers.some((specifier) => {
-              if (specifier.local.name === "ref") {
-                pageInfo.hasImportRef = true;
-                return true;
-              }
-              return false;
-            });
-          }
-        }
-        if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.loc?.identifierName === pageInfo.pageBackFnName) {
-          pageInfo.onPageBackCallNodeToRemove = node;
-          const callback = node.expression.arguments[0];
-          const backArguments = node.expression.arguments[1];
-          if (backArguments?.type === "ObjectExpression") {
-            const config = new Function(
-              // @ts-ignore
-              `return (${(generate.default ? generate.default : generate)(backArguments).code});`
-            )();
-            Object.assign(pageInfo.backConfig, config);
-          }
-          if (callback && (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression")) {
-            pageInfo.onPageBackBodyAst = callback.body.body;
-          }
-          return;
-        }
-        if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.loc?.identifierName === pageInfo.activeFnName) {
-          activeFnCallsToModify.push({
-            start: node.expression.start,
-            end: node.expression.end,
-            original: sfc.scriptSetup.loc.source.substring(
-              node.expression.start,
-              node.expression.end
-            ),
-            name: pageInfo.activeFnName
-          });
-        }
-        if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.loc?.identifierName === pageInfo.inActiveFnName) {
-          inActiveFnCallsToModify.push({
-            start: node.expression.start,
-            end: node.expression.end,
-            original: sfc.scriptSetup.loc.source.substring(
-              node.expression.start,
-              node.expression.end
-            ),
-            name: pageInfo.inActiveFnName
-          });
-        }
-      }
-    });
-  }
-  if (!pageInfo.hasPageBack)
-    return code;
-  if (pageInfo.onPageBackCallNodeToRemove) {
-    const scriptSetupOffset = sfc.scriptSetup.loc.start.offset;
-    const nodeToRemove = pageInfo.onPageBackCallNodeToRemove;
-    const globalStart = scriptSetupOffset + nodeToRemove.start;
-    const globalEnd = scriptSetupOffset + nodeToRemove.end;
-    codeMs.remove(globalStart, globalEnd);
-  }
-  let callbackCode = "";
-  if (pageInfo.onPageBackBodyAst.length > 0) {
-    const tempAstRoot = {
-      type: "BlockStatement",
-      body: pageInfo.onPageBackBodyAst
-    };
-    walkAST(tempAstRoot, {
-      enter(node) {
-        if (node.type === "CallExpression" && node.callee.type === "Identifier") {
-          const createIdentifier = (name) => ({ type: "Identifier", name });
-          if (node.callee.name === pageInfo.activeFnName) {
-            node.arguments.unshift(createIdentifier("__MP_WEIXIN_ACTIVEBACK__"));
-          } else if (node.callee.name === pageInfo.inActiveFnName) {
-            node.arguments.unshift(createIdentifier("__MP_WEIXIN_INACTIVEBACK__"));
-          }
-        }
-      }
-    });
-    callbackCode = pageInfo.onPageBackBodyAst.map((statement) => (generate.default ? generate.default : generate)(statement).code).join("\n");
-  }
-  if (code.includes("<page-container")) {
-    context.log.debugLog(`${context.getPageById(id)}\u9875\u9762\u5DF2\u6709page-container\u7EC4\u4EF6\uFF0C\u6CE8\u5165\u5931\u8D25`);
-    return code;
-  }
-  if (!pageInfo.backConfig.preventDefault) {
-    callbackCode += "uni.navigateBack({ delta: 1 });";
-  }
-  const importUseMpWeixinBack = `import { useMpWeixinBack } from '${virtualFileId}'`;
-  const importRefFromVue = !pageInfo.hasImportRef ? `import { ref } from 'vue'` : "";
-  const stateFrequency = "let __MP_BACK_FREQUENCY__ = 1;";
-  const statePageContainerVar = `
-    const { __MP_BACK_SHOW_PAGE_CONTAINER__, __MP_WEIXIN_ACTIVEBACK__, __MP_WEIXIN_INACTIVEBACK__ } = useMpWeixinBack(${pageInfo.backConfig.initialValue})
-  `;
-  const configBack = (() => {
-    const onPageBack = pageInfo.backConfig.onPageBack;
-    if (!onPageBack)
-      return "";
-    if (typeof onPageBack !== "function") {
-      throw new Error("`onPageBack` must be a function");
-    }
-    const params = JSON.stringify({ page: context.getPageById(id) });
-    if (isArrowFunction(onPageBack) || onPageBack.toString().includes("function")) {
-      return `(${onPageBack})(${params});`;
-    }
-    return `(function ${onPageBack})()`;
-  })();
-  const stateBeforeLeave = `
-    const onBeforeLeave = () => {
-      if (!__MP_BACK_SHOW_PAGE_CONTAINER__.value) {
-        return
-      }
-      if (__MP_BACK_FREQUENCY__ < ${pageInfo.backConfig.frequency}) {
-        __MP_BACK_SHOW_PAGE_CONTAINER__.value = false
-        setTimeout(() => __MP_BACK_SHOW_PAGE_CONTAINER__.value = true, 0);
-        __MP_BACK_FREQUENCY__++
-      }
-      ${configBack}
-      ${callbackCode}
-    };
-  `;
-  const { template, scriptSetup } = sfc;
-  const tempOffsets = {
-    start: template.loc.start.offset,
-    end: template.loc.end.offset,
-    content: template.content
-  };
-  const templateMagicString = new MagicString(tempOffsets.content);
-  templateMagicString.append(pageContainerComp);
-  codeMs.overwrite(tempOffsets.start, tempOffsets.end, templateMagicString.toString());
-  const scriptOffsets = {
-    start: scriptSetup.loc.start.offset,
-    end: scriptSetup.loc.end.offset,
-    content: scriptSetup.content || ""
-  };
-  const scriptMagicString = new MagicString(scriptOffsets.content);
-  scriptMagicString.prepend(
-    ` ${importRefFromVue}
-      ${importUseMpWeixinBack}
-      ${stateFrequency}
-      ${statePageContainerVar}
-      ${stateBeforeLeave} `
-  );
-  activeFnCallsToModify.forEach((call) => {
-    const fnCallRegex = new RegExp(`${call.name}\\(([^)]*)\\)`, "g");
-    const newCall = call.original.replace(fnCallRegex, (_match, args) => {
-      if (!args.trim()) {
-        return `${call.name}(__MP_WEIXIN_ACTIVEBACK__)`;
-      }
-      return `${call.name}(__MP_WEIXIN_ACTIVEBACK__, ${args})`;
-    });
-    scriptMagicString.overwrite(call.start, call.end, newCall);
-  });
-  inActiveFnCallsToModify.forEach((call) => {
-    const fnCallRegex = new RegExp(`${call.name}\\(([^)]*)\\)`, "g");
-    const newCall = call.original.replace(fnCallRegex, (_match, args) => {
-      if (!args.trim()) {
-        return `${call.name}(__MP_WEIXIN_INACTIVEBACK__)`;
-      }
-      return `${call.name}(__MP_WEIXIN_INACTIVEBACK__, ${args})`;
-    });
-    scriptMagicString.overwrite(call.start, call.end, newCall);
-  });
-  codeMs.overwrite(scriptOffsets.start, scriptOffsets.end, scriptMagicString.toString());
-  return codeMs.toString();
-}
-function optionsWalk(context, code, sfc, id) {
-  const codeMs = new MagicString(code);
-  const ast = babelParse(sfc.script.loc.source, sfc.script.lang);
-  let pageInfo = {
-    hasPageBack: false,
-    pageBackFnName: "onPageBack",
-    backConfig: { ...context.config }
-  };
-  let exportDefaultNode = null;
-  let dataMethodNode = null;
-  let methodsNode = null;
-  let onPageBackNodeMethod = null;
-  let onPageBackNodeProperty = null;
-  if (ast) {
-    walkAST(ast, {
-      enter(node) {
-        if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "ObjectExpression") {
-          exportDefaultNode = node.declaration;
-          const properties = node.declaration.properties;
-          for (let i = 0; i < properties.length; i++) {
-            const element = properties[i];
-            if (element.type === "ObjectMethod" && element.key.type === "Identifier" && element.key.name === "data" && element.body.type === "BlockStatement") {
-              dataMethodNode = element.body;
-            }
-            if (element.type === "ObjectProperty" && element.key.type === "Identifier" && element.key.name === "methods") {
-              methodsNode = element.value;
-            }
-            const blockStatementCondition = element.type === "ObjectMethod" && element.key.type === "Identifier" && element.key.name === pageInfo.pageBackFnName && element.body.type === "BlockStatement";
-            const functionExpressionCondition = element.type === "ObjectProperty" && element.key.type === "Identifier" && element.key.name === pageInfo.pageBackFnName && element.value.type === "FunctionExpression";
-            if (blockStatementCondition) {
-              pageInfo.hasPageBack = true;
-              onPageBackNodeMethod = element;
-            }
-            if (functionExpressionCondition) {
-              pageInfo.hasPageBack = true;
-              onPageBackNodeProperty = element;
-            }
-          }
-        }
-      }
-    });
-  }
-  if (!pageInfo.hasPageBack)
-    return;
-  const newDataProperty = [
-    {
-      type: "ObjectProperty",
-      key: { type: "Identifier", name: "__MP_BACK_SHOW_PAGE_CONTAINER__" },
-      value: { type: "BooleanLiteral", value: true },
-      computed: false,
-      shorthand: false
-    },
-    {
-      type: "ObjectProperty",
-      key: { type: "Identifier", name: "__MP_BACK_FREQUENCY__" },
-      value: { type: "NumericLiteral", value: 1 },
-      computed: false,
-      shorthand: false
-    }
-  ];
-  if (dataMethodNode) {
-    const returnStatement = dataMethodNode.body.find(
-      (node) => node.type === "ReturnStatement"
-    );
-    if (returnStatement && returnStatement.argument && returnStatement.argument.type === "ObjectExpression") {
-      returnStatement.argument.properties.push(...newDataProperty);
-    }
-  } else if (exportDefaultNode) {
-    const addData = {
-      type: "ObjectMethod",
-      key: { type: "Identifier", name: "data" },
-      kind: "method",
-      params: [],
-      async: false,
-      generator: false,
-      computed: false,
-      body: {
-        type: "BlockStatement",
-        directives: [],
-        body: [
-          {
-            type: "ReturnStatement",
-            argument: {
-              type: "ObjectExpression",
-              properties: newDataProperty
-            }
-          }
-        ]
-      }
-    };
-    exportDefaultNode.properties.push(addData);
-  }
-  const configBack = (() => {
-    const onPageBack = pageInfo.backConfig.onPageBack;
-    if (!onPageBack)
-      return "";
-    if (typeof onPageBack !== "function") {
-      throw new Error("`onPageBack` must be a function");
-    }
-    const params = JSON.stringify({ page: context.getPageById(id) });
-    if (isArrowFunction(onPageBack) || onPageBack.toString().includes("function")) {
-      return `(${onPageBack})(${params});`;
-    }
-    return `(function ${onPageBack})()`;
-  })();
-  const stateBeforeLeave = `
-    function onBeforeLeave() {
-      if (this.__MP_BACK_FREQUENCY__ < ${pageInfo.backConfig.frequency}) {
-        this.__MP_BACK_SHOW_PAGE_CONTAINER__ = false
-        setTimeout(() => { this.__MP_BACK_SHOW_PAGE_CONTAINER__ = true }, 0);
-        this.__MP_BACK_FREQUENCY__++
-      }
-      ${configBack}
-      ${!pageInfo.backConfig.preventDefault ? "uni.navigateBack({ delta: 1 });" : ""}
-    };
-  `;
-  const stateBeforeLeaveAst = babelParse(stateBeforeLeave);
-  const stateBeforeLeaveNode = stateBeforeLeaveAst.body.find(
-    (node) => node.type === "FunctionDeclaration"
-  );
-  const newMethodsProperty = {
-    type: "ObjectMethod",
-    key: {
-      type: "Identifier",
-      name: "onBeforeLeave"
-    },
-    kind: "method",
-    generator: false,
-    async: false,
-    params: [],
-    computed: false,
-    body: {
-      type: "BlockStatement",
-      directives: [],
-      body: [
-        ...onPageBackNodeMethod ? onPageBackNodeMethod.body.body : [],
-        ...onPageBackNodeProperty ? onPageBackNodeProperty.value.body.body : [],
-        ...stateBeforeLeaveNode.body.body
-      ]
-    }
-  };
-  if (methodsNode) {
-    methodsNode.properties.push(newMethodsProperty);
-  } else if (exportDefaultNode) {
-    const addMethods = {
-      type: "ObjectProperty",
-      computed: false,
-      shorthand: false,
-      key: {
-        type: "Identifier",
-        name: "methods"
-      },
-      value: {
-        type: "ObjectExpression",
-        properties: [newMethodsProperty]
-      }
-    };
-    exportDefaultNode.properties.push(addMethods);
-  }
-  const { template, script } = sfc;
-  const tempOffsets = {
-    start: template.loc.start.offset,
-    end: template.loc.end.offset,
-    content: template.content
-  };
-  const templateMagicString = new MagicString(tempOffsets.content);
-  templateMagicString.append(pageContainerComp);
-  codeMs.overwrite(tempOffsets.start, tempOffsets.end, templateMagicString.toString());
-  const scriptOffsets = {
-    start: script.loc.start.offset,
-    end: script.loc.end.offset
-  };
-  const newScriptContent = (generate.default ? generate.default : generate)(ast).code;
-  codeMs.overwrite(scriptOffsets.start, scriptOffsets.end, newScriptContent);
-  return codeMs.toString();
-}
-const vueWalker = {
-  compositionWalk,
-  optionsWalk
-};
+import { parse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+import { babelParse } from 'ast-kit';
 
 let compilerPromise = null;
 async function resolveCompiler(root) {
@@ -407,10 +18,10 @@ async function resolveCompiler(root) {
       const _require = createRequire(import.meta.url);
       const compilerPath = _require.resolve("@vue/compiler-sfc", { paths: [root] });
       return _require(compilerPath);
-    } catch (firstError) {
+    } catch {
       try {
         return await import('@vue/compiler-sfc');
-      } catch (secondError) {
+      } catch {
         throw new Error(
           `[mp-weixin-back] Cannot resolve @vue/compiler-sfc.
 This plugin requires @vue/compiler-sfc to be installed in your project.
@@ -423,26 +34,489 @@ Docs: https://github.com/DBAAZzz/mp-weixin-back#%EF%B8%8F-vite-\u914D\u7F6E
   })();
   return compilerPromise;
 }
-async function transformVueFile(code, id) {
-  try {
-    const sfcCompiler = await resolveCompiler(this.config.root);
-    const sfc = sfcCompiler.parse(code).descriptor;
-    const { template, script, scriptSetup } = sfc;
-    if (!template?.content) {
-      return code;
+
+const virtualFileId = "mp-weixin-back-helper";
+const resolvedVirtualFileId = "\0" + virtualFileId;
+const ON_PAGE_BACK = "onPageBack";
+const BEFORE_LEAVE_HANDLER = "__MP_BACK_ON_BEFORE_LEAVE__";
+
+class MpBackConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MpBackConfigError";
+  }
+}
+
+const OPTION_TYPES = {
+  preventDefault: { nodeType: "BooleanLiteral", label: "\u5E03\u5C14" },
+  initialValue: { nodeType: "BooleanLiteral", label: "\u5E03\u5C14" },
+  frequency: { nodeType: "NumericLiteral", label: "\u6570\u5B57" }
+};
+function extractStaticOptions(node, where) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (prop.type === "SpreadElement") {
+      throw new MpBackConfigError(`${where}\uFF1AonPageBack \u914D\u7F6E\u4E0D\u652F\u6301\u5C55\u5F00\u8FD0\u7B97\u7B26\uFF0C\u914D\u7F6E\u5728\u6784\u5EFA\u671F\u9759\u6001\u8BFB\u53D6`);
+    }
+    if (prop.type === "ObjectMethod")
+      continue;
+    if (prop.computed) {
+      throw new MpBackConfigError(`${where}\uFF1AonPageBack \u914D\u7F6E\u4E0D\u652F\u6301\u8BA1\u7B97\u5C5E\u6027\u540D\uFF0C\u914D\u7F6E\u5728\u6784\u5EFA\u671F\u9759\u6001\u8BFB\u53D6`);
+    }
+    const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
+    if (key === null) {
+      throw new MpBackConfigError(`${where}\uFF1AonPageBack \u914D\u7F6E\u7684\u5C5E\u6027\u540D\u5FC5\u987B\u662F\u6807\u8BC6\u7B26\u6216\u5B57\u7B26\u4E32\u5B57\u9762\u91CF`);
+    }
+    if (!(key in OPTION_TYPES))
+      continue;
+    const expected = OPTION_TYPES[key];
+    const value = prop.value;
+    if (value.type === expected.nodeType) {
+      result[key] = value.value;
+    } else {
+      throw new MpBackConfigError(
+        `${where}\uFF1AonPageBack \u914D\u7F6E\u9879 ${key} \u5FC5\u987B\u662F${expected.label}\u5B57\u9762\u91CF\uFF08\u8BE5\u503C\u5728\u6784\u5EFA\u671F\u8BFB\u53D6\uFF0C\u6536\u5230 ${value.type}\uFF09\u3002\u5982\u9700\u8FD0\u884C\u65F6\u63A7\u5236\uFF0C\u8BF7\u4F7F\u7528 activeMpBack()/inactiveMpBack()`
+      );
+    }
+  }
+  return result;
+}
+
+const traverse$1 = _traverse.default ?? _traverse;
+const DEFAULT_PAGE_CONTAINER = {
+  zIndex: 1,
+  overlay: false,
+  duration: false
+};
+function buildPageContainerTag(options = {}) {
+  const pc = { ...DEFAULT_PAGE_CONTAINER, ...options };
+  return `<page-container :show="__MP_BACK_SHOW_PAGE_CONTAINER__" :overlay="${pc.overlay}" @beforeleave="${BEFORE_LEAVE_HANDLER}" :z-index="${pc.zIndex}" :duration="${pc.duration}"></page-container>`;
+}
+function injectPageContainer(ms, template, tag) {
+  ms.appendLeft(template.loc.end.offset, `
+  ${tag}
+`);
+}
+function buildCompositionBeforeLeave(cfg, globalHookCode) {
+  return `const ${BEFORE_LEAVE_HANDLER} = () => {
+  if (!__MP_BACK_SHOW_PAGE_CONTAINER__.value) return
+  if (__MP_BACK_FREQUENCY__ < ${cfg.frequency}) {
+    __MP_BACK_SHOW_PAGE_CONTAINER__.value = false
+    setTimeout(() => { __MP_BACK_SHOW_PAGE_CONTAINER__.value = true }, 0)
+    __MP_BACK_FREQUENCY__++
+  }
+  ${globalHookCode}
+  if (typeof __MP_BACK_CB__ === 'function') __MP_BACK_CB__()
+  ${cfg.preventDefault ? "" : "uni.navigateBack({ delta: 1 })"}
+};`;
+}
+function buildOptionsBeforeLeaveMethod(cfg, globalHookCode) {
+  return `${BEFORE_LEAVE_HANDLER}() {
+    if (!this.__MP_BACK_SHOW_PAGE_CONTAINER__) return
+    if (this.__MP_BACK_FREQUENCY__ < ${cfg.frequency}) {
+      this.__MP_BACK_SHOW_PAGE_CONTAINER__ = false
+      setTimeout(() => { this.__MP_BACK_SHOW_PAGE_CONTAINER__ = true }, 0)
+      this.__MP_BACK_FREQUENCY__++
+    }
+    ${globalHookCode}
+    const __mpBackOption = this.$options.onPageBack
+    const __mpBackHandler = typeof __mpBackOption === 'function' ? __mpBackOption : __mpBackOption && __mpBackOption.handler
+    if (typeof __mpBackHandler === 'function') __mpBackHandler.call(this)
+    ${cfg.preventDefault ? "" : "uni.navigateBack({ delta: 1 })"}
+  }`;
+}
+const KNOWN_GLOBALS = /* @__PURE__ */ new Set([
+  "uni",
+  "wx",
+  "getApp",
+  "getCurrentPages",
+  "requirePlugin",
+  "console",
+  "JSON",
+  "Math",
+  "Date",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "Promise",
+  "Reflect",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "NaN",
+  "Infinity",
+  "undefined",
+  "globalThis",
+  "setTimeout",
+  "clearTimeout",
+  "setInterval",
+  "clearInterval",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  "arguments"
+]);
+function serializeGlobalHook(context, page) {
+  const hook = context.config.onPageBack;
+  if (!hook)
+    return "";
+  if (typeof hook !== "function") {
+    throw new MpBackConfigError("\u63D2\u4EF6\u914D\u7F6E\u9879 onPageBack \u5FC5\u987B\u662F\u51FD\u6570");
+  }
+  const source = hook.toString();
+  const { expression, ast } = normalizeFunctionSource(source);
+  warnOnClosureReferences(context, ast);
+  const params = JSON.stringify({ page });
+  return `;(${expression})(${params});`;
+}
+function normalizeFunctionSource(source) {
+  const candidates = [
+    source,
+    `function ${source}`,
+    source.startsWith("async ") ? `async function ${source.slice("async ".length)}` : null
+  ].filter((c) => c !== null);
+  for (const candidate of candidates) {
+    try {
+      const ast = parse(`(${candidate});`, { sourceType: "module" });
+      return { expression: candidate, ast };
+    } catch {
+    }
+  }
+  throw new MpBackConfigError(
+    "\u65E0\u6CD5\u89E3\u6790\u63D2\u4EF6\u914D\u7F6E\u7684 onPageBack \u51FD\u6570\u6E90\u7801\uFF0C\u8BF7\u4F7F\u7528\u7BAD\u5934\u51FD\u6570\u3001function \u8868\u8FBE\u5F0F\u6216\u5BF9\u8C61\u65B9\u6CD5\u7B80\u5199"
+  );
+}
+function warnOnClosureReferences(context, ast) {
+  const unresolved = /* @__PURE__ */ new Set();
+  traverse$1(ast, {
+    Identifier(p) {
+      if (!p.isReferencedIdentifier())
+        return;
+      const name = p.node.name;
+      if (KNOWN_GLOBALS.has(name))
+        return;
+      if (p.scope.hasBinding(name))
+        return;
+      unresolved.add(name);
+    }
+  });
+  if (unresolved.size > 0) {
+    context.log.error(
+      `\u63D2\u4EF6\u914D\u7F6E\u7684 onPageBack \u5F15\u7528\u4E86\u5916\u90E8\u53D8\u91CF\uFF1A${[...unresolved].join(", ")}\u3002\u8BE5\u51FD\u6570\u4F1A\u88AB\u5E8F\u5217\u5316\u6CE8\u5165\u9875\u9762\uFF0C\u95ED\u5305\u53D8\u91CF\u5728\u8FD0\u884C\u65F6\u4E0D\u53EF\u7528\uFF0C\u8BF7\u8BA9\u51FD\u6570\u81EA\u5305\u542B\u3002`
+    );
+  }
+}
+
+const traverse = _traverse.default ?? _traverse;
+function compositionTransform(context, code, template, scriptSetup, id) {
+  const base = scriptSetup.loc.start.offset;
+  const ast = parseScript(scriptSetup.content, scriptSetup.lang);
+  const hasHelperImport = ast.program.body.some(
+    (stmt) => stmt.type === "ImportDeclaration" && stmt.source.value === virtualFileId
+  );
+  if (!hasHelperImport)
+    return;
+  const registerCalls = [];
+  const activeCalls = [];
+  const inactiveCalls = [];
+  traverse(ast, {
+    CallExpression(path) {
+      const exportName = resolveHelperCallee(path);
+      if (exportName === "onPageBack")
+        registerCalls.push(path.node);
+      else if (exportName === "activeMpBack")
+        activeCalls.push(path.node);
+      else if (exportName === "inactiveMpBack")
+        inactiveCalls.push(path.node);
+    }
+  });
+  if (registerCalls.length === 0) {
+    context.log.debugLog(`${id} import \u4E86 mp-weixin-back-helper \u4F46\u672A\u8C03\u7528 onPageBack\uFF0C\u8DF3\u8FC7\u6CE8\u5165`);
+    return;
+  }
+  let staticOptions = {};
+  let optionsFound = false;
+  for (const call of registerCalls) {
+    const optionsArg = call.arguments[1];
+    if (!optionsArg)
+      continue;
+    if (optionsArg.type !== "ObjectExpression") {
+      throw new MpBackConfigError(
+        `${id}\uFF1AonPageBack \u7684\u7B2C\u4E8C\u4E2A\u53C2\u6570\u5FC5\u987B\u662F\u5185\u8054\u5BF9\u8C61\u5B57\u9762\u91CF\uFF08\u914D\u7F6E\u5728\u6784\u5EFA\u671F\u9759\u6001\u8BFB\u53D6\uFF0C\u6536\u5230 ${optionsArg.type}\uFF09\u3002\u8BF7\u5199\u6210 onPageBack(cb, { preventDefault: true }) \u7684\u5F62\u5F0F`
+      );
+    }
+    if (optionsFound) {
+      context.log.error(`${id}\uFF1AonPageBack \u88AB\u591A\u6B21\u4F20\u5165\u914D\u7F6E\uFF0C\u4EC5\u7B2C\u4E00\u5904\u751F\u6548`);
+      continue;
+    }
+    staticOptions = extractStaticOptions(optionsArg, id);
+    optionsFound = true;
+  }
+  const cfg = {
+    preventDefault: context.config.preventDefault,
+    frequency: context.config.frequency,
+    initialValue: context.config.initialValue,
+    ...staticOptions
+  };
+  const ms = new MagicString(code);
+  injectPageContainer(ms, template, buildPageContainerTag(context.config.pageContainer));
+  for (const call of registerCalls) {
+    ms.overwrite(base + call.callee.start, base + call.callee.end, "__MP_BACK_REGISTER__");
+  }
+  for (const call of activeCalls) {
+    insertFirstArgument(ms, base, call, "__MP_WEIXIN_ACTIVEBACK__");
+  }
+  for (const call of inactiveCalls) {
+    insertFirstArgument(ms, base, call, "__MP_WEIXIN_INACTIVEBACK__");
+  }
+  const globalHookCode = serializeGlobalHook(context, context.getPageById(id));
+  const injected = `
+import { useMpWeixinBack } from '${virtualFileId}';
+let __MP_BACK_FREQUENCY__ = 1;
+let __MP_BACK_CB__ = null;
+const __MP_BACK_REGISTER__ = (cb) => { __MP_BACK_CB__ = cb };
+const { __MP_BACK_SHOW_PAGE_CONTAINER__, __MP_WEIXIN_ACTIVEBACK__, __MP_WEIXIN_INACTIVEBACK__ } = useMpWeixinBack(${cfg.initialValue});
+${buildCompositionBeforeLeave(cfg, globalHookCode)}
+`;
+  ms.appendRight(base, injected);
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true, source: id, includeContent: true })
+  };
+}
+function parseScript(content, lang) {
+  const plugins = [];
+  if (lang === "ts" || lang === "tsx")
+    plugins.push("typescript");
+  if (lang === "jsx" || lang === "tsx")
+    plugins.push("jsx");
+  return parse(content, { sourceType: "module", plugins });
+}
+function resolveHelperCallee(path) {
+  const callee = path.node.callee;
+  if (callee.type !== "Identifier")
+    return null;
+  const binding = path.scope.getBinding(callee.name);
+  if (!binding)
+    return null;
+  const declaration = binding.path;
+  const parent = declaration.parent;
+  if (parent?.type !== "ImportDeclaration" || parent.source.value !== virtualFileId)
+    return null;
+  if (declaration.isImportDefaultSpecifier())
+    return "onPageBack";
+  if (declaration.isImportSpecifier()) {
+    const imported = declaration.node.imported;
+    if (imported.type === "Identifier") {
+      if (imported.name === "activeMpBack")
+        return "activeMpBack";
+      if (imported.name === "inactiveMpBack")
+        return "inactiveMpBack";
     }
-    if (!script?.content && !scriptSetup?.content) {
-      return code;
+  }
+  return null;
+}
+function insertFirstArgument(ms, base, call, name) {
+  const firstArg = call.arguments[0];
+  if (firstArg) {
+    ms.appendLeft(base + firstArg.start, `${name}, `);
+  } else {
+    ms.appendLeft(base + call.end - 1, name);
+  }
+}
+
+function optionsTransform(context, code, template, script, id) {
+  const base = script.loc.start.offset;
+  const ast = babelParse(script.content, script.lang);
+  let componentObject = null;
+  for (const stmt of ast.body) {
+    if (stmt.type !== "ExportDefaultDeclaration")
+      continue;
+    if (stmt.declaration.type === "ObjectExpression") {
+      componentObject = stmt.declaration;
+    } else if (stmt.declaration.type === "CallExpression" && stmt.declaration.arguments[0]?.type === "ObjectExpression") {
+      componentObject = stmt.declaration.arguments[0];
     }
-    const walker = scriptSetup ? "compositionWalk" : "optionsWalk";
-    return vueWalker[walker](this, code, sfc, id);
-  } catch (error) {
-    this.log.error(
-      `Failed to transform ${id}. Please check the file is a valid Vue SFC.
-  Docs: https://github.com/DBAAZzz/mp-weixin-back#-\u5FEB\u901F\u5F00\u59CB`
+  }
+  if (!componentObject)
+    return;
+  let dataOption = null;
+  let methodsOption = null;
+  let onPageBackOption = null;
+  let dataIndex = -1;
+  let methodsIndex = -1;
+  let onPageBackIndex = -1;
+  let lastSpreadIndex = -1;
+  for (let index = 0; index < componentObject.properties.length; index++) {
+    const prop = componentObject.properties[index];
+    if (prop.type === "SpreadElement") {
+      lastSpreadIndex = index;
+      continue;
+    }
+    const name = propertyName(prop);
+    if (name === "data") {
+      dataOption = prop;
+      dataIndex = index;
+    }
+    if (name === "methods") {
+      methodsOption = prop;
+      methodsIndex = index;
+    }
+    if (name === ON_PAGE_BACK) {
+      onPageBackOption = prop;
+      onPageBackIndex = index;
+    }
+  }
+  if (!onPageBackOption)
+    return;
+  if (lastSpreadIndex > onPageBackIndex) {
+    throw new MpBackConfigError(
+      `${id}\uFF1AonPageBack \u4E4B\u540E\u5B58\u5728\u5BF9\u8C61\u5C55\u5F00\uFF08...\uFF09\uFF0C\u8FD0\u884C\u65F6\u5B9E\u9645\u751F\u6548\u7684\u56DE\u8C03\u53EF\u80FD\u4E0E\u6784\u5EFA\u671F\u8BFB\u53D6\u7684\u914D\u7F6E\u4E0D\u4E00\u81F4\uFF1B\u8BF7\u5C06\u5C55\u5F00\u79FB\u5230 onPageBack \u4E4B\u524D`
     );
-    this.log.error(String(error));
-    return code;
+  }
+  let staticOptions = {};
+  if (onPageBackOption.type === "ObjectProperty" && onPageBackOption.value.type === "ObjectExpression") {
+    staticOptions = extractStaticOptions(onPageBackOption.value, id);
+  }
+  const cfg = {
+    preventDefault: context.config.preventDefault,
+    frequency: context.config.frequency,
+    initialValue: context.config.initialValue,
+    ...staticOptions
+  };
+  const ms = new MagicString(code);
+  injectPageContainer(ms, template, buildPageContainerTag(context.config.pageContainer));
+  const stateProps = `__MP_BACK_SHOW_PAGE_CONTAINER__: ${cfg.initialValue}, __MP_BACK_FREQUENCY__: 1,`;
+  if (dataOption) {
+    if (lastSpreadIndex > dataIndex) {
+      throw new MpBackConfigError(
+        `${id}\uFF1Adata \u4E4B\u540E\u5B58\u5728\u5BF9\u8C61\u5C55\u5F00\uFF08...\uFF09\uFF0C\u6CE8\u5165\u7684\u62E6\u622A\u72B6\u6001\u53EF\u80FD\u5728\u8FD0\u884C\u65F6\u88AB\u8986\u76D6\uFF1B\u8BF7\u5C06\u5C55\u5F00\u79FB\u5230 data \u4E4B\u524D`
+      );
+    }
+    const dataReturn = resolveDataReturnObject(dataOption);
+    if (!dataReturn) {
+      throw new MpBackConfigError(
+        `${id}\uFF1Adata \u5FC5\u987B\u662F\u65B9\u6CD5\u6216\u8FD4\u56DE\u5BF9\u8C61\u5B57\u9762\u91CF\u7684\u51FD\u6570\uFF08\u652F\u6301 data() { return {...} }\u3001data: () => ({...})\u3001data: function () { return {...} }\uFF09\uFF0C\u5426\u5219\u65E0\u6CD5\u6CE8\u5165\u62E6\u622A\u72B6\u6001`
+      );
+    }
+    ms.appendRight(base + dataReturn.start + 1, `
+    ${stateProps}`);
+  } else {
+    if (lastSpreadIndex >= 0) {
+      throw new MpBackConfigError(
+        `${id}\uFF1A\u7EC4\u4EF6\u9009\u9879\u4F7F\u7528\u4E86\u5BF9\u8C61\u5C55\u5F00\uFF08...\uFF09\u4E14\u672A\u663E\u5F0F\u58F0\u660E data\uFF0C\u63D2\u4EF6\u65E0\u6CD5\u5B89\u5168\u6CE8\u5165\u62E6\u622A\u72B6\u6001\uFF1B\u8BF7\u663E\u5F0F\u58F0\u660E data() { return {} }`
+      );
+    }
+    ms.appendRight(
+      base + componentObject.start + 1,
+      `
+  data() {
+    return { ${stateProps} }
+  },`
+    );
+  }
+  const globalHookCode = serializeGlobalHook(context, context.getPageById(id));
+  const method = buildOptionsBeforeLeaveMethod(cfg, globalHookCode);
+  if (methodsOption) {
+    if (lastSpreadIndex > methodsIndex) {
+      throw new MpBackConfigError(
+        `${id}\uFF1Amethods \u4E4B\u540E\u5B58\u5728\u5BF9\u8C61\u5C55\u5F00\uFF08...\uFF09\uFF0C\u6CE8\u5165\u7684\u5904\u7406\u65B9\u6CD5\u53EF\u80FD\u5728\u8FD0\u884C\u65F6\u88AB\u8986\u76D6\uFF1B\u8BF7\u5C06\u5C55\u5F00\u79FB\u5230 methods \u4E4B\u524D`
+      );
+    }
+    const methodsObject = methodsOption.type === "ObjectProperty" && methodsOption.value.type === "ObjectExpression" ? methodsOption.value : null;
+    if (!methodsObject) {
+      throw new MpBackConfigError(
+        `${id}\uFF1Amethods \u5FC5\u987B\u662F\u5BF9\u8C61\u5B57\u9762\u91CF\uFF0C\u5426\u5219\u65E0\u6CD5\u6CE8\u5165\u8FD4\u56DE\u62E6\u622A\u7684\u5904\u7406\u65B9\u6CD5`
+      );
+    }
+    ms.appendRight(base + methodsObject.start + 1, `
+  ${method},`);
+  } else {
+    if (lastSpreadIndex >= 0) {
+      throw new MpBackConfigError(
+        `${id}\uFF1A\u7EC4\u4EF6\u9009\u9879\u4F7F\u7528\u4E86\u5BF9\u8C61\u5C55\u5F00\uFF08...\uFF09\u4E14\u672A\u663E\u5F0F\u58F0\u660E methods\uFF0C\u63D2\u4EF6\u65E0\u6CD5\u5B89\u5168\u6CE8\u5165\u8FD4\u56DE\u62E6\u622A\u7684\u5904\u7406\u65B9\u6CD5\uFF1B\u8BF7\u663E\u5F0F\u58F0\u660E methods: {}`
+      );
+    }
+    ms.appendRight(base + componentObject.start + 1, `
+  methods: {
+  ${method},
+  },`);
+  }
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true, source: id, includeContent: true })
+  };
+}
+function propertyName(prop) {
+  if (prop.type === "SpreadElement" || prop.computed)
+    return null;
+  if (prop.key.type === "Identifier")
+    return prop.key.name;
+  if (prop.key.type === "StringLiteral")
+    return prop.key.value;
+  return null;
+}
+function resolveDataReturnObject(dataOption) {
+  if (dataOption.type === "ObjectMethod") {
+    return findReturnObject(dataOption.body);
+  }
+  const value = dataOption.value;
+  if (value.type === "FunctionExpression") {
+    return findReturnObject(value.body);
+  }
+  if (value.type === "ArrowFunctionExpression") {
+    if (value.body.type === "ObjectExpression")
+      return value.body;
+    if (value.body.type === "BlockStatement")
+      return findReturnObject(value.body);
+  }
+  return null;
+}
+function findReturnObject(block) {
+  for (const stmt of block.body) {
+    if (stmt.type === "ReturnStatement" && stmt.argument?.type === "ObjectExpression") {
+      return stmt.argument;
+    }
+  }
+  return null;
+}
+
+async function transformVueFile(context, code, id) {
+  if (context.hasPages && context.getPageById(id) === null) {
+    context.log.debugLog(`${id} \u4E0D\u662F pages.json \u4E2D\u6CE8\u518C\u7684\u9875\u9762\uFF0C\u8DF3\u8FC7\u6CE8\u5165`);
+    return;
+  }
+  const compiler = await resolveCompiler(context.config.root);
+  const { descriptor } = compiler.parse(code, { filename: id });
+  const template = descriptor.template;
+  const script = descriptor.script;
+  const scriptSetup = descriptor.scriptSetup;
+  if (!template?.content)
+    return;
+  if (template.content.includes("<page-container")) {
+    context.log.debugLog(`${id} \u9875\u9762\u5DF2\u6709 page-container \u7EC4\u4EF6\uFF0C\u8DF3\u8FC7\u6CE8\u5165`);
+    return;
+  }
+  if (scriptSetup?.content) {
+    const result = compositionTransform(context, code, template, scriptSetup, id);
+    if (result)
+      return result;
+  }
+  if (script?.content) {
+    return optionsTransform(context, code, template, script, id);
   }
 }
 
@@ -452,11 +526,15 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-class pageContext {
+class PageContext {
   constructor(config) {
     __publicField(this, "logPreText", "[mp-weixin-back] : ");
     __publicField(this, "config");
     __publicField(this, "pages", []);
+    /** pages.json 的绝对路径；找不到时为 null（此时禁用页面级过滤） */
+    __publicField(this, "pagesJsonPath");
+    /** 页面源码目录相对 root 的前缀：CLI 项目为 'src'，HBuilderX 项目为 '' */
+    __publicField(this, "sourceBase", "src");
     __publicField(this, "log", {
       info: (text) => {
         console.log(white(this.logPreText + text));
@@ -471,60 +549,100 @@ class pageContext {
       }
     });
     this.config = config;
+    this.pagesJsonPath = this.resolvePagesJsonPath();
+  }
+  /** 依次探测 src/pages.json（CLI 项目）和 pages.json（HBuilderX 项目） */
+  resolvePagesJsonPath() {
+    for (const base of ["src", ""]) {
+      const candidate = path.join(this.config.root, base, "pages.json");
+      if (fs.existsSync(candidate)) {
+        this.sourceBase = base;
+        return candidate;
+      }
+    }
+    return null;
+  }
+  get hasPages() {
+    return this.pagesJsonPath !== null;
   }
-  getPagesJsonPath() {
-    const pagesJsonPath = path.join(this.config.root, "src/pages.json");
-    return pagesJsonPath;
+  isPagesJson(file) {
+    return this.pagesJsonPath !== null && path.normalize(file) === path.normalize(this.pagesJsonPath);
   }
-  // 获取页面配置详情
-  async getPagesJsonInfo() {
-    const hasPagesJson = fs.existsSync(this.getPagesJsonPath());
-    if (!hasPagesJson)
+  /** 读取并解析 pages.json；dev 下 pages.json 变更时会被重新调用 */
+  async loadPages() {
+    if (!this.pagesJsonPath) {
+      this.log.debugLog("\u672A\u627E\u5230 src/pages.json \u6216 pages.json\uFF0C\u7981\u7528\u9875\u9762\u7EA7\u8FC7\u6EE4\uFF08\u6240\u6709\u4F7F\u7528 helper \u7684 .vue \u6587\u4EF6\u90FD\u4F1A\u88AB\u5904\u7406\uFF09");
       return;
+    }
     try {
-      const content = await fs.promises.readFile(this.getPagesJsonPath(), "utf-8");
+      const content = await fs.promises.readFile(this.pagesJsonPath, "utf-8");
       const pagesContent = JSON5.parse(content);
-      const { pages, subpackages } = pagesContent;
-      if (pages) {
-        const mainPages = pages.reduce((acc, current) => {
-          acc.push(current.path);
-          return acc;
-        }, []);
-        this.pages.push(...mainPages);
+      const next = [];
+      for (const page of pagesContent.pages ?? []) {
+        next.push(page.path);
       }
-      if (subpackages) {
-        for (let i = 0; i < subpackages.length; i++) {
-          const element = subpackages[i];
-          const root = element.root;
-          const subPages = element.pages.reduce((acc, current) => {
-            acc.push(`${root}/${current.path}`.replace("//", "/"));
-            return acc;
-          }, []);
-          this.pages.push(...subPages);
+      const subpackages = [...pagesContent.subpackages ?? [], ...pagesContent.subPackages ?? []];
+      for (const sub of subpackages) {
+        for (const page of sub.pages ?? []) {
+          next.push(`${sub.root}/${page.path}`.replace("//", "/"));
         }
       }
+      this.pages = next;
+      this.log.debugLog(`\u5DF2\u52A0\u8F7D ${next.length} \u4E2A\u9875\u9762\uFF08${this.pagesJsonPath}\uFF09`);
     } catch (error) {
       this.log.error(
-        `Failed to read pages.json. Make sure src/pages.json exists and is valid JSON/JSON5.
-  Path checked: ${this.getPagesJsonPath()}
+        `Failed to read pages.json. Make sure it is valid JSON/JSON5.
+  Path checked: ${this.pagesJsonPath}
   Docs: https://github.com/DBAAZzz/mp-weixin-back#%EF%B8%8F-vite-\u914D\u7F6E`
       );
       this.log.debugLog(String(error));
     }
   }
-  // 获取指定id的page
+  /** 获取指定 id 对应的页面路径；不是已注册页面（或无 pages.json）时返回 null */
   getPageById(id) {
-    const path2 = (id.split("src/")[1] || "").replace(".vue", "");
-    return this.pages.find((i) => i === path2) || null;
+    if (!this.hasPages)
+      return null;
+    const filename = id.split("?")[0];
+    const rel = path.relative(path.join(this.config.root, this.sourceBase), filename).split(path.sep).join("/");
+    if (rel.startsWith(".."))
+      return null;
+    const pagePath = rel.replace(/\.vue$/, "");
+    return this.pages.includes(pagePath) ? pagePath : null;
   }
   async transform(code, id) {
-    const result = await transformVueFile.call(this, code, id);
-    return result;
+    return await transformVueFile(this, code, id);
   }
 }
 
+function virtualModuleCode(dev) {
+  return `
+import { ref } from 'vue'
+const __MP_BACK_DEV__ = ${dev}
+function __mpBackWarn(name) {
+  if (__MP_BACK_DEV__) {
+    console.warn('[mp-weixin-back] ' + name + ' \u672A\u751F\u6548\uFF1A\u8BE5\u6587\u4EF6\u672A\u88AB\u63D2\u4EF6\u7F16\u8BD1\u5904\u7406\u3002\u8BF7\u786E\u8BA4\u5B83\u662F pages.json \u4E2D\u6CE8\u518C\u7684\u9875\u9762\uFF0C\u4E14\u5F53\u524D\u6784\u5EFA\u5E73\u53F0\u4E3A mp-weixin\u3002')
+  }
+}
+export default function onPageBack() { __mpBackWarn('onPageBack') }
+export function activeMpBack(fn) {
+  if (typeof fn === 'function') fn()
+  else __mpBackWarn('activeMpBack')
+}
+export function inactiveMpBack(fn) {
+  if (typeof fn === 'function') fn()
+  else __mpBackWarn('inactiveMpBack')
+}
+export function useMpWeixinBack(initialValue = true) {
+  const __MP_BACK_SHOW_PAGE_CONTAINER__ = ref(initialValue)
+  const __MP_WEIXIN_ACTIVEBACK__ = () => { __MP_BACK_SHOW_PAGE_CONTAINER__.value = true }
+  const __MP_WEIXIN_INACTIVEBACK__ = () => { __MP_BACK_SHOW_PAGE_CONTAINER__.value = false }
+  return { __MP_BACK_SHOW_PAGE_CONTAINER__, __MP_WEIXIN_ACTIVEBACK__, __MP_WEIXIN_INACTIVEBACK__ }
+}
+`;
+}
 function MpBackPlugin(userOptions = {}) {
   let context;
+  let enabled = true;
   const defaultOptions = {
     initialValue: true,
     preventDefault: false,
@@ -536,58 +654,57 @@ function MpBackPlugin(userOptions = {}) {
     name: "vite-plugin-mp-weixin-back",
     enforce: "pre",
     configResolved(config) {
-      context = new pageContext({ ...options, mode: config.mode, root: config.root });
+      const platform = process.env.UNI_PLATFORM;
+      enabled = !platform || platform === "mp-weixin";
+      context = new PageContext({ ...options, mode: config.mode, root: config.root });
+      if (!enabled) {
+        context.log.info(`\u5F53\u524D\u6784\u5EFA\u5E73\u53F0\u4E3A ${platform}\uFF0C\u63D2\u4EF6\u5DF2\u7981\u7528\uFF08\u4FDD\u7559 no-op API \u4EE5\u4FDD\u8BC1\u4EE3\u7801\u53EF\u7F16\u8BD1\uFF09`);
+      }
     },
     buildStart() {
-      context.getPagesJsonInfo();
+      if (context.pagesJsonPath) {
+        this.addWatchFile(context.pagesJsonPath);
+      }
+      return context.loadPages();
+    },
+    async watchChange(id) {
+      if (context.isPagesJson(id)) {
+        await context.loadPages();
+      }
     },
     resolveId(id) {
       if (id === virtualFileId) {
-        return virtualFileId;
+        return resolvedVirtualFileId;
       }
     },
     load(id) {
-      if (id.includes("node_modules")) {
-        return;
-      }
-      if (id === virtualFileId) {
-        return `
-          import { ref } from 'vue'
-          export default function onPageBack() {}
-          export function activeMpBack(fn = null) {
-            fn?.()
-          }
-          export function inactiveMpBack(fn = null) {
-            fn?.()
-          }
-          export function useMpWeixinBack(initialValue = true) {
-            const __MP_BACK_SHOW_PAGE_CONTAINER__ = ref(initialValue)
-
-            const __MP_WEIXIN_ACTIVEBACK__ = () => {
-              __MP_BACK_SHOW_PAGE_CONTAINER__.value = true
-            }
-
-            const __MP_WEIXIN_INACTIVEBACK__ = () => {
-              __MP_BACK_SHOW_PAGE_CONTAINER__.value = false
-            }
-
-            return {
-              __MP_BACK_SHOW_PAGE_CONTAINER__,
-              __MP_WEIXIN_ACTIVEBACK__,
-              __MP_WEIXIN_INACTIVEBACK__
-            }
-          }
-        `;
+      if (id === resolvedVirtualFileId) {
+        return virtualModuleCode(context.config.mode !== "production");
       }
     },
     async transform(code, id) {
-      if (id.includes("node_modules") || !id.includes(".vue")) {
+      if (!enabled)
+        return;
+      const [filename, rawQuery] = id.split("?", 2);
+      if (filename.includes("node_modules"))
+        return;
+      if (!filename.endsWith(".vue"))
+        return;
+      if (rawQuery && new URLSearchParams(rawQuery).has("vue"))
+        return;
+      if (!code.includes(virtualFileId) && !code.includes(ON_PAGE_BACK))
+        return;
+      try {
+        return await context.transform(code, id);
+      } catch (error) {
+        if (error instanceof MpBackConfigError) {
+          this.error(`[mp-weixin-back] ${error.message}`);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        context.log.error(`Failed to transform ${id}: ${message}`);
+        this.warn(`[mp-weixin-back] \u8F6C\u6362 ${id} \u5931\u8D25\uFF0C\u8BE5\u9875\u9762\u7684\u8FD4\u56DE\u62E6\u622A\u672A\u751F\u6548\uFF1A${message}`);
         return;
       }
-      return {
-        code: await context.transform(code, id),
-        map: null
-      };
     }
   };
 }