@bundle-stats/utils 4.3.0-beta.3 → 4.3.0-rc.0

package/src/webpack/extract/modules-packages-duplicate.ts

@@ -1,3 +1,4 @@
+import isEmpty from 'lodash/isEmpty';
 import map from 'lodash/map';
 import orderBy from 'lodash/orderBy';
 import sum from 'lodash/sum';
@@ -25,9 +26,9 @@ interface DuplicatePackageGroup {
 }
 
 interface ModulesPackagesDuplicateData {
-  insights: {
+  insights?: {
     duplicatePackages?: JobInsights['webpack']['duplicatePackages'];
-    duplicatePackagesV3: JobInsights['webpack']['duplicatePackagesV3'];
+    duplicatePackagesV3?: JobInsights['webpack']['duplicatePackagesV3'];
   };
   metrics: {
     duplicatePackagesCount: MetricRun;
@@ -37,7 +38,7 @@ interface ModulesPackagesDuplicateData {
 export const getDuplicatePackagesInsight = (
   duplicatePackagesMap: Record<string, Array<string>>,
   baselineDuplicatePackagesMap?: Record<string, Array<string>>,
-): JobInsight<JobInsightDuplicatePackagesV3Data> => {
+): JobInsight<JobInsightDuplicatePackagesV3Data> | null => {
   const duplicateInstances: Array<string> = [];
   const baselineDuplicateInstances: Array<string> = [];
   const newDuplicateInstances: Array<string> = [];
@@ -81,8 +82,8 @@ export const getDuplicatePackagesInsight = (
   const newDuplicateInstancesCount = newDuplicateInstances.length;
   const removedDuplicateInstancesCount = removedDuplicateInstances.length;
 
-  let text: string;
-  let insightType: InsightType;
+  let text = '';
+  let insightType: InsightType | null = null;
 
   if (newDuplicateInstancesCount > 0 && removedDuplicateInstancesCount > 0) {
     // New duplicate packages and removed duplicates
@@ -90,7 +91,7 @@ export const getDuplicatePackagesInsight = (
       newDuplicateInstancesCount > 1 || removedDuplicateInstancesCount > 1 ? 'packages' : 'package';
     text = `Bundle introduced ${newDuplicateInstancesCount} and removed ${removedDuplicateInstancesCount} duplicate ${item}`;
     insightType = InsightType.ERROR;
-  } else if (newDuplicateInstancesCount > 0 && baselineDuplicatePackagesMap) {
+  } else if (newDuplicateInstancesCount > 0 && !isEmpty(baselineDuplicatePackagesMap)) {
     // New duplicate packages and baseline comparison
     const item = newDuplicateInstancesCount > 1 ? 'packages' : 'package';
     text = `Bundle introduced ${newDuplicateInstancesCount} duplicate ${item}`;
@@ -100,6 +101,12 @@ export const getDuplicatePackagesInsight = (
     const item = newDuplicateInstancesCount > 1 ? 'packages' : 'package';
     text = `Bundle contains ${newDuplicateInstancesCount} duplicate ${item}`;
     insightType = InsightType.WARNING;
+  } else if (removedDuplicateInstancesCount > 0 && duplicateInstancesCount > 0) {
+    // Removed duplicate packages, but there are duplicate packages remaining
+    const itemRemoved = removedDuplicateInstancesCount > 1 ? 'packages' : 'package';
+    const itemRemaining = duplicateInstancesCount > 1 ? 'packages' : 'package';
+    text = `Bundle removed ${removedDuplicateInstancesCount} duplicate ${itemRemoved}, ${duplicateInstancesCount} duplicate ${itemRemaining} remaining`;
+    insightType = InsightType.WARNING;
   } else if (removedDuplicateInstancesCount > 0) {
     // Removed duplicate packages
     const item = removedDuplicateInstancesCount > 1 ? 'packages' : 'package';
@@ -115,9 +122,11 @@ export const getDuplicatePackagesInsight = (
     text = `Bundle contains ${duplicateInstancesCount} duplicate ${item}`;
     insightType = InsightType.WARNING;
   } else {
-    // No change
-    text = 'Bundle does not contain duplicate packages';
-    insightType = InsightType.INFO;
+    // No change - noop
+  }
+
+  if (!text || !insightType) {
+    return null;
   }
 
   return {
@@ -180,11 +189,15 @@ export const extractModulesPackagesDuplicate = (
     baselineJob?.insights?.webpack?.duplicatePackages?.data ||
     {};
 
+  const noDuplicatesDuplicatePackagesV3 = getDuplicatePackagesInsight({}, baselineDuplicatePackages);
+
   if (!count) {
     return {
-      insights: {
-        duplicatePackagesV3: getDuplicatePackagesInsight({}, baselineDuplicatePackages),
-      },
+      ...(noDuplicatesDuplicatePackagesV3 && {
+        insights: {
+          duplicatePackagesV3: noDuplicatesDuplicatePackagesV3,
+        },
+      }),
       metrics: {
         duplicatePackagesCount: {
           value: count,
@@ -221,16 +234,18 @@ export const extractModulesPackagesDuplicate = (
     duplicatePackagesData[packageName] = packageData.children.map(({ id }) => id);
   });
 
+  const duplicatePackagesV3 = getDuplicatePackagesInsight(
+    duplicatePackagesData,
+    baselineDuplicatePackages,
+  );
+
   return {
     insights: {
       duplicatePackages: {
         type: InsightType.WARNING,
         data: duplicatePackagesData,
       },
-      duplicatePackagesV3: getDuplicatePackagesInsight(
-        duplicatePackagesData,
-        baselineDuplicatePackages,
-      ),
+      ...(duplicatePackagesV3 && { duplicatePackagesV3 }),
     },
     metrics: {
       duplicatePackagesCount: {

package/src/webpack/extract/modules.ts

@@ -1,11 +1,12 @@
 import round from 'lodash/round';
-import { WebpackStatsFiltered, WebpackStatsFilteredRootModule } from '@bundle-stats/plugin-webpack-filter';
+import union from 'lodash/union';
+import { WebpackStatsFiltered, WebpackStatsFilteredModule } from '@bundle-stats/plugin-webpack-filter';
 
 import { Module, MetricsModules } from '../types';
 import { getModuleName, normalizeChunkId } from '../utils';
 
 /*
- * Extract webpack modules array to an object with metrics
+ * Extract webpack modules metrics and stats
  */
 export const extractModules = (webpackStats?: WebpackStatsFiltered): MetricsModules => {
   const modulesSource = webpackStats?.modules;
@@ -22,57 +23,86 @@ export const extractModules = (webpackStats?: WebpackStatsFiltered): MetricsModu
   }
 
   // Flatten concatenated modules
-  const allModules = modulesSource.reduce((agg, moduleEntry) => {
-    if (!moduleEntry.modules) {
-      agg.push(moduleEntry);
+  const modulesByName: Map<string, WebpackStatsFilteredModule> = new Map();
 
-      return agg;
+  modulesSource.forEach((rootModule) => {
+    // skip modules that do not belong to any chunk
+    if (!rootModule.chunks || rootModule.chunks.length === 0) {
+      return;
+    }
+
+    // flatten concatenated modules
+    if (rootModule.modules) {
+      rootModule.modules.forEach((concatenatedModule) => {
+        const concatenatedModuleName = getModuleName(concatenatedModule.name);
+        const existingModule = modulesByName.get(concatenatedModuleName);
+
+        // Merge if the module is already available
+        // webpack adds a module entry for every concatenated module
+        if (existingModule) {
+          modulesByName.set(concatenatedModuleName, {
+            ...existingModule,
+            chunks: union(existingModule.chunks, rootModule.chunks),
+          });
+        } else {
+          modulesByName.set(concatenatedModuleName, {
+            ...concatenatedModule,
+            chunks: rootModule.chunks,
+          });
+        }
+      });
+
+      return;
+    }
+
+    const normalizedName = getModuleName(rootModule.name);
+    const savedRootModule = modulesByName.get(normalizedName);
+
+    // Merge module data
+    // @NOTE some webpack plugins (mini-css-extract-plugin) might add a root module entry
+    // even if thee module was already concantenated in another module
+    if (savedRootModule) {
+      modulesByName.set(normalizedName, {
+        ...savedRootModule,
+        chunks: union(savedRootModule.chunks, rootModule.chunks),
+        size: rootModule.size,
+      });
+
+      return;
     }
 
-    // eslint-disable-next-line no-param-reassign
-    agg = agg.concat(
-      moduleEntry.modules.map((concatenatedModule) => ({
-        ...concatenatedModule,
-        // Add parent chunks
-        chunks: moduleEntry.chunks,
-      })),
-    );
+    modulesByName.set(normalizedName, rootModule);
+  });
 
-    return agg;
-  }, [] as Array<WebpackStatsFilteredRootModule>);
+  // Normalize module entries and extract metrics
+  const modules: Record<string, Module> = {};
 
   let moduleCount = 0;
   let totalCodeSize = 0;
   let duplicateCodeSize = 0;
   let duplicateModulesCount = 0;
 
-  // Normalize module entries
-  const modules = allModules.reduce((agg, moduleEntry) => {
+  modulesByName.forEach((moduleEntry, normalizedName) => {
     const { name, size = 0, chunks } = moduleEntry;
-    const normalizedName = getModuleName(name);
-
-    // skip modules that do not belong to any chunk
-    if (!chunks || chunks?.length === 0) {
-      return agg;
-    }
 
     const instances = chunks.length;
     const duplicateInstances = instances - 1;
+    const duplicated = duplicateInstances > 0;
 
     moduleCount += instances;
-    duplicateModulesCount += duplicateInstances;
-    duplicateCodeSize += duplicateInstances * size;
     totalCodeSize += instances * size;
 
-    // eslint-disable-next-line no-param-reassign
-    agg[normalizedName] = {
+    if (duplicated) {
+      duplicateModulesCount += duplicateInstances;
+      duplicateCodeSize += duplicateInstances * size;
+    }
+
+    modules[normalizedName] = {
       name,
       value: size,
       chunkIds: chunks.map(normalizeChunkId),
-      duplicated: Boolean(duplicateInstances),
+      ...(duplicated && { duplicated }),
     };
-
-    return agg;
   }, {} as Record<string, Module>);
 
   const duplicateCode = totalCodeSize ? round((duplicateCodeSize / totalCodeSize) * 100, 2) : 0;

package/src/webpack/metrics.js

@@ -9,7 +9,7 @@ import { Metric } from './types';
 export const metrics = {
   [Metric.BUNDLE_SIZE]: {
     label: 'Bundle Size',
-    description: 'The total size of the assets produced by webpack',
+    description: 'The total size of the assets processed by the bundler',
     url: 'https://relative-ci.com/documentation/metrics-and-data#assets',
     type: METRIC_TYPE_FILE_SIZE,
   },
@@ -48,14 +48,14 @@ export const metrics = {
   },
   [Metric.MODULE_COUNT]: {
     label: 'Modules',
-    description: 'The total number of modules bundled by webpack',
+    description: 'The total number of bundled modules',
     url: 'https://relative-ci.com/documentation/metrics-and-data#modules-1',
     type: METRIC_TYPE_NUMERIC,
     biggerIsBetter: false,
   },
   [Metric.DUPLICATE_MODULES_COUNT]: {
     label: 'Duplicate Modules',
-    description: 'The total number of modules that belong to more than one chunk',
+    description: 'The total number of module instances bundled into multiple chunks',
     url: 'https://relative-ci.com/documentation/metrics-and-data#modules-1',
     type: METRIC_TYPE_NUMERIC,
     biggerIsBetter: false,
@@ -69,14 +69,14 @@ export const metrics = {
   },
   [Metric.PACKAGE_COUNT]: {
     label: 'Packages',
-    description: 'The total number of packages bundled by webpack',
+    description: 'The total number of bundled packages',
     url: 'https://relative-ci.com/documentation/metrics-and-data#packages',
     type: METRIC_TYPE_NUMERIC,
     biggerIsBetter: false,
   },
   [Metric.DUPLICATE_PACKAGES_COUNT]: {
     label: 'Duplicate Packages',
-    description: 'The total number of duplicate packages',
+    description: 'The total number of bundled duplicate package instances',
     url: 'https://relative-ci.com/documentation/metrics-and-data#packages',
     type: METRIC_TYPE_NUMERIC,
     biggerIsBetter: false,

package/src/webpack/types.ts

@@ -50,8 +50,8 @@ export interface MetricsAssets {
 
 export interface Module extends MetricRun {
   name: string;
-  chunkIds: Array<String>;
-  duplicated: boolean;
+  chunkIds: Array<string>;
+  duplicated?: boolean;
 }
 
 export type Modules = Record<string, Module>;

package/types/browsertime/metrics.d.ts

@@ -104,4 +104,4 @@ export namespace metrics {
         export { METRIC_TYPE_DURATION as type };
     }
 }
-import { METRIC_TYPE_DURATION } from "../config/metrics";
+import { METRIC_TYPE_DURATION } from '../config/metrics';

package/types/config/metrics.d.ts

@@ -3,33 +3,4 @@ export const METRIC_TYPE_DURATION: "METRIC_TYPE_DURATION";
 export const METRIC_TYPE_NUMERIC: "METRIC_TYPE_NUMERIC";
 export const METRIC_TYPE_SCORE: "METRIC_TYPE_SCORE";
 export const METRIC_TYPE_PERCENTAGE: "METRIC_TYPE_PERCENTAGE";
-export namespace METRIC_TYPES {
-    namespace METRIC_TYPE_NUMERIC {
-        export const biggerIsBetter: boolean;
-        export { formatNumber as formatter };
-    }
-    namespace METRIC_TYPE_SCORE {
-        const biggerIsBetter_1: boolean;
-        export { biggerIsBetter_1 as biggerIsBetter };
-        export { formatNumber as formatter };
-    }
-    namespace METRIC_TYPE_DURATION {
-        const biggerIsBetter_2: boolean;
-        export { biggerIsBetter_2 as biggerIsBetter };
-        export { formatDuration as formatter };
-    }
-    namespace METRIC_TYPE_FILE_SIZE {
-        const biggerIsBetter_3: boolean;
-        export { biggerIsBetter_3 as biggerIsBetter };
-        export { formatFileSize as formatter };
-    }
-    namespace METRIC_TYPE_PERCENTAGE {
-        const biggerIsBetter_4: boolean;
-        export { biggerIsBetter_4 as biggerIsBetter };
-        export { formatPercentage as formatter };
-    }
-}
-import { formatNumber } from "../utils/format";
-import { formatDuration } from "../utils/format";
-import { formatFileSize } from "../utils/format";
-import { formatPercentage } from "../utils/format";
+export const METRIC_TYPES: Record<string, import('../constants').MetricType>;

package/types/constants.d.ts

@@ -85,6 +85,10 @@ export interface JobInsights {
         newPackages?: JobInsight<JobInsightNewPackagesData>;
     };
 }
+export interface JobInsightsInfo {
+    duplicatePackages?: JobInsights['webpack']['duplicatePackagesV3'];
+    newPackages?: JobInsights['webpack']['newPackages'];
+}
 export type JobMetricsSource = Record<string, MetricRun | Record<string, MetricRun>>;
 export type JobMetrics = JobSection<JobMetricsSource>;
 export interface JobData {

package/types/i18n.d.ts

@@ -9,10 +9,13 @@ declare namespace _default {
     const COMPONENT_LINK_MODULES_DUPLICATE: string;
     const COMPONENT_LINK_CHUNK_MODULES: string;
     const COMPONENT_LINK_PACKAGES_COUNT: string;
+    const COMPONENT_LINK_PACKAGES_CHANGED: string;
     const COMPONENT_LINK_PACKAGES_DUPLICATE: string;
+    const COMPONENT_LINK_PACKAGES_DUPLICATE_CHANGED: string;
     const COMPONENT_LINK_VIEW_PACKAGE: string;
     function COMPONENT_LINK_BUNDLE_ASSETS_BY_FILE_TYPE({ label }: {
         label: any;
     }): string;
+    function COMPONENT_LINK_BUNDLE_ASSETS_BY_ENTRY_TYPE(assetType: any): string;
 }
 export default _default;

package/types/lighthouse/metrics.d.ts

@@ -59,7 +59,7 @@ export namespace metrics {
         export { METRIC_TYPE_NUMERIC as type };
     }
 }
-import { METRIC_TYPE_SCORE } from "../config/metrics";
-import { METRIC_TYPE_DURATION } from "../config/metrics";
-import { METRIC_TYPE_FILE_SIZE } from "../config/metrics";
-import { METRIC_TYPE_NUMERIC } from "../config/metrics";
+import { METRIC_TYPE_SCORE } from '../config/metrics';
+import { METRIC_TYPE_DURATION } from '../config/metrics';
+import { METRIC_TYPE_FILE_SIZE } from '../config/metrics';
+import { METRIC_TYPE_NUMERIC } from '../config/metrics';

package/types/utils/component-links.d.ts

@@ -23,11 +23,13 @@ export declare const BUNDLE_ASSETS_COUNT: ComponentLink;
 export declare const BUNDLE_ASSETS_CHUNK_COUNT: ComponentLink;
 export declare const BUNDLE_MODULES: ComponentLink;
 export declare const BUNDLE_MODULES_DUPLICATE: ComponentLink;
+export declare const getBundleAssetsByEntryType: (assetType: 'entry' | 'initial' | 'chunk') => ComponentLink;
 export declare const getBundleModulesBySearch: (search: string) => ComponentLink;
 export declare const getBundleModulesByChunk: (chunkIds: Array<string>, chunkId: string, fileType?: string) => ComponentLink;
 export declare const BUNDLE_PACKAGES_COUNT: ComponentLink;
+export declare const BUNDLE_PACKAGES_CHANGED: ComponentLink;
 export declare const BUNDLE_PACKAGES_DUPLICATE: ComponentLink;
-export declare const BUNDLE_PACKAGES_DUPLICATE_NEW: ComponentLink;
+export declare const BUNDLE_PACKAGES_DUPLICATE_CHANGED: ComponentLink;
 export declare const getBundleAssetsFileTypeComponentLink: (fileType: string, label: string) => ComponentLink;
 export declare const getBundlePackagesByNameComponentLink: (search: string) => ComponentLink;
 export declare const getComponentStateQueryString: (params?: {}) => string;

package/types/utils/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./component-links";
 export * from "./delta";
 export * from "./date";
+export * from "./insights";
 export * from "./file-types";
 export * from "./format";
 export * from "./metrics";

package/types/utils/insights.d.ts

@@ -0,0 +1,9 @@
+import { JobInsight, JobInsightsInfo } from '../constants';
+interface InsightListItem {
+    name: string;
+    insight: JobInsight;
+    link: any;
+}
+export declare const getInsightList: (insights: JobInsightsInfo) => Array<InsightListItem>;
+export declare const getChangedInsights: (normalizedInsights: JobInsightsInfo) => JobInsightsInfo | null;
+export {};

package/types/webpack/constants.d.ts

@@ -7,4 +7,4 @@ export const SECTIONS: string[];
 export const SUMMARY_METRIC_PATHS: Metric[];
 export const MODULE_PATH_PACKAGES: RegExp;
 export const PACKAGE_PATH_NAME: RegExp;
-import { Metric } from "./types";
+import { Metric } from './types';

package/types/webpack/extract/assets-size-total-insight.d.ts

@@ -10,4 +10,4 @@ export function extractAssetsSizeTotalInsight(_: any, currentExtractedData: any,
         };
     };
 };
-import { InsightType } from "../../constants";
+import { InsightType } from '../../constants';

package/types/webpack/extract/modules-packages-duplicate.d.ts

@@ -1,13 +1,13 @@
 import { Job, JobInsight, JobInsightDuplicatePackagesV3Data, JobInsights, MetricRun } from '../../constants';
 interface ModulesPackagesDuplicateData {
-    insights: {
+    insights?: {
         duplicatePackages?: JobInsights['webpack']['duplicatePackages'];
-        duplicatePackagesV3: JobInsights['webpack']['duplicatePackagesV3'];
+        duplicatePackagesV3?: JobInsights['webpack']['duplicatePackagesV3'];
     };
     metrics: {
         duplicatePackagesCount: MetricRun;
     };
 }
-export declare const getDuplicatePackagesInsight: (duplicatePackagesMap: Record<string, Array<string>>, baselineDuplicatePackagesMap?: Record<string, Array<string>>) => JobInsight<JobInsightDuplicatePackagesV3Data>;
+export declare const getDuplicatePackagesInsight: (duplicatePackagesMap: Record<string, Array<string>>, baselineDuplicatePackagesMap?: Record<string, Array<string>>) => JobInsight<JobInsightDuplicatePackagesV3Data> | null;
 export declare const extractModulesPackagesDuplicate: (_: any, currentExtractedData: any, baselineJob?: Job) => ModulesPackagesDuplicateData;
 export {};

package/types/webpack/metrics.d.ts

@@ -148,6 +148,6 @@ export namespace metrics {
         }
     }
 }
-import { METRIC_TYPE_FILE_SIZE } from "../config/metrics";
-import { METRIC_TYPE_PERCENTAGE } from "../config/metrics";
-import { METRIC_TYPE_NUMERIC } from "../config/metrics";
+import { METRIC_TYPE_FILE_SIZE } from '../config/metrics';
+import { METRIC_TYPE_PERCENTAGE } from '../config/metrics';
+import { METRIC_TYPE_NUMERIC } from '../config/metrics';

package/types/webpack/types.d.ts

@@ -43,8 +43,8 @@ export interface MetricsAssets {
 }
 export interface Module extends MetricRun {
     name: string;
-    chunkIds: Array<String>;
-    duplicated: boolean;
+    chunkIds: Array<string>;
+    duplicated?: boolean;
 }
 export type Modules = Record<string, Module>;
 export interface MetricsModules {

package/tsconfig.lib.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false
-  },
-  "exclude": ["**/__tests__/*"]
-}