#线上错误反解

import type { RsbuildPlugin, Rspack } from '@rsbuild/core';

const ASSET = 'debug-metadata.json';

export function pluginUploadDebugMetadata(
  upload: (json: string, assetName: string) => Promise<void>,
): RsbuildPlugin {
  return {
    name: 'upload-debug-metadata',
    setup(api) {
      api.modifyBundlerChain((chain, { environment, isProd }) => {
        const isLynx =
          environment.name === 'lynx' || environment.name.startsWith('lynx-');
        if (!isProd || !isLynx) return;

        chain.plugin('upload-debug-metadata').use(
          class {
            apply(compiler: Rspack.Compiler) {
              const { Compilation } = compiler.webpack;
              compiler.hooks.thisCompilation.tap('upload', (compilation) => {
                compilation.hooks.processAssets.tapPromise(
                  // 比默认插件的清理早一个 stage
                  {
                    name: 'upload',
                    stage: Compilation.PROCESS_ASSETS_STAGE_REPORT,
                  },
                  async (assets) => {
                    for (const name of Object.keys(assets)) {
                      if (name !== ASSET && !name.endsWith(`/${ASSET}`))
                        continue;
                      const json = compilation
                        .getAsset(name)
                        ?.source.source()
                        .toString();
                      if (json) await upload(json, name);
                    }
                  },
                );
              });
            }
          },
        );
      });
    },
  };
}

import crypto from 'node:crypto';
import path from 'node:path';
import type { RsbuildPlugin, Rspack } from '@rsbuild/core';

const ASSET = 'debug-metadata.json';

export function pluginHostDebugMetadata(opts: {
  baseUrl: string;
  upload: (json: string, key: string) => Promise<void>;
}): RsbuildPlugin {
  const { baseUrl, upload } = opts;
  return {
    name: 'host-debug-metadata',
    setup(api) {
      api.modifyBundlerChain((chain, { environment, isProd }) => {
        const isLynx =
          environment.name === 'lynx' || environment.name.startsWith('lynx-');
        if (!isProd || !isLynx) return;

        const exposed = api.useExposed<{
          LynxTemplatePlugin: {
            getLynxTemplatePluginHooks: (c: Rspack.Compilation) => {
              beforeEncode: { tap: (n: string, fn: (a: any) => any) => void };
            };
          };
        }>(Symbol.for('LynxTemplatePlugin'));
        if (!exposed) return;
        const { LynxTemplatePlugin } = exposed;

        chain
          .plugin('host-debug-metadata')
          .after('lynx:debug-metadata')
          .use(
            class {
              apply(compiler: Rspack.Compiler) {
                const { Compilation, sources } = compiler.webpack;
                const keyByAsset = new Map<string, string>();

                compiler.hooks.thisCompilation.tap('host-dm', (compilation) => {
                  const hooks =
                    LynxTemplatePlugin.getLynxTemplatePluginHooks(compilation);

                  hooks.beforeEncode.tap('host-dm', (args) => {
                    const assetName = path.posix.format({
                      dir: args.intermediate,
                      base: ASSET,
                    });
                    const content = compilation
                      .getAsset(assetName)
                      ?.source.source()
                      .toString();
                    if (!content) return args; // 不是 lynx 模板

                    const key = crypto
                      .createHash('sha1')
                      .update(content)
                      .digest('hex');
                    keyByAsset.set(assetName, key);
                    const fileUrl = `${baseUrl}/${key}/${ASSET}`;

                    const root = args.encodeData.lepusCode.root?.name;
                    const mainThread = root
                      ? path.posix.basename(root.replace(/\\/g, '/'))
                      : 'main-thread.js';

                    // 写进编码后的模板
                    args.encodeData.sourceContent.config.debugMetadataUrl =
                      fileUrl;
                    args.encodeData.compilerOptions.templateDebugUrl =
                      `${fileUrl}?field=bytecode-debug-info` +
                      `&filename=${encodeURIComponent(mainThread)}`;

                    // 把每个 JS 的 sourceMappingURL 注释重新指向托管地址
                    for (const a of JSON.parse(content).artifacts ?? []) {
                      if (!a.path?.endsWith('.js')) continue;
                      const name = a.path.replaceAll('/./', '/');
                      const asset = compilation.getAsset(name);
                      if (!asset) continue;
                      const before = asset.source.source().toString();
                      if (!before.includes('//# sourceMappingURL=')) continue;
                      const after = before.replace(
                        /\/\/# sourceMappingURL=\S*/g,
                        `//# sourceMappingURL=${fileUrl}?field=source-map` +
                          `&path=${encodeURIComponent(`${name}.map`)}`,
                      );
                      compilation.updateAsset(
                        name,
                        new sources.RawSource(after),
                        asset.info,
                      );
                    }
                    return args;
                  });

                  compilation.hooks.processAssets.tapPromise(
                    {
                      name: 'host-dm',
                      stage: Compilation.PROCESS_ASSETS_STAGE_REPORT,
                    },
                    async (assets) => {
                      for (const name of Object.keys(assets)) {
                        if (name !== ASSET && !name.endsWith(`/${ASSET}`))
                          continue;
                        const json = compilation
                          .getAsset(name)
                          ?.source.source()
                          .toString();
                        const key = keyByAsset.get(name);
                        if (json && key) await upload(json, key);
                      }
                    },
                  );
                });
              }
            },
          );
      });
    },
  };
}