@bundle-stats/utils 4.4.0-beta.0 → 4.4.0-beta.3

package/src/utils/component-links.ts

@@ -16,6 +16,7 @@ import {
   MODULE_FILE_TYPE,
   MODULE_FILTERS,
   MODULE_SOURCE_TYPE,
+  MODULE_SOURCE_TYPE_LABELS,
   PACKAGE_FILTERS,
   SECTIONS,
 } from '../config/component-links';
@@ -25,6 +26,7 @@ export type ComponentLinkFilters = Record<string, boolean>;
 
 export interface ComponentLinkParams {
   search?: string;
+  entryId?: string;
   filters: ComponentLinkFilters;
 }
 
@@ -159,6 +161,51 @@ export const BUNDLE_ASSETS_CHUNK_COUNT: ComponentLink = {
   },
 };
 
+export const getBundleAsset = (entryId: string): ComponentLink => ({
+  section: SECTIONS.ASSETS,
+  title: 'View asset details' as any,
+  params: {
+    [COMPONENT.BUNDLE_ASSETS]: {
+      entryId,
+      filters: {},
+    },
+  },
+});
+
+export const getBundleAssetsByEntryType = (
+  assetType: 'entry' | 'initial' | 'chunk',
+): ComponentLink => ({
+  section: SECTIONS.ASSETS,
+  title: I18N.COMPONENT_LINK_BUNDLE_ASSETS_BY_ENTRY_TYPE(assetType),
+  params: {
+    [COMPONENT.BUNDLE_ASSETS]: {
+      filters: {
+        [ASSET_FILTERS.CHANGED]: false,
+        ...getAssetEntryTypeFilters(false),
+        [`${ASSET_ENTRY_TYPE}.${ASSET_FILTERS.ENTRY}`]: assetType === 'entry',
+        [`${ASSET_ENTRY_TYPE}.${ASSET_FILTERS.INITIAL}`]: assetType === 'initial',
+        [`${ASSET_ENTRY_TYPE}.${ASSET_FILTERS.CHUNK}`]: assetType === 'chunk',
+      },
+    },
+  },
+});
+
+export const getBundleAssetsFileTypeComponentLink = (
+  fileType: string,
+  label: string = fileType,
+): ComponentLink => ({
+  section: SECTIONS.ASSETS,
+  title: I18N.COMPONENT_LINK_BUNDLE_ASSETS_BY_FILE_TYPE({ label }),
+  params: {
+    [COMPONENT.BUNDLE_ASSETS]: {
+      filters: {
+        ...getAssetFileTypeFilters(false),
+        [`${ASSET_FILE_TYPE}.${fileType}`]: true,
+      },
+    },
+  },
+});
+
 export const BUNDLE_MODULES: ComponentLink = {
   section: SECTIONS.MODULES,
   title: I18N.COMPONENT_LINK_MODULES,
@@ -221,6 +268,35 @@ export const getBundleModulesByChunk = (
   },
 });
 
+export const getBundleModulesByFileTpe = (
+  fileType: string,
+  fileTypeLabel?: string,
+): ComponentLink => ({
+  section: SECTIONS.MODULES,
+  title: I18N.COMPONENT_LINK_MODULES_BY_FILE_TYPE(fileTypeLabel || fileType),
+  params: {
+    [COMPONENT.BUNDLE_MODULES]: {
+      filters: {
+        ...getModuleFileTypeFilters(false),
+        [`${MODULE_FILE_TYPE}.${fileType}`]: true,
+      },
+    },
+  },
+});
+
+export const getBundleModulesBySource = (thirdParty: boolean, label = ''): ComponentLink => ({
+  section: SECTIONS.MODULES,
+  title: I18N.COMPONENT_LINK_MODULES_BY_SOURCE(label),
+  params: {
+    [COMPONENT.BUNDLE_MODULES]: {
+      filters: {
+        [`${MODULE_SOURCE_TYPE}.${MODULE_FILTERS.THIRD_PARTY}`]: thirdParty,
+        [`${MODULE_SOURCE_TYPE}.${MODULE_FILTERS.FIRST_PARTY}`]: !thirdParty,
+      },
+    },
+  },
+});
+
 export const BUNDLE_PACKAGES_COUNT: ComponentLink = {
   section: SECTIONS.PACKAGES,
   title: I18N.COMPONENT_LINK_PACKAGES_COUNT,
@@ -234,6 +310,19 @@ export const BUNDLE_PACKAGES_COUNT: ComponentLink = {
   },
 };
 
+export const BUNDLE_PACKAGES_CHANGED: ComponentLink = {
+  section: SECTIONS.PACKAGES,
+  title: I18N.COMPONENT_LINK_PACKAGES_CHANGED,
+  params: {
+    [COMPONENT.BUNDLE_PACKAGES]: {
+      filters: {
+        // Keep a filter to allow the merge and skip default
+        [PACKAGE_FILTERS.CHANGED]: true,
+      },
+    },
+  },
+};
+
 export const BUNDLE_PACKAGES_DUPLICATE: ComponentLink = {
   section: SECTIONS.PACKAGES,
   title: I18N.COMPONENT_LINK_PACKAGES_DUPLICATE,
@@ -246,21 +335,18 @@ export const BUNDLE_PACKAGES_DUPLICATE: ComponentLink = {
   },
 };
 
-export const getBundleAssetsFileTypeComponentLink = (
-  fileType: string,
-  label: string,
-): ComponentLink => ({
-  section: SECTIONS.ASSETS,
-  title: I18N.COMPONENT_LINK_BUNDLE_ASSETS_BY_FILE_TYPE({ label }),
+export const BUNDLE_PACKAGES_DUPLICATE_CHANGED: ComponentLink = {
+  section: SECTIONS.PACKAGES,
+  title: I18N.COMPONENT_LINK_PACKAGES_DUPLICATE_CHANGED,
   params: {
-    [COMPONENT.BUNDLE_ASSETS]: {
+    [COMPONENT.BUNDLE_PACKAGES]: {
       filters: {
-        ...getAssetFileTypeFilters(false),
-        [`${ASSET_FILE_TYPE}.${fileType}`]: true,
+        [PACKAGE_FILTERS.CHANGED]: true,
+        [PACKAGE_FILTERS.DUPLICATE]: true,
       },
     },
   },
-});
+};
 
 export const getBundlePackagesByNameComponentLink = (search: string): ComponentLink => ({
   section: SECTIONS.PACKAGES,

package/src/utils/index.js

@@ -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/src/utils/insights.ts

@@ -0,0 +1,82 @@
+import isEmpty from 'lodash/isEmpty';
+
+import { InsightType, JobInsight, JobInsightsInfo } from '../constants';
+import {
+  BUNDLE_PACKAGES_DUPLICATE,
+  BUNDLE_PACKAGES_CHANGED,
+  BUNDLE_PACKAGES_DUPLICATE_CHANGED,
+} from './component-links';
+
+interface InsightListItem {
+  /**
+   * Inight name
+   */
+  name: string;
+  /**
+   * Insight data
+   */
+  insight: JobInsight;
+  /**
+   * Custom link props
+   */
+  link: any;
+}
+
+/**
+ * Get the insigh list ordered by level type
+ */
+export const getInsightList = (insights: JobInsightsInfo): Array<InsightListItem> => {
+  const { duplicatePackages, newPackages } = insights;
+
+  const insightsByLevel: Record<InsightType, Array<InsightListItem>> = {
+    [InsightType.ERROR]: [],
+    [InsightType.WARNING]: [],
+    [InsightType.INFO]: [],
+  };
+
+  if (duplicatePackages) {
+    insightsByLevel[duplicatePackages.type].push({
+      name: 'duplicatePackages',
+      insight: duplicatePackages,
+      link:
+        duplicatePackages.type === InsightType.WARNING
+          ? BUNDLE_PACKAGES_DUPLICATE
+          : BUNDLE_PACKAGES_DUPLICATE_CHANGED,
+    });
+  }
+
+  if (newPackages) {
+    insightsByLevel[newPackages.type].push({
+      name: 'newPackages',
+      insight: newPackages,
+      link: BUNDLE_PACKAGES_CHANGED,
+    });
+  }
+
+  return [
+    ...(insightsByLevel[InsightType.ERROR] || []),
+    ...(insightsByLevel[InsightType.WARNING] || []),
+    ...(insightsByLevel[InsightType.INFO] || []),
+  ];
+};
+
+/**
+ * Show only the insights that are introduced by a change
+ */
+export const getChangedInsights = (normalizedInsights: JobInsightsInfo): JobInsightsInfo | null => {
+  const res: JobInsightsInfo = {};
+
+  if (normalizedInsights.duplicatePackages?.type === InsightType.ERROR) {
+    res.duplicatePackages = normalizedInsights.duplicatePackages;
+  }
+
+  if (normalizedInsights.newPackages) {
+    res.newPackages = normalizedInsights.newPackages;
+  }
+
+  if (isEmpty(res)) {
+    return null;
+  }
+
+  return res;
+};

package/src/webpack/extract/assets-size-total-insight.js

@@ -1,4 +1,4 @@
-import { InsightType } from '../../config/insights';
+import { InsightType } from '../../constants';
 import { getMetricRunInfo } from '../../utils/metrics';
 import { getMetricType } from '../utils';
 import { Metric } from '../types';

package/src/webpack/extract/index.js

@@ -11,6 +11,7 @@ import { extractModules } from './modules';
 import { extractModulesPackages } from './modules-packages';
 import { extractModulesPackagesCount } from './modules-packages-count';
 import { extractModulesPackagesDuplicate } from './modules-packages-duplicate';
+import { extractModulesPackagesNewInsight } from './modules-packages-new-insight';
 
 const extractFns = [
   extractAssets,
@@ -24,6 +25,7 @@ const extractFns = [
   extractModulesPackages,
   extractModulesPackagesCount,
   extractModulesPackagesDuplicate,
+  extractModulesPackagesNewInsight,
 ];
 
 export const extract = (webpackStats, baseline) =>

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

@@ -1,9 +1,10 @@
+import isEmpty from 'lodash/isEmpty';
 import map from 'lodash/map';
 import orderBy from 'lodash/orderBy';
 import sum from 'lodash/sum';
 
-import { InsightType } from '../../config';
 import {
+  InsightType,
   Job,
   JobInsight,
   JobInsightDuplicatePackagesData,
@@ -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-packages-new-insight.ts

@@ -0,0 +1,80 @@
+import { InsightType, Job, JobInsights } from '../../constants';
+import { Packages } from '../types';
+
+interface ModulesPackagesNewData {
+  insights?: {
+    newPackages: JobInsights['webpack']['newPackages'];
+  };
+}
+
+const getPackageNames = (packages: Packages): Set<string> => {
+  const result: Set<string> = new Set();
+
+  Object.values(packages).forEach((metricPackage) => {
+    result.add(metricPackage.name);
+  });
+
+  return result;
+};
+
+const getText = (newPackages: Array<string>) => {
+  if (newPackages.length === 1) {
+    return `Bundle introduced one new package: ${newPackages[0]}`;
+  }
+
+  const firstNewPackages = newPackages.slice(0, 3);
+  const otherPackages = newPackages.slice(3);
+
+  const text = `Bundle introduced ${newPackages.length} new packages: ${firstNewPackages.join(', ')}`;
+
+  if (otherPackages.length === 0) {
+    return text;
+  }
+
+  if (otherPackages.length === 1) {
+    return `${text} and one more`;
+  }
+
+  return `${text} and ${otherPackages.length} more`;
+};
+
+export const extractModulesPackagesNewInsight = (
+  _: any,
+  currentExtractedData: any,
+  baselineJob?: Job,
+): ModulesPackagesNewData | null => {
+  const currentMetricPackages = currentExtractedData?.metrics?.packages as Packages;
+  const baselineMetricPackages = baselineJob?.metrics?.webpack?.packages as Packages;
+
+  // Skip insight when the baseline data is missing
+  if (!baselineMetricPackages) {
+    return null;
+  }
+
+  const currentPackages = getPackageNames(currentMetricPackages);
+  const baselinePackages = getPackageNames(baselineMetricPackages);
+
+  const newPackages: Array<string> = [];
+
+  currentPackages.forEach((packageName) => {
+    if (!baselinePackages.has(packageName)) {
+      newPackages.push(packageName);
+    }
+  });
+
+  if (newPackages.length === 0) {
+    return null;
+  }
+
+  return {
+    insights: {
+      newPackages: {
+        type: InsightType.WARNING,
+        data: {
+          text: getText(newPackages),
+          packages: newPackages,
+        },
+      },
+    },
+  };
+};

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,60 +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;
     }
 
-    // eslint-disable-next-line no-param-reassign
-    agg = agg.concat(
-      moduleEntry.modules.map((concatenatedModule) => ({
-        ...concatenatedModule,
-        // Add parent chunks
-        chunks: moduleEntry.chunks,
-      })),
-    );
+    // 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;
+    }
 
-    return agg;
-  }, [] as Array<WebpackStatsFilteredRootModule>);
+    modulesByName.set(normalizedName, rootModule);
+  });
+
+  // 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 are orphane(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;
 
-    const reasons = moduleEntry.reasons?.map((reason) => getModuleName(reason.module));
+    if (duplicated) {
+      duplicateModulesCount += duplicateInstances;
+      duplicateCodeSize += duplicateInstances * size;
+    }
 
-    // eslint-disable-next-line no-param-reassign
-    agg[normalizedName] = {
+    modules[normalizedName] = {
       name,
       value: size,
       chunkIds: chunks.map(normalizeChunkId),
-      duplicated: Boolean(duplicateInstances),
-      ...(reasons && { reasons }),
+      ...(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

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