@datadog/esbuild-plugin 2.3.0-dev → 2.3.0

package/dist/src/index.mjs

@@ -10823,7 +10823,7 @@ const glob = Object.assign(glob_, {
 glob.glob = glob;
 
 const EXTENSION_RX = /\.(?!.*(?:\.|\/|\\))(\w{1,})/g;
-const QUERY_RX = /(\?|!|%3F)+/gi;
+const QUERY_RX = /(\?|%3F|\|)+/gi;
 const getExtension = (filepath) => {
   EXTENSION_RX.lastIndex = 0;
   return EXTENSION_RX.exec(filepath)?.[1];
@@ -10837,14 +10837,83 @@ const getType = (name) => {
   }
   return getExtension(cleanPath(name)) || "unknown";
 };
+const serializeBuildReport = (report) => {
+  const jsonReport = {
+    errors: report.errors,
+    warnings: report.warnings,
+    start: report.start,
+    end: report.end,
+    duration: report.duration,
+    writeDuration: report.writeDuration,
+    entries: [],
+    inputs: [],
+    outputs: []
+  };
+  for (const entry of report.entries || []) {
+    const newEntry = { ...entry, inputs: [], outputs: [] };
+    if (entry.inputs) {
+      newEntry.inputs = entry.inputs.map((file) => file.filepath);
+    }
+    if (entry.outputs) {
+      newEntry.outputs = entry.outputs.map((file) => file.filepath);
+    }
+    jsonReport.entries.push(newEntry);
+  }
+  for (const input of report.inputs || []) {
+    const newInput = { ...input, dependencies: [], dependents: [] };
+    if (input.dependencies) {
+      for (const dependency of input.dependencies) {
+        newInput.dependencies.push(dependency.filepath);
+      }
+    }
+    if (input.dependents) {
+      for (const dependent of input.dependents) {
+        newInput.dependents.push(dependent.filepath);
+      }
+    }
+    jsonReport.inputs.push(newInput);
+  }
+  for (const output of report.outputs || []) {
+    const newOutput = { ...output, inputs: [] };
+    if (output.inputs) {
+      newOutput.inputs = output.inputs.map((file) => file.filepath);
+    }
+    jsonReport.outputs.push(newOutput);
+  }
+  return jsonReport;
+};
 const BUNDLER_SPECIFICS = ["unknown", "commonjsHelpers.js", "vite/preload-helper.js"];
-const cleanReport = (report, filepath) => {
-  return Array.from(new Set(report.map(cleanPath))).filter(
-    (reportFilepath) => reportFilepath !== filepath && !BUNDLER_SPECIFICS.includes(reportFilepath)
-  );
+const cleanReport = (report, filepath, filter) => {
+  const cleanedReport = /* @__PURE__ */ new Set();
+  for (const reportFilepath of report) {
+    const cleanedPath = cleanPath(reportFilepath);
+    if (
+      // Don't add itself into it.
+      cleanedPath === filepath || // Remove common specific files injected by bundlers.
+      BUNDLER_SPECIFICS.includes(cleanedPath)
+    ) {
+      continue;
+    }
+    if (filter) {
+      const filteredValue = filter(cleanedPath);
+      if (filteredValue) {
+        cleanedReport.add(filteredValue);
+      }
+    } else {
+      cleanedReport.add(cleanedPath);
+    }
+  }
+  return cleanedReport;
 };
 const cleanPath = (filepath) => {
-  return filepath.split(QUERY_RX).shift().replace(/^[^\w\s.,!@#$%^&*()=+~`\-/]+/, "");
+  return filepath.split("!").pop().split(QUERY_RX).shift().replace(/^[^\w\s.,!@#$%^&*()=+~`\-/]+/, "");
+};
+const getResolvedPath = (filepath) => {
+  try {
+    return require.resolve(filepath);
+  } catch (e) {
+    return filepath;
+  }
 };
 const cleanName = (context, filepath) => {
   if (filepath === "unknown") {
@@ -10853,12 +10922,7 @@ const cleanName = (context, filepath) => {
   if (filepath.includes("webpack/runtime")) {
     return filepath.replace("webpack/runtime/", "").replace(/ +/g, "-");
   }
-  let resolvedPath = filepath;
-  try {
-    resolvedPath = require.resolve(filepath);
-  } catch (e) {
-  }
-  return resolvedPath.replace(context.bundler.outDir, "").replace(context.cwd, "").split("node_modules").pop().split("?").shift().replace(/^\/+/, "");
+  return filepath.split("!").pop().replace(context.bundler.outDir, "").replace(context.cwd, "").split("node_modules").pop().split(QUERY_RX).shift().replace(/^\/+/, "");
 };
 
 const reIndexMeta = (obj, cwd) => Object.fromEntries(
@@ -10881,7 +10945,7 @@ const getEntryNames = (entrypoints, context) => {
       const fullPath = entry && typeof entry === "object" ? entry.in : entry;
       const allFiles = getAllEntryFiles(fullPath, context.cwd);
       for (const file of allFiles) {
-        const cleanedName = cleanName(context, file);
+        const cleanedName = cleanName(context, getResolvedPath(file));
         entryNames.set(cleanedName, cleanedName);
       }
     }
@@ -10890,7 +10954,7 @@ const getEntryNames = (entrypoints, context) => {
     for (const [entryName, entryPath] of entryList) {
       const allFiles = getAllEntryFiles(entryPath, context.cwd);
       for (const file of allFiles) {
-        const cleanedName = cleanName(context, file);
+        const cleanedName = cleanName(context, getResolvedPath(file));
         entryNames.set(cleanedName, entryName);
       }
     }
@@ -10928,8 +10992,8 @@ const getEsbuildPlugin$2 = (context, log) => {
           const file = {
             name: cleanName(context, filename),
             filepath,
-            dependents: [],
-            dependencies: [],
+            dependents: /* @__PURE__ */ new Set(),
+            dependencies: /* @__PURE__ */ new Set(),
             size: input.bytes,
             type: getType(filename)
           };
@@ -11004,7 +11068,17 @@ const getEsbuildPlugin$2 = (context, log) => {
             meta: metaOutputsIndexed
           }
         };
+        const FILE_EXCEPTIONS_RX = /(<runtime>|https:|file:|data:|#)/g;
+        const isFileSupported = (filePath) => {
+          if (filePath.match(FILE_EXCEPTIONS_RX)) {
+            return false;
+          }
+          return true;
+        };
         const getAllImports = (filePath, ref, allImports = {}) => {
+          if (!isFileSupported(filePath)) {
+            return allImports;
+          }
           const file = ref.report[filePath];
           if (!file) {
             warn(`Could not find report's ${filePath}`);
@@ -11056,14 +11130,17 @@ const getEsbuildPlugin$2 = (context, log) => {
             continue;
           }
           for (const dependency of metaFile.imports) {
+            if (!isFileSupported(dependency.path)) {
+              continue;
+            }
             const dependencyPath = path$i.join(cwd, dependency.path);
             const dependencyFile = references.inputs.report[dependencyPath];
             if (!dependencyFile) {
               warn(`Could not find input file of ${dependency.path}`);
               continue;
             }
-            input.dependencies.push(dependencyFile);
-            dependencyFile.dependents.push(input);
+            input.dependencies.add(dependencyFile);
+            dependencyFile.dependents.add(input);
           }
         }
         context.build.outputs = outputs;
@@ -11090,19 +11167,23 @@ const getRollupPlugin$1 = (context, log) => {
     moduleParsed(info) {
       const cleanId = cleanPath(info.id);
       const report = importsReport[cleanId] || {
-        dependencies: [],
-        dependents: []
+        dependencies: /* @__PURE__ */ new Set(),
+        dependents: /* @__PURE__ */ new Set()
       };
       const newDependencies = cleanReport(
-        [...info.dynamicallyImportedIds, ...info.importedIds],
+        /* @__PURE__ */ new Set([...info.dynamicallyImportedIds, ...info.importedIds]),
         cleanId
-      ).filter((dependency) => !report.dependencies.includes(dependency));
+      );
       const newDependents = cleanReport(
-        [...info.dynamicImporters, ...info.importers],
+        /* @__PURE__ */ new Set([...info.dynamicImporters, ...info.importers]),
         cleanId
-      ).filter((dependent) => !report.dependents.includes(dependent));
-      report.dependencies.push(...newDependencies);
-      report.dependents.push(...newDependents);
+      );
+      for (const dependent of newDependents) {
+        report.dependents.add(dependent);
+      }
+      for (const dependency of newDependencies) {
+        report.dependencies.add(dependency);
+      }
       importsReport[cleanId] = report;
     },
     writeBundle(options, bundle) {
@@ -11121,22 +11202,28 @@ const getRollupPlugin$1 = (context, log) => {
         for (const dependency of dependencies) {
           const cleanedDependency = cleanPath(dependency);
           if (!importsReport[cleanedDependency]) {
-            importsReport[cleanedDependency] = { dependencies: [], dependents: [] };
+            importsReport[cleanedDependency] = {
+              dependencies: /* @__PURE__ */ new Set(),
+              dependents: /* @__PURE__ */ new Set()
+            };
           }
-          if (importsReport[cleanedDependency].dependents.includes(filepath)) {
+          if (importsReport[cleanedDependency].dependents.has(filepath)) {
             continue;
           }
-          importsReport[cleanedDependency].dependents.push(filepath);
+          importsReport[cleanedDependency].dependents.add(filepath);
         }
         for (const dependent of dependents) {
           const cleanedDependent = cleanPath(dependent);
           if (!importsReport[cleanedDependent]) {
-            importsReport[cleanedDependent] = { dependencies: [], dependents: [] };
+            importsReport[cleanedDependent] = {
+              dependencies: /* @__PURE__ */ new Set(),
+              dependents: /* @__PURE__ */ new Set()
+            };
           }
-          if (importsReport[cleanedDependent].dependencies.includes(filepath)) {
+          if (importsReport[cleanedDependent].dependencies.has(filepath)) {
             continue;
           }
-          importsReport[cleanedDependent].dependencies.push(filepath);
+          importsReport[cleanedDependent].dependencies.add(filepath);
         }
       }
       for (const [filename, asset] of Object.entries(bundle)) {
@@ -11159,8 +11246,8 @@ const getRollupPlugin$1 = (context, log) => {
             }
             const moduleFile = {
               name: cleanName(context, modulepath),
-              dependencies: [],
-              dependents: [],
+              dependencies: /* @__PURE__ */ new Set(),
+              dependents: /* @__PURE__ */ new Set(),
               filepath: modulepath,
               // Since we store as input, we use the originalLength.
               size: module.originalLength,
@@ -11191,7 +11278,7 @@ const getRollupPlugin$1 = (context, log) => {
             );
             continue;
           }
-          input.dependencies.push(foundInput);
+          input.dependencies.add(foundInput);
         }
         for (const dependent of importReport.dependents) {
           const foundInput = reportInputsIndexed[dependent];
@@ -11201,7 +11288,7 @@ const getRollupPlugin$1 = (context, log) => {
             );
             continue;
           }
-          input.dependents.push(foundInput);
+          input.dependents.add(foundInput);
         }
       }
       if (tempSourcemaps.length) {
@@ -11279,34 +11366,58 @@ const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
       chunkGroupChildren: true,
       chunkGroups: true,
       chunkModules: true,
+      chunkRelations: true,
       entrypoints: true,
       errors: true,
       ids: true,
       modules: true,
+      nestedModules: true,
       reasons: true,
       relatedAssets: true,
-      runtime: true,
-      runtimeModules: true,
       warnings: true
     });
     const chunks = stats.chunks || [];
-    const assets = stats.assets ? [...stats.assets] : [];
-    const modules = stats.modules || [];
+    const assets = compilation.getAssets();
+    const modules = [];
     const entrypoints = stats.entrypoints || [];
     const tempSourcemaps = [];
     const tempDeps = {};
     const reportInputsIndexed = {};
     const reportOutputsIndexed = {};
-    if (context.bundler.variant === "5" && stats.assets) {
-      for (const asset of stats.assets) {
-        if (asset.related) {
-          assets.push(...asset.related);
+    const modulePerId = /* @__PURE__ */ new Map();
+    const modulePerIdentifier = /* @__PURE__ */ new Map();
+    const concatModulesPerId = /* @__PURE__ */ new Map();
+    const concatModulesPerIdentifier = /* @__PURE__ */ new Map();
+    for (const module of stats.modules || []) {
+      if (module.modules) {
+        if (module.id) {
+          concatModulesPerId.set(module.id, module.modules);
+        }
+        if (module.identifier) {
+          concatModulesPerIdentifier.set(module.identifier, module.modules);
+        }
+        for (const subModule of module.modules) {
+          modules.push(subModule);
+          if (subModule.id) {
+            modulePerId.set(subModule.id, subModule);
+          }
+          if (subModule.identifier) {
+            modulePerIdentifier.set(subModule.identifier, subModule);
+          }
+        }
+      } else {
+        modules.push(module);
+        if (module.id) {
+          modulePerId.set(module.id, module);
+        }
+        if (module.identifier) {
+          modulePerIdentifier.set(module.identifier, module);
         }
       }
     }
     for (const asset of assets) {
       const file = {
-        size: asset.size,
+        size: asset.info.size || 0,
         name: asset.name,
         inputs: [],
         filepath: path$i.join(context.bundler.outDir, asset.name),
@@ -11321,38 +11432,77 @@ const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
     for (const sourcemap of tempSourcemaps) {
       const outputFound = reportOutputsIndexed[sourcemap.filepath.replace(/\.map$/, "")];
       if (!outputFound) {
-        warn(`Output not found for ${sourcemap.name}`);
+        warn(`Output not found for sourcemap ${sourcemap.name}`);
         continue;
       }
       sourcemap.inputs.push(outputFound);
     }
+    const getModulePath = (module) => {
+      return module.nameForCondition ? module.nameForCondition : module.name ? path$i.join(context.cwd, module.name) : module.identifier ? module.identifier : "unknown";
+    };
+    const getModules = (reason) => {
+      const { moduleIdentifier, moduleId } = reason;
+      if (!moduleIdentifier && !moduleId) {
+        return [];
+      }
+      const modulesFound = [];
+      if (moduleId) {
+        const module = modulePerId.get(moduleId);
+        if (module) {
+          modulesFound.push(module);
+        }
+        const concatModules = concatModulesPerId.get(moduleId);
+        if (concatModules) {
+          modulesFound.push(...concatModules);
+        }
+      }
+      if (moduleIdentifier) {
+        const module = modulePerIdentifier.get(moduleIdentifier);
+        if (module) {
+          modulesFound.push(module);
+        }
+        const concatModules = concatModulesPerIdentifier.get(moduleIdentifier);
+        if (concatModules) {
+          modulesFound.push(...concatModules);
+        }
+      }
+      return Array.from(new Set(modulesFound.map(getModulePath)));
+    };
+    const modulesDone = /* @__PURE__ */ new Set();
     for (const module of modules) {
-      if (module.moduleType === "runtime" || module.name?.startsWith("(webpack)")) {
+      if (module.moduleType === "runtime" || module.name?.startsWith("(webpack)") || module.type === "orphan modules") {
+        continue;
+      }
+      const modulePath = getModulePath(module);
+      if (modulesDone.has(modulePath)) {
         continue;
       }
-      const modulePath = module.identifier ? module.identifier : module.name ? path$i.join(context.cwd, module.name) : "unknown";
+      modulesDone.add(modulePath);
       if (modulePath === "unknown") {
         warn(`Unknown module: ${JSON.stringify(module)}`);
       }
       if (module.reasons) {
-        const moduleDeps = tempDeps[modulePath] || { dependencies: [], dependents: [] };
-        const reasons = module.reasons.map((reason) => {
-          const reasonName = reason.resolvedModuleIdentifier ? reason.resolvedModuleIdentifier : reason.moduleIdentifier ? reason.moduleIdentifier : reason.resolvedModule ? path$i.join(context.cwd, reason.resolvedModule) : "unknown";
-          return reasonName;
-        }).filter((reason) => reason !== "unknown");
-        for (const reason of reasons) {
-          const reasonDeps = tempDeps[reason] || { dependencies: [], dependents: [] };
-          reasonDeps.dependencies.push(modulePath);
-          tempDeps[reason] = reasonDeps;
-        }
-        moduleDeps.dependents.push(...reasons);
+        const moduleDeps = tempDeps[modulePath] || {
+          dependencies: /* @__PURE__ */ new Set(),
+          dependents: /* @__PURE__ */ new Set()
+        };
+        const dependents = module.reasons.flatMap(getModules);
+        for (const dependent of dependents) {
+          const reasonDeps = tempDeps[dependent] || {
+            dependencies: /* @__PURE__ */ new Set(),
+            dependents: /* @__PURE__ */ new Set()
+          };
+          reasonDeps.dependencies.add(modulePath);
+          tempDeps[dependent] = reasonDeps;
+          moduleDeps.dependents.add(dependent);
+        }
         tempDeps[modulePath] = moduleDeps;
       }
       const file = {
         size: module.size || 0,
         name: cleanName(context, modulePath),
-        dependencies: [],
-        dependents: [],
+        dependencies: /* @__PURE__ */ new Set(),
+        dependents: /* @__PURE__ */ new Set(),
         filepath: modulePath,
         type: getType(modulePath)
       };
@@ -11370,7 +11520,9 @@ const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
           warn(`Output not found for ${file.name}`);
           continue;
         }
-        outputFound.inputs.push(file);
+        if (!outputFound.inputs.includes(file)) {
+          outputFound.inputs.push(file);
+        }
       }
       reportInputsIndexed[modulePath] = file;
       inputs.push(file);
@@ -11388,10 +11540,8 @@ const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
         warn(`Could not find dependency report for ${input.name}`);
         continue;
       }
-      input.dependencies = cleanReport(depsReport.dependencies, input.filepath).map(
-        getInput
-      );
-      input.dependents = cleanReport(depsReport.dependents, input.filepath).map(getInput);
+      input.dependencies = cleanReport(depsReport.dependencies, input.filepath, getInput);
+      input.dependents = cleanReport(depsReport.dependents, input.filepath, getInput);
     }
     for (const [name, entry] of Object.entries(entrypoints)) {
       const entryOutputs = [];
@@ -11414,21 +11564,21 @@ const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
         }
         const outputFound = reportOutputsIndexed[assetPath];
         if (outputFound) {
-          if (outputFound.type !== "map") {
+          if (outputFound.type !== "map" && !entryOutputs.includes(outputFound)) {
             entryOutputs.push(outputFound);
             entryInputs.push(...outputFound.inputs);
             size += outputFound.size;
           }
         }
       }
-      const assetFound = assets.find((asset) => asset.chunkNames?.includes(name));
+      const entryFilename = stats.assetsByChunkName?.[name]?.[0];
       const file = {
         name,
-        filepath: assetFound ? path$i.join(context.bundler.outDir, assetFound.name) : "unknown",
+        filepath: entryFilename ? path$i.join(context.bundler.outDir, entryFilename) : "unknown",
         size,
-        inputs: entryInputs,
+        inputs: Array.from(new Set(entryInputs)),
         outputs: entryOutputs,
-        type: assetFound ? getType(assetFound.name) : "unknown"
+        type: entryFilename ? getType(entryFilename) : "unknown"
       };
       entries.push(file);
     }
@@ -11438,7 +11588,7 @@ const getWebpackPlugin$2 = (context, PLUGIN_NAME, log) => (compiler) => {
   });
 };
 
-const PLUGIN_NAME$3 = "build-report";
+const PLUGIN_NAME$3 = "datadog-build-report-plugin";
 const getBuildReportPlugin = (opts, context) => {
   const log = getLogger(opts.logLevel, PLUGIN_NAME$3);
   return {
@@ -18343,7 +18493,7 @@ const getRepositoryData = async (git, repositoryURL) => {
 
 const getGitPlugin = (options, context) => {
   return {
-    name: "git-plugin",
+    name: "datadog-git-plugin",
     enforce: "pre",
     async buildStart() {
       const shouldGetGitInfo = options.rum?.sourcemaps && options.disableGit !== true;
@@ -18356,7 +18506,7 @@ const getGitPlugin = (options, context) => {
   };
 };
 
-const PLUGIN_NAME$2 = "context-plugin";
+const PLUGIN_NAME$2 = "datadog-context-plugin";
 const rollupPlugin = (context) => ({
   options(options) {
     context.bundler.rawConfig = options;
@@ -18376,9 +18526,6 @@ const getGlobalContextPlugin = (opts, meta) => {
   const variant = meta.framework === "webpack" ? meta.webpack.compiler["webpack"] ? "5" : "4" : "";
   const globalContext = {
     auth: opts.auth,
-    start: Date.now(),
-    cwd,
-    version: meta.version,
     bundler: {
       name: meta.framework,
       fullName: `${meta.framework}${variant}`,
@@ -18388,7 +18535,10 @@ const getGlobalContextPlugin = (opts, meta) => {
     build: {
       errors: [],
       warnings: []
-    }
+    },
+    cwd,
+    start: Date.now(),
+    version: meta.version
   };
   const globalContextPlugin = {
     name: PLUGIN_NAME$2,
@@ -23299,31 +23449,6 @@ const getLoaders = (loaders) => {
   return metrics;
 };
 
-const getModuleEntryTags = (file, entries) => {
-  const entryNames = entries.filter((entry) => {
-    const foundModules = entry.inputs.filter((input) => {
-      return input.name === file.name;
-    });
-    return foundModules.length;
-  }).map((entry) => entry.name);
-  return Array.from(new Set(entryNames)).map((entryName) => `entryName:${entryName}`);
-};
-const getAssetEntryTags = (file, entries) => {
-  const cleanAssetName = file.name.replace(/\.map$/, "");
-  const entryNames = entries.filter((entry) => {
-    const foundModules = entry.outputs.filter((output) => {
-      return output.name === cleanAssetName;
-    });
-    return foundModules.length;
-  }).map((entry) => entry.name);
-  return Array.from(new Set(entryNames)).map((entryName) => `entryName:${entryName}`);
-};
-const getModuleAssetTags = (file, outputs) => {
-  const assetNames = outputs.filter((output) => {
-    return output.inputs.find((input) => input.filepath === file.filepath);
-  }).map((output) => output.name);
-  return Array.from(new Set(assetNames)).map((assetName) => `assetName:${assetName}`);
-};
 const getUniversalMetrics = (globalContext) => {
   const metrics = [];
   const inputs = globalContext.build.inputs || [];
@@ -23332,6 +23457,32 @@ const getUniversalMetrics = (globalContext) => {
   const nbWarnings = globalContext.build.warnings.length;
   const nbErrors = globalContext.build.errors.length;
   const duration = globalContext.build.duration;
+  const entriesPerInput = /* @__PURE__ */ new Map();
+  const assetsPerInput = /* @__PURE__ */ new Map();
+  const entriesPerAsset = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const input of entry.inputs) {
+      if (!entriesPerInput.has(input.filepath)) {
+        entriesPerInput.set(input.filepath, []);
+      }
+      entriesPerInput.get(input.filepath).push(entry.name);
+    }
+    for (const output of entry.outputs) {
+      const cleanAssetName = output.filepath.replace(/\.map$/, "");
+      if (!entriesPerAsset.has(cleanAssetName)) {
+        entriesPerAsset.set(cleanAssetName, []);
+      }
+      entriesPerAsset.get(cleanAssetName).push(entry.name);
+    }
+  }
+  for (const output of outputs) {
+    for (const input of output.inputs) {
+      if (!assetsPerInput.has(input.filepath)) {
+        assetsPerInput.set(input.filepath, []);
+      }
+      assetsPerInput.get(input.filepath).push(output.name);
+    }
+  }
   metrics.push(
     {
       metric: "assets.count",
@@ -23373,12 +23524,17 @@ const getUniversalMetrics = (globalContext) => {
     });
   }
   for (const input of inputs) {
-    const tags = [
-      `moduleName:${input.name}`,
-      `moduleType:${input.type}`,
-      ...getModuleEntryTags(input, entries),
-      ...getModuleAssetTags(input, outputs)
-    ];
+    const tags = [`moduleName:${input.name}`, `moduleType:${input.type}`];
+    if (entriesPerInput.has(input.filepath)) {
+      tags.push(
+        ...entriesPerInput.get(input.filepath).map((entryName) => `entryName:${entryName}`)
+      );
+    }
+    if (assetsPerInput.has(input.filepath)) {
+      tags.push(
+        ...assetsPerInput.get(input.filepath).map((assetName) => `assetName:${assetName}`)
+      );
+    }
     metrics.push(
       {
         metric: "modules.size",
@@ -23389,38 +23545,37 @@ const getUniversalMetrics = (globalContext) => {
       {
         metric: "modules.dependencies",
         type: "count",
-        value: input.dependencies.length,
+        value: input.dependencies.size,
         tags
       },
       {
         metric: "modules.dependents",
         type: "count",
-        value: input.dependents.length,
+        value: input.dependents.size,
         tags
       }
     );
   }
   for (const output of outputs) {
+    const tags = [`assetName:${output.name}`, `assetType:${output.type}`];
+    const cleanAssetName = output.filepath.replace(/\.map$/, "");
+    if (entriesPerAsset.has(cleanAssetName)) {
+      tags.push(
+        ...entriesPerAsset.get(cleanAssetName).map((entryName) => `entryName:${entryName}`)
+      );
+    }
     metrics.push(
       {
         metric: "assets.size",
         type: "size",
         value: output.size,
-        tags: [
-          `assetName:${output.name}`,
-          `assetType:${output.type}`,
-          ...getAssetEntryTags(output, entries)
-        ]
+        tags
       },
       {
         metric: "assets.modules.count",
         type: "count",
         value: output.inputs.length,
-        tags: [
-          `assetName:${output.name}`,
-          `assetType:${output.type}`,
-          ...getAssetEntryTags(output, entries)
-        ]
+        tags
       }
     );
   }
@@ -23661,6 +23816,7 @@ var prettyBytes = (number, options) => {
 var prettyBytes$1 = /*@__PURE__*/getDefaultExportFromCjs(prettyBytes);
 
 const TOP = 5;
+const MAX_VALUE_LENGTH = 60;
 const numColor = chalk.bold.red;
 const nameColor = chalk.bold.cyan;
 const sortDesc = (attr) => (a, b) => {
@@ -23737,7 +23893,7 @@ const getGeneralValues = (context) => {
 const getAssetsValues = (context) => {
   const assetSizesToPrint = {
     name: "Asset size",
-    values: (context.build.outputs || []).sort(sortDesc((output) => output.size)).map((output) => ({
+    values: (context.build.outputs || []).filter((output) => output.type !== "map").sort(sortDesc((output) => output.size)).map((output) => ({
       name: output.name,
       value: prettyBytes$1(output.size)
     })),
@@ -23761,17 +23917,6 @@ const getAssetsValues = (context) => {
   };
   return [assetSizesToPrint, entrySizesToPrint, entryModulesToPrint];
 };
-const getAll = (attribute, collection, filepath, accumulator = []) => {
-  const reported = collection[filepath]?.[attribute] || [];
-  for (const reportedFilename of reported) {
-    if (accumulator.includes(reportedFilename) || reportedFilename === filepath) {
-      continue;
-    }
-    accumulator.push(reportedFilename);
-    getAll(attribute, collection, reportedFilename, accumulator);
-  }
-  return accumulator;
-};
 const getModulesValues = (context) => {
   const dependentsToPrint = {
     name: `Module total dependents`,
@@ -23793,55 +23938,86 @@ const getModulesValues = (context) => {
     values: [],
     top: true
   };
-  const dependencies = [];
-  const inputs = Object.fromEntries(
-    (context.build.inputs || []).map((input) => [
-      input.filepath,
-      {
-        name: input.name,
-        size: input.size,
-        dependencies: input.dependencies.map((dep) => dep.filepath),
-        dependents: input.dependents.map((dep) => dep.filepath)
-      }
-    ])
-  );
-  for (const filepath in inputs) {
-    if (!Object.hasOwn(inputs, filepath)) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const serializedReport = serializeBuildReport(context.build);
+  const inputs = /* @__PURE__ */ new Map();
+  const fileDependencies = /* @__PURE__ */ new Map();
+  const fileDependents = /* @__PURE__ */ new Map();
+  for (const input of serializedReport.inputs || []) {
+    if (input.type === "map") {
       continue;
     }
-    const fileDependencies = getAll("dependencies", inputs, filepath);
-    const aggregatedSize = fileDependencies.reduce(
-      (acc, dep) => acc + inputs[dep].size,
-      inputs[filepath].size
-    );
-    dependencies.push({
-      name: inputs[filepath].name,
-      size: inputs[filepath].size,
+    const dependenciesSet = new Set(input.dependencies);
+    const dependentsSet = new Set(input.dependents);
+    for (const dep of dependenciesSet) {
+      if (!fileDependents.has(dep)) {
+        fileDependents.set(dep, /* @__PURE__ */ new Set());
+      }
+      fileDependents.get(dep).add(input.filepath);
+    }
+    for (const dep of dependentsSet) {
+      if (!fileDependencies.has(dep)) {
+        fileDependencies.set(dep, /* @__PURE__ */ new Set());
+      }
+      fileDependencies.get(dep).add(input.filepath);
+    }
+    if (fileDependencies.has(input.filepath)) {
+      const existingDependencies = fileDependencies.get(input.filepath);
+      for (const dep of existingDependencies) {
+        dependenciesSet.add(dep);
+      }
+    }
+    if (fileDependents.has(input.filepath)) {
+      const existingDependents = fileDependents.get(input.filepath);
+      for (const dep of existingDependents) {
+        dependentsSet.add(dep);
+      }
+    }
+    fileDependencies.set(input.filepath, dependenciesSet);
+    fileDependents.set(input.filepath, dependentsSet);
+    inputs.set(input.filepath, {
+      name: input.name,
+      size: input.size,
+      dependencies: dependenciesSet,
+      dependents: dependentsSet
+    });
+  }
+  for (const [filepath, input] of inputs) {
+    const inputDependencies = fileDependencies.get(filepath) || /* @__PURE__ */ new Set();
+    const inputDependents = fileDependents.get(filepath) || /* @__PURE__ */ new Set();
+    let aggregatedSize = input.size;
+    for (const dep of inputDependencies) {
+      aggregatedSize += inputs.get(dep)?.size || 0;
+    }
+    dependencies.add({
+      name: input.name,
+      size: input.size,
       aggregatedSize,
-      dependents: getAll("dependents", inputs, filepath),
-      dependencies: fileDependencies
+      dependents: inputDependents,
+      dependencies: inputDependencies
     });
   }
-  if (!dependencies.length) {
+  if (!dependencies.size) {
     return [dependentsToPrint, dependenciesToPrint, sizesToPrint];
   }
-  dependencies.sort(sortDesc((file) => file.dependents.length));
-  dependentsToPrint.values = dependencies.map((file) => ({
+  const dependenciesArray = Array.from(dependencies);
+  dependenciesArray.sort(sortDesc((file) => file.dependents.size));
+  dependentsToPrint.values = dependenciesArray.map((file) => ({
     name: file.name,
-    value: file.dependents.length.toString()
+    value: file.dependents.size.toString()
   }));
-  dependencies.sort(sortDesc((file) => file.dependencies.length));
-  dependenciesToPrint.values = dependencies.map((file) => ({
+  dependenciesArray.sort(sortDesc((file) => file.dependencies.size));
+  dependenciesToPrint.values = dependenciesArray.map((file) => ({
     name: file.name,
-    value: file.dependencies.length.toString()
+    value: file.dependencies.size.toString()
   }));
-  dependencies.sort(sortDesc("size"));
-  sizesToPrint.values = dependencies.map((file) => ({
+  dependenciesArray.sort(sortDesc("size"));
+  sizesToPrint.values = dependenciesArray.map((file) => ({
     name: file.name,
     value: prettyBytes$1(file.size)
   }));
-  dependencies.sort(sortDesc("aggregatedSize"));
-  aggregatedSizesToPrint.values = dependencies.map((file) => ({
+  dependenciesArray.sort(sortDesc("aggregatedSize"));
+  aggregatedSizesToPrint.values = dependenciesArray.map((file) => ({
     name: file.name,
     value: prettyBytes$1(file.aggregatedSize || file.size)
   }));
@@ -23876,6 +24052,17 @@ const renderValues = (values) => {
   let outputString = "";
   const titlePadding = 4;
   const valuePadding = 4;
+  for (const group of values) {
+    if (group.top && group.values.length >= TOP) {
+      group.values = group.values.slice(0, TOP);
+      group.name = `Top ${TOP} ${group.name}`;
+    }
+    for (const value of group.values) {
+      if (value.name.length > MAX_VALUE_LENGTH) {
+        value.name = `${value.name.slice(0, 10)}[...]${value.name.slice(-(MAX_VALUE_LENGTH - 15))}`;
+      }
+    }
+  }
   const maxTitleWidth = Math.max(...values.map((val) => val.name.length));
   const maxNameWidth = Math.max(...values.flatMap((val) => val.values.map((v) => v.name.length)));
   const maxValueWidth = Math.max(
@@ -23889,13 +24076,11 @@ const renderValues = (values) => {
     if (group.values.length === 0) {
       continue;
     }
-    const title = group.top && group.values.length >= TOP ? `Top ${TOP} ${group.name}` : group.name;
-    const titlePad = totalWidth - (title.length + titlePadding);
+    const titlePad = totalWidth - (group.name.length + titlePadding);
     outputString += `
-== ${title} ${"=".repeat(titlePad)}=
+== ${group.name} ${"=".repeat(titlePad)}=
 `;
-    const valuesToPrint = group.top ? group.values.slice(0, TOP) : group.values;
-    for (const value of valuesToPrint) {
+    for (const value of group.values) {
       const valuePad = maxValueWidth - value.value.length;
       outputString += ` [${numColor(value.value)}] ${" ".repeat(valuePad)}${nameColor(value.name)}
 `;
@@ -24143,6 +24328,10 @@ class Tapables {
     this.tapables = [];
     this.hooks = {};
     this.timings = /* @__PURE__ */ new Map();
+    this.ignoredHooks = [
+      // This one triggers a DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK warning.
+      "normalModuleLoader"
+    ];
     this.cwd = cwd;
   }
   saveResult(type, pluginName, hookName, context, start, end) {
@@ -24189,7 +24378,7 @@ class Tapables {
   }
   getPromiseTapPatch(type, fn, pluginName, hookName) {
     return (...args) => {
-      this.checkHooks();
+      this.checkNewHooks();
       const startTime = performance$1.now();
       const returnValue = fn.apply(this, args);
       const cb = () => {
@@ -24208,7 +24397,7 @@ class Tapables {
   }
   getAsyncTapPatch(type, fn, pluginName, hookName) {
     return (...args) => {
-      this.checkHooks();
+      this.checkNewHooks();
       const startTime = performance$1.now();
       const originalCB = args.pop();
       const newCB = (...a) => {
@@ -24227,7 +24416,7 @@ class Tapables {
   }
   getDefaultTapPatch(type, fn, pluginName, hookName) {
     return (...args) => {
-      this.checkHooks();
+      this.checkNewHooks();
       const startTime = performance$1.now();
       const returnValue = fn.apply(this, args);
       this.saveResult(
@@ -24286,23 +24475,32 @@ class Tapables {
     this.hooks[tapableName].push(hookName);
     this.replaceTaps(hookName, hook);
   }
-  checkHooks() {
-    for (const tapable of this.tapables) {
-      const name = tapable.constructor.name;
-      for (const hookName of Object.keys(tapable.hooks)) {
-        this.patchHook(name, hookName, tapable.hooks[hookName]);
+  patchHooks(tapable) {
+    const name = tapable.constructor.name;
+    const hooksToPatch = Object.keys(tapable.hooks).filter((hookName) => {
+      if (this.ignoredHooks.includes(hookName)) {
+        return false;
+      }
+      if (this.hooks[name]?.includes(hookName)) {
+        return false;
       }
+      return true;
+    });
+    for (const hookName of hooksToPatch) {
+      this.patchHook(name, hookName, tapable.hooks[hookName]);
+    }
+  }
+  checkNewHooks() {
+    for (const tapable of this.tapables) {
+      this.patchHooks(tapable);
     }
   }
   // Let's navigate through all the hooks we can find.
   throughHooks(tapable) {
-    const name = tapable.constructor.name;
     if (!this.tapables.includes(tapable)) {
       this.tapables.push(tapable);
     }
-    for (const hookName of Object.keys(tapable.hooks)) {
-      this.patchHook(name, hookName, tapable.hooks[hookName]);
-    }
+    this.patchHooks(tapable);
   }
 }
 
@@ -36032,6 +36230,10 @@ const buildPluginFactory = ({
       ...unpluginMetaContext
     });
     const plugins = [...internalPlugins];
+    if (options.customPlugins) {
+      const customPlugins = options.customPlugins(options, globalContext);
+      plugins.push(...customPlugins);
+    }
     if (options[CONFIG_KEY$1] && options[CONFIG_KEY$1].disabled !== true) {
       plugins.push(...getPlugins$2(options, globalContext));
     }
@@ -36044,7 +36246,7 @@ const buildPluginFactory = ({
 
 var name = "@datadog/esbuild-plugin";
 var packageManager = "yarn@4.0.2";
-var version$1 = "2.3.0-dev";
+var version$1 = "2.3.0";
 var license = "MIT";
 var author = "Datadog";
 var description = "Datadog ESBuild Plugin";
@@ -36109,7 +36311,6 @@ var devDependencies = {
 var peerDependencies = {
 	esbuild: ">=0.x"
 };
-var stableVersion = "2.2.1";
 var pkg = {
 	name: name,
 	packageManager: packageManager,
@@ -36127,8 +36328,7 @@ var pkg = {
 	files: files,
 	scripts: scripts,
 	devDependencies: devDependencies,
-	peerDependencies: peerDependencies,
-	stableVersion: stableVersion
+	peerDependencies: peerDependencies
 };
 
 const datadogEsbuildPlugin = buildPluginFactory({