@rsdoctor/core 0.0.0-next-20240620044732

package/dist/build-utils/build/utils/parseBundle.d.ts

@@ -0,0 +1,13 @@
+import { ParseBundle } from '../../../types';
+/**
+ * The following code is based on
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/src/parseUtils.js#L10
+ *
+ *
+ * MIT Licensed
+ * Author th0r
+ * Copyright JS Foundation and other contributors.
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/LICENSE
+ */
+export declare const parseBundle: ParseBundle;
+//# sourceMappingURL=parseBundle.d.ts.map

package/dist/build-utils/build/utils/parseBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseBundle.d.ts","sourceRoot":"","sources":["../../../../src/build-utils/build/utils/parseBundle.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGtC;;;;;;;;;GASG;AAEH,eAAO,MAAM,WAAW,EAAE,WA4PzB,CAAC"}

package/dist/build-utils/build/utils/parseBundle.js

@@ -0,0 +1,367 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parseBundle_exports = {};
+__export(parseBundle_exports, {
+  parseBundle: () => parseBundle
+});
+module.exports = __toCommonJS(parseBundle_exports);
+var import_fs = __toESM(require("fs"));
+var import_lodash = require("lodash");
+var import_filesize = require("filesize");
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+var import_path = require("path");
+var import_logger = require("@rsdoctor/utils/logger");
+const parseBundle = (bundlePath, modulesData) => {
+  if (bundlePath.indexOf(".worker.") > 0) {
+    return {};
+  }
+  if ((0, import_path.extname)(bundlePath) !== ".js") {
+    return {};
+  }
+  let content = import_fs.default.readFileSync(bundlePath, "utf8");
+  const tagCache = /* @__PURE__ */ new Map();
+  let hasBannerPlugin = content.indexOf("RSDOCTOR_START::") > 0;
+  if (hasBannerPlugin && !tagCache.get(bundlePath)) {
+    const tagMatchResult = getStringBetween(
+      content,
+      0,
+      /([a-z|A-Z]+\.[a-z]+)\(\SRSDOCTOR_START::(.*?);/,
+      /([a-z|A-Z]+\.[a-z]+)\(\SRSDOCTOR_END::(.*?)\)/
+    );
+    content = tagMatchResult.result?.trim() || content;
+    tagCache.set(bundlePath, tagMatchResult.loc);
+    hasBannerPlugin = true;
+  } else if (hasBannerPlugin && !tagCache.get(bundlePath)) {
+    const loc = tagCache.get(bundlePath);
+    content = content.slice(loc.start, loc.end);
+    hasBannerPlugin = true;
+  }
+  const ast = import_ruleUtils.parser.internal.parse(content, {
+    sourceType: "script",
+    ecmaVersion: "latest"
+  });
+  const walkState = {
+    locations: null,
+    expressionStatementDepth: 0
+  };
+  import_ruleUtils.parser.walk.recursive(ast, walkState, {
+    ExpressionStatement(node, state, c) {
+      if (state.locations)
+        return;
+      state.expressionStatementDepth++;
+      try {
+        if (
+          // Webpack 5 stores modules in the the top-level IIFE
+          state.expressionStatementDepth === 1 && // ast?.range?.includes(node) &&
+          isIIFE(node)
+        ) {
+          const fn = getIIFECallExpression(node);
+          if (
+            // It should not contain neither arguments
+            fn.arguments.length === 0 && // ...nor parameters
+            fn.callee.params.length === 0
+          ) {
+            const firstVariableDeclaration = fn.callee.body.body.find(
+              (node2) => node2.type === "VariableDeclaration"
+            );
+            if (firstVariableDeclaration) {
+              for (const declaration of firstVariableDeclaration.declarations) {
+                if (declaration.init) {
+                  state.locations = getModulesLocations(declaration.init);
+                  if (state.locations) {
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (!state.locations) {
+          c(node.expression, state);
+        }
+      } catch (e) {
+        (0, import_logger.debug)(() => e);
+      }
+      state.expressionStatementDepth--;
+    },
+    Program(node, state, _c) {
+      if (state.locations)
+        return;
+      try {
+        if (hasBannerPlugin) {
+          const firstVariableDeclaration = node.body.find(
+            (node2) => {
+              return node2.type === "VariableDeclaration" && node2.declarations?.[0]?.init?.type === "ObjectExpression" && node2.declarations?.[0]?.init?.properties?.length;
+            }
+          );
+          if (firstVariableDeclaration) {
+            for (const declaration of firstVariableDeclaration.declarations) {
+              if (declaration.init) {
+                state.locations = getModulesLocations(declaration.init);
+                if (state.locations) {
+                  break;
+                }
+              }
+            }
+          }
+        }
+        if (!state.locations) {
+          node.body.forEach((n) => _c(n, state));
+        }
+      } catch (e) {
+        (0, import_logger.debug)(() => e);
+      }
+      state.expressionStatementDepth--;
+    },
+    AssignmentExpression(node, state) {
+      if (state.locations)
+        return;
+      const { left, right } = node;
+      if (left?.object && left.object.name === "exports" && left.property && left.property.name === "modules" && isModulesHash(right)) {
+        state.locations = getModulesLocations(right);
+      }
+    },
+    CallExpression(node, state, c) {
+      if (state.locations)
+        return;
+      const args = node.arguments;
+      if (node.callee.type === "FunctionExpression" && !node.callee.id && args.length === 1 && isSimpleModulesList(args[0])) {
+        state.locations = getModulesLocations(args[0]);
+        return;
+      }
+      if (node.callee.type === "Identifier" && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
+        state.locations = getModulesLocations(args[1]);
+        return;
+      }
+      if (isAsyncChunkPushExpression(node)) {
+        state.locations = getModulesLocations(args[0].elements[1]);
+        return;
+      }
+      if (isAsyncWebWorkerChunkExpression(node)) {
+        state.locations = getModulesLocations(args[1]);
+        return;
+      }
+      args.forEach((arg) => c(arg, state));
+    }
+  });
+  let modules;
+  if (walkState.locations) {
+    modules = (0, import_lodash.mapValues)(
+      walkState.locations,
+      (loc) => content.slice(loc.start, loc.end)
+    );
+  } else {
+    modules = {};
+  }
+  const modulesObj = {};
+  for (const module2 in modules) {
+    if (!module2) {
+      return {};
+    }
+    const moduleContent = modules[module2];
+    const size = moduleContent && Buffer.byteLength(moduleContent);
+    const _filterModules = (0, import_lodash.find)(modulesData, {
+      id: Number(module2)
+    });
+    const identifier = _filterModules?.identifier || (0, import_lodash.find)(modulesData, { id: module2 })?.identifier || "";
+    modulesObj[identifier] = {
+      size,
+      sizeConvert: (0, import_filesize.filesize)(size || 0),
+      content: moduleContent
+    };
+  }
+  return {
+    modules: modulesObj,
+    src: content,
+    runtimeSrc: getBundleRuntime(content, walkState.locations)
+  };
+};
+function getBundleRuntime(content, modulesLocations) {
+  const sortedLocations = Object.values(modulesLocations || {}).sort(
+    (a, b) => a.start - b.start
+  );
+  let result = "";
+  let lastIndex = 0;
+  for (const { start, end } of sortedLocations) {
+    result += content.slice(lastIndex, start);
+    lastIndex = end;
+  }
+  return result + content.slice(lastIndex, content.length);
+}
+function isIIFE(node) {
+  return node.type === "ExpressionStatement" && (node.expression.type === "CallExpression" || node.expression.type === "UnaryExpression" && node.expression.argument.type === "CallExpression");
+}
+function getIIFECallExpression(node) {
+  if (node.expression.type === "UnaryExpression") {
+    return node.expression.argument;
+  }
+  return node.expression;
+}
+function isModulesList(node) {
+  return isSimpleModulesList(node) || // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
+  isOptimizedModulesArray(node);
+}
+function isSimpleModulesList(node) {
+  return (
+    // Modules are contained in hash. Keys are module ids.
+    isModulesHash(node) || // Modules are contained in array. Indexes are module ids.
+    isModulesArray(node)
+  );
+}
+function isModulesHash(node) {
+  return node.type === "ObjectExpression" && node.properties.map((node2) => node2.value).every(isModuleWrapper);
+}
+function isModulesArray(node) {
+  return node.type === "ArrayExpression" && node.elements.every(
+    (elem) => (
+      // Some of array items may be skipped because there is no module with such id
+      !elem || isModuleWrapper(elem)
+    )
+  );
+}
+function isOptimizedModulesArray(node) {
+  return node.type === "CallExpression" && node.callee.type === "MemberExpression" && // Make sure the object called is `Array(<some number>)`
+  node.callee.object.type === "CallExpression" && node.callee.object.callee.type === "Identifier" && node.callee.object.callee.name === "Array" && node.callee.object.arguments.length === 1 && isNumericId(node.callee.object.arguments[0]) && // Make sure the property X called for `Array(<some number>).X` is `concat`
+  node.callee.property.type === "Identifier" && node.callee.property.name === "concat" && // Make sure exactly one array is passed in to `concat`
+  node.arguments.length === 1 && isModulesArray(node.arguments[0]);
+}
+function isModuleWrapper(node) {
+  return (
+    // It's an anonymous function expression that wraps module
+    (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && !node.id || // If `DedupePlugin` is used it can be an ID of duplicated module...
+    isModuleId(node) || // or an array of shape [<module_id>, ...args]
+    node.type === "ArrayExpression" && node.elements.length > 1 && isModuleId(node.elements[0])
+  );
+}
+function isModuleId(node) {
+  return node.type === "Literal" && (isNumericId(node) || typeof node.value === "string");
+}
+function isNumericId(node) {
+  return node.type === "Literal" && Number.isInteger(node.value) && node.value >= 0;
+}
+function isChunkIds(node) {
+  return node.type === "ArrayExpression" && node.elements.every(isModuleId);
+}
+function isAsyncChunkPushExpression(node) {
+  const { callee, arguments: args } = node;
+  return callee.type === "MemberExpression" && callee.property.name === "push" && callee.object.type === "AssignmentExpression" && args.length === 1 && args[0].type === "ArrayExpression" && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
+}
+function mayBeAsyncChunkArguments(args) {
+  return args.length >= 2 && isChunkIds(args[0]);
+}
+function isAsyncWebWorkerChunkExpression(node) {
+  const { callee, type, arguments: args } = node;
+  return type === "CallExpression" && callee.type === "MemberExpression" && args.length === 2 && isChunkIds(args[0]) && isModulesList(args[1]);
+}
+function getModulesLocations(node) {
+  if (node.type === "ObjectExpression") {
+    const modulesNodes = node.properties;
+    return modulesNodes.reduce(
+      (result, moduleNode) => {
+        const moduleId = moduleNode.key.name || moduleNode.key.value;
+        result[moduleId] = getModuleLocation(moduleNode.value);
+        return result;
+      },
+      {}
+    );
+  }
+  const isOptimizedArray = node.type === "CallExpression";
+  if (node.type === "ArrayExpression" || isOptimizedArray) {
+    const minId = isOptimizedArray ? (
+      // Get the [minId] value from the Array() call first argument literal value
+      node.callee.object.arguments[0].value
+    ) : (
+      // `0` for simple array
+      0
+    );
+    const modulesNodes = isOptimizedArray ? (
+      // The modules reside in the `concat()` function call arguments
+      node.arguments[0].elements
+    ) : node.elements;
+    return modulesNodes.reduce(
+      (result, moduleNode, i) => {
+        if (moduleNode) {
+          result[i + minId] = getModuleLocation(moduleNode);
+        }
+        return result;
+      },
+      {}
+    );
+  }
+  return {};
+}
+function getModuleLocation(node) {
+  return {
+    start: node.start,
+    end: node.end
+  };
+}
+function getStringBetween(raw, position, start, end) {
+  try {
+    const matchStart = raw.match(start);
+    const startFlagIndex = matchStart?.length ? raw.indexOf(matchStart[0], position) : -1;
+    if (startFlagIndex === -1 || !matchStart?.length) {
+      return {
+        result: null,
+        remain: position
+      };
+    }
+    const startTagLength = matchStart[0].length;
+    const matchEnd = raw.match(end);
+    const endFlagIndex = matchEnd?.length ? raw.indexOf(matchEnd[0], startFlagIndex + startTagLength) : -1;
+    if (endFlagIndex === -1 || !matchEnd?.length) {
+      return {
+        result: null,
+        remain: position
+      };
+    }
+    let innerContent = raw.slice(startFlagIndex + startTagLength, endFlagIndex).trim();
+    if (innerContent.endsWith(",")) {
+      innerContent = innerContent.slice(0, -1);
+    }
+    return {
+      result: innerContent,
+      remain: matchEnd?.length ? endFlagIndex + matchEnd[0].length : endFlagIndex,
+      loc: {
+        start: startFlagIndex + startTagLength,
+        end: endFlagIndex
+      }
+    };
+  } catch (e) {
+    (0, import_logger.debug)(() => e);
+    return {
+      result: null,
+      remain: position
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseBundle
+});

package/dist/build-utils/build/utils/plugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from '@rsdoctor/types';
+export type IHook = Plugin.BaseCompiler['hooks'][keyof Plugin.BaseCompiler['hooks']];
+export declare function shouldInterceptPluginHook<T extends IHook>(hook: T): boolean;
+export declare function interceptCompilerHooks(compiler: Plugin.BaseCompiler, interceptor: (name: string, hook: IHook, scope: 'compiler') => void): void;
+export declare function interceptCompilationHooks(compilation: Plugin.BaseCompilation, interceptor: (name: string, hook: IHook, scope: 'compilation') => void): void;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/build-utils/build/utils/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../src/build-utils/build/utils/plugin.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,MAAM,MAAM,KAAK,GACf,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,MAAM,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AAEnE,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE,CAAC,WAoBjE;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,CAAC,YAAY,EAC7B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,QAQpE;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,CAAC,eAAe,EACnC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,aAAa,KAAK,IAAI,QAiBvE"}

package/dist/build-utils/build/utils/plugin.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  interceptCompilationHooks: () => interceptCompilationHooks,
+  interceptCompilerHooks: () => interceptCompilerHooks,
+  shouldInterceptPluginHook: () => shouldInterceptPluginHook
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_compatible = require("../../common/module-graph/compatible");
+function shouldInterceptPluginHook(hook) {
+  if (hook._fakeHook) {
+    return false;
+  }
+  if (typeof hook.isUsed === "function") {
+    return hook.isUsed();
+  }
+  if (hook._map && hook._map.size === 0) {
+    return false;
+  }
+  return true;
+}
+function interceptCompilerHooks(compiler, interceptor) {
+  Object.keys(compiler.hooks).forEach((hook) => {
+    const v = compiler.hooks[hook];
+    if (shouldInterceptPluginHook(v)) {
+      interceptor(hook, v, "compiler");
+    }
+  });
+}
+function interceptCompilationHooks(compilation, interceptor) {
+  Object.keys(compilation.hooks).forEach((hook) => {
+    if (hook === "normalModuleLoader" && (0, import_compatible.isWebpack5orRspack)(compilation)) {
+      return;
+    }
+    const v = compilation.hooks[hook];
+    if (shouldInterceptPluginHook(v)) {
+      interceptor(hook, v, "compilation");
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  interceptCompilationHooks,
+  interceptCompilerHooks,
+  shouldInterceptPluginHook
+});

package/dist/build-utils/common/chunks/assetsContent.d.ts

@@ -0,0 +1,5 @@
+import { ChunkGraph } from '@rsdoctor/graph';
+export declare function assetsContents(assetMap: Map<string, {
+    content: string;
+}>, chunkGraph: ChunkGraph): void;
+//# sourceMappingURL=assetsContent.d.ts.map

package/dist/build-utils/common/chunks/assetsContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assetsContent.d.ts","sourceRoot":"","sources":["../../../../src/build-utils/common/chunks/assetsContent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,EAC1C,UAAU,EAAE,UAAU,QAOvB"}

package/dist/build-utils/common/chunks/assetsContent.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var assetsContent_exports = {};
+__export(assetsContent_exports, {
+  assetsContents: () => assetsContents
+});
+module.exports = __toCommonJS(assetsContent_exports);
+function assetsContents(assetMap, chunkGraph) {
+  const assets = chunkGraph.getAssets();
+  assets.forEach((asset) => {
+    const { content = "" } = assetMap.get(asset.path) || {};
+    asset.content = content;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assetsContents
+});

package/dist/build-utils/common/chunks/assetsModules.d.ts

@@ -0,0 +1,24 @@
+import { Plugin } from '@rsdoctor/types';
+import type { ModuleGraph } from '@rsdoctor/graph';
+import { ParseBundle } from '../../../types';
+export type ParsedModuleSizeData = {
+    [x: string]: {
+        size: number;
+        sizeConvert: string;
+        content: string;
+    };
+};
+/**
+ * The following code is modified based on
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/8a3d3f0f40010f2b41ccd28519eda5a44e13da3e/src/analyzer.js#L20
+ *
+ * MIT Licensed
+ * Author th0r
+ * Copyright JS Foundation and other contributors.
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/LICENSE
+ */
+export declare function getAssetsModulesData(bundleStats: Plugin.StatsCompilation, bundleDir: string, opts: {
+    parseBundle?: ParseBundle;
+}): Promise<ParsedModuleSizeData | null>;
+export declare function transformAssetsModulesData(parsedModulesData: ParsedModuleSizeData, moduleGraph: ModuleGraph): void;
+//# sourceMappingURL=assetsModules.d.ts.map

package/dist/build-utils/common/chunks/assetsModules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assetsModules.d.ts","sourceRoot":"","sources":["../../../../src/build-utils/common/chunks/assetsModules.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGtC,MAAM,MAAM,oBAAoB,GAAG;IACjC,CAAC,CAAC,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACrE,CAAC;AACF;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,CAAC,gBAAgB,EACpC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE;IACJ,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,GACA,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAsEtC;AAED,wBAAgB,0BAA0B,CACxC,iBAAiB,EAAE,oBAAoB,EACvC,WAAW,EAAE,WAAW,QAUzB"}

package/dist/build-utils/common/chunks/assetsModules.js

@@ -0,0 +1,107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var assetsModules_exports = {};
+__export(assetsModules_exports, {
+  getAssetsModulesData: () => getAssetsModulesData,
+  transformAssetsModulesData: () => transformAssetsModulesData
+});
+module.exports = __toCommonJS(assetsModules_exports);
+var import_lodash = require("lodash");
+var import_path = __toESM(require("path"));
+var import_logger = require("@rsdoctor/utils/logger");
+var import_module_graph = require("../module-graph");
+async function getAssetsModulesData(bundleStats, bundleDir, opts) {
+  const { parseBundle = () => ({}) } = opts || {};
+  if ((0, import_lodash.isEmpty)(bundleStats.assets) && !(0, import_lodash.isEmpty)(bundleStats.children)) {
+    const { children } = bundleStats;
+    const _bundleStats = children?.[0];
+    if (!children) {
+      return {};
+    }
+    for (let i = 1; i < children.length; i++) {
+      children[i]?.assets?.forEach((asset) => {
+        _bundleStats?.assets?.push(asset);
+      });
+    }
+  } else if (!(0, import_lodash.isEmpty)(bundleStats.children)) {
+    bundleStats?.children?.forEach((child) => {
+      child?.assets?.forEach((asset) => {
+        bundleStats?.assets?.push(asset);
+      });
+    });
+  }
+  let bundlesSources = null;
+  let parsedModules = null;
+  if (bundleDir && bundleStats?.assets) {
+    bundlesSources = {};
+    parsedModules = {};
+    for (const statAsset of bundleStats.assets) {
+      const assetFile = import_path.default.join(bundleDir, statAsset.name);
+      let bundleInfo;
+      const collectedModules = [];
+      (0, import_module_graph.getModulesFromArray)(bundleStats.modules ?? [], collectedModules);
+      const childrenModules = bundleStats.children?.flatMap((c) => c.modules || []) || [];
+      collectedModules.push(...childrenModules);
+      try {
+        bundleInfo = await parseBundle(assetFile, collectedModules);
+      } catch (err) {
+        const { code = "", message } = err;
+        const msg = code === "ENOENT" ? "no such file" : message;
+        process.env.DEVTOOLS_NODE_DEV === "1" && import_logger.logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
+        continue;
+      }
+      bundlesSources[statAsset.name] = (0, import_lodash.pick)(bundleInfo, "src", "runtimeSrc");
+      Object.assign(parsedModules, bundleInfo?.modules || {});
+    }
+    if ((0, import_lodash.isEmpty)(bundlesSources)) {
+      bundlesSources = null;
+      parsedModules = null;
+      process.env.DEVTOOLS_DEV && import_logger.logger.warn(
+        "\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n"
+      );
+    }
+  }
+  return parsedModules;
+}
+function transformAssetsModulesData(parsedModulesData, moduleGraph) {
+  if (!moduleGraph)
+    return;
+  Object.entries(parsedModulesData).forEach(([moduleId, parsedData]) => {
+    const module2 = moduleGraph.getModuleByWebpackId(moduleId ?? "");
+    module2?.setSize({
+      parsedSize: parsedData?.size
+    });
+    module2?.setSource({ parsedSource: parsedData?.content || "" });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAssetsModulesData,
+  transformAssetsModulesData
+});

package/dist/build-utils/common/chunks/chunkTransform.d.ts

@@ -0,0 +1,6 @@
+import { ChunkGraph } from '@rsdoctor/graph';
+import { Plugin } from '@rsdoctor/types';
+export declare function chunkTransform(assetMap: Map<string, {
+    content: string;
+}>, bundleStats: Plugin.StatsCompilation): ChunkGraph;
+//# sourceMappingURL=chunkTransform.d.ts.map

package/dist/build-utils/common/chunks/chunkTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkTransform.d.ts","sourceRoot":"","sources":["../../../../src/build-utils/common/chunks/chunkTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,UAAU,EAEX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAIzC,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,EAC1C,WAAW,EAAE,MAAM,CAAC,gBAAgB,cA0DrC"}