@bundle-stats/ui 4.13.4 → 4.14.0-beta.1

package/src/components/module-info/module-info.tsx

@@ -1,36 +1,210 @@
+import type { ElementType } from 'react';
 import React, { useMemo } from 'react';
 import cx from 'classnames';
-import isEmpty from 'lodash/isEmpty';
+import orderBy from 'lodash/orderBy';
 import noop from 'lodash/noop';
+import type { MetricRunInfo, MetricTypeConfig, ReportMetricRow } from '@bundle-stats/utils';
 import {
+  METRIC_TYPE_CONFIGS,
   BUNDLE_MODULES_DUPLICATE,
   FILE_TYPE_LABELS,
   MODULE_SOURCE_TYPE_LABELS,
-  MetricRunInfo,
+  formatNumber,
   getBundleModulesByChunk,
   getBundleModulesByFileTpe,
   getBundleModulesBySource,
+  getMetricRunInfo,
 } from '@bundle-stats/utils';
-import { Module, MetaChunk } from '@bundle-stats/utils/types/webpack';
+import type { Module, MetaChunk } from '@bundle-stats/utils/types/webpack';
 
+import type { ReportMetricModuleRow } from '../../types';
 import { Stack } from '../../layout/stack';
 import { Tag } from '../../ui/tag';
 import { ComponentLink } from '../component-link';
+import { RunInfo } from '../run-info';
 import { EntryInfo, EntryInfoMetaLink } from '../entry-info';
 import css from './module-info.module.css';
+import { FlexStack } from '../../layout';
+import { ModuleSizeMetric, ModuleSizeMetrics } from '../../constants';
+
+interface DuplicateInstancesProps {
+  current: number;
+  baseline: number;
+}
+
+const DuplicateInstances = ({ current, baseline }: DuplicateInstancesProps) => {
+  const runInfo = getMetricRunInfo(
+    { biggerIsBetter: false, formatter: formatNumber },
+    current,
+    baseline,
+  ) as MetricRunInfo;
+
+  return (
+    <RunInfo
+      current={runInfo.displayValue}
+      delta={runInfo.displayDeltaPercentage}
+      deltaPercentage={runInfo.displayDelta}
+      deltaType={runInfo.deltaType}
+      size="small"
+      className={css.duplicateInstances}
+    />
+  );
+};
+
+enum ChunkDataState {
+  ADDED = 2,
+  REMOVED = 1,
+  NOT_CHANGED = 0,
+}
+
+const ChunkDataStateKind = {
+  [ChunkDataState.ADDED]: 'info',
+  [ChunkDataState.REMOVED]: 'danger',
+  [ChunkDataState.NOT_CHANGED]: 'default',
+};
+
+interface ChunkData {
+  id: string;
+  state: ChunkDataState;
+}
+
+function compareChunksData(
+  currentChunkIds: Array<string>,
+  baselineChunkIds: Array<string>,
+): Array<ChunkData> {
+  const result: Array<ChunkData> = [];
+
+  currentChunkIds.forEach((chunkId) => {
+    if (!baselineChunkIds.includes(chunkId)) {
+      result.push({ id: chunkId, state: ChunkDataState.ADDED });
+    } else {
+      result.push({ id: chunkId, state: ChunkDataState.NOT_CHANGED });
+    }
+  });
+
+  baselineChunkIds.forEach((chunk) => {
+    if (!currentChunkIds.includes(chunk)) {
+      result.push({ id: chunk, state: ChunkDataState.REMOVED });
+    }
+  });
+
+  return orderBy(result, 'state', 'desc');
+}
+
+interface ChunksDeltaProps {
+  customComponentLink: ElementType;
+  runs: Array<Module & MetricRunInfo>;
+  chunks: Array<MetaChunk>;
+  chunkIds: Array<string>;
+}
+
+const ChunksDelta = (props: ChunksDeltaProps) => {
+  const { customComponentLink: CustomComponentLink, runs, chunks, chunkIds } = props;
+
+  const currentChunkIds = runs[0]?.chunkIds || [];
+  const baselineChunkIds = runs[runs.length - 1]?.chunkIds || [];
+
+  const chunksData = compareChunksData(currentChunkIds, baselineChunkIds);
+
+  return (
+    <Stack space="xxxsmall">
+      <div>
+        {chunksData.map((chunkData) => {
+          const chunk = chunks?.find(({ id }) => id === chunkData.id);
+
+          if (!chunk) {
+            return null;
+          }
+
+          return (
+            <EntryInfoMetaLink
+              as={CustomComponentLink}
+              {...getBundleModulesByChunk(chunkIds, chunkData.id)}
+              className={cx(
+                css.chunksItem,
+                css[`chunksItem-${ChunkDataStateKind[chunkData.state]}`],
+              )}
+            >
+              {chunk.name}
+            </EntryInfoMetaLink>
+          );
+        })}
+      </div>
+    </Stack>
+  );
+};
+
+interface ModuleSizeRunInfoProps {
+  metric: MetricTypeConfig;
+  title: string;
+  titleTooltip?: string;
+  current?: number;
+  baseline?: number;
+}
+
+const ModuleSizeRunInfo = (props: ModuleSizeRunInfoProps) => {
+  const { metric, title, titleTooltip, current, baseline } = props;
+
+  const runInfo = getMetricRunInfo(metric, current || 0, baseline || 0) as MetricRunInfo;
+
+  return (
+    <RunInfo
+      title={title}
+      titleTooltip={titleTooltip}
+      current={runInfo.displayValue}
+      delta={runInfo.displayDeltaPercentage}
+      deltaPercentage={runInfo.displayDelta}
+      deltaType={runInfo.deltaType}
+      baseline={metric.formatter(baseline || 0)}
+    />
+  );
+};
+
+const renderRunInfo = (item: ReportMetricRow) => {
+  const itemModule = item as ReportMetricModuleRow;
+
+  const currentRun = itemModule.runs[0];
+  const baselineRun =
+    itemModule.runs.length > 1 ? itemModule.runs[itemModule.runs.length - 1] : null;
+  const metric = METRIC_TYPE_CONFIGS.METRIC_TYPE_FILE_SIZE;
+
+  return (
+    <FlexStack space="small" className={css.moduleSizes}>
+      {itemModule.duplicated && (
+        <>
+          <ModuleSizeRunInfo
+            metric={metric}
+            title={ModuleSizeMetrics[ModuleSizeMetric.TOTAL_SIZE].label}
+            titleTooltip={ModuleSizeMetrics[ModuleSizeMetric.TOTAL_SIZE].tooltip}
+            current={currentRun.sizeTotal}
+            baseline={baselineRun.sizeTotal}
+          />
+          <ModuleSizeRunInfo
+            metric={metric}
+            title={ModuleSizeMetrics[ModuleSizeMetric.DUPLICATE_SIZE].label}
+            titleTooltip={ModuleSizeMetrics[ModuleSizeMetric.DUPLICATE_SIZE].tooltip}
+            current={currentRun.sizeDuplicate}
+            baseline={baselineRun.sizeDuplicate}
+          />
+        </>
+      )}
+      <ModuleSizeRunInfo
+        metric={metric}
+        title={ModuleSizeMetrics[ModuleSizeMetric.SIZE].label}
+        titleTooltip={ModuleSizeMetrics[ModuleSizeMetric.SIZE].tooltip}
+        current={currentRun.size}
+        baseline={baselineRun.size}
+      />
+    </FlexStack>
+  );
+};
 
 interface ModuleInfoProps {
-  item: {
-    label: string;
-    changed?: boolean;
-    duplicated?: boolean;
-    thirdParty?: boolean;
-    fileType?: string;
-    runs: Array<Module & MetricRunInfo>;
-  };
+  item: ReportMetricModuleRow;
   chunks?: Array<MetaChunk>;
   chunkIds?: Array<string>;
   labels: Array<string>;
+  metricLabel?: string;
   customComponentLink?: React.ElementType;
   onClose: () => void;
 }
@@ -42,6 +216,7 @@ export const ModuleInfo = (props: ModuleInfoProps & React.ComponentProps<'div'>)
     labels,
     chunks = [],
     chunkIds = [],
+    metricLabel = '',
     customComponentLink: CustomComponentLink = ComponentLink,
     onClick = noop,
     onClose,
@@ -69,37 +244,25 @@ export const ModuleInfo = (props: ModuleInfoProps & React.ComponentProps<'div'>)
     ? MODULE_SOURCE_TYPE_LABELS.THIRD_PARTY
     : MODULE_SOURCE_TYPE_LABELS.FIRST_PARTY;
 
+  const currentChunkCount = (item.runs[0]?.chunkIds || []).length;
+  const baselineChunkCount = (item.runs[item.runs.length - 1]?.chunkIds || []).length;
+  const currentDuplicateInstances = currentChunkCount > 0 ? currentChunkCount - 1 : 0;
+  const baselineDuplicateInstances = baselineChunkCount > 0 ? baselineChunkCount - 1 : 0;
+  const hasDuplicates = currentDuplicateInstances !== 0 || baselineDuplicateInstances !== 0;
+
   return (
-    <EntryInfo item={item} labels={labels} tags={tags} onClose={onClose} className={rootClassName}>
+    <EntryInfo
+      item={item as ReportMetricRow}
+      labels={labels}
+      tags={tags}
+      onClose={onClose}
+      renderRunInfo={renderRunInfo}
+      runSizeLabel={metricLabel}
+      className={rootClassName}
+    >
       <Stack space="xxxsmall">
-        {item.runs?.map(
-          (currentRun, index) =>
-            !isEmpty(currentRun?.chunkIds) && (
-              <EntryInfo.Meta label="Chunks" className={css.chunks}>
-                {labels[index]}:
-                {currentRun.chunkIds.map((chunkId) => {
-                  const chunk = chunks?.find(({ id }) => id === chunkId);
-
-                  if (!chunk) {
-                    return null;
-                  }
-
-                  return (
-                    <EntryInfoMetaLink
-                      as={CustomComponentLink}
-                      {...getBundleModulesByChunk(chunkIds, chunkId)}
-                      className={css.chunksItem}
-                    >
-                      {chunk.name}
-                    </EntryInfoMetaLink>
-                  );
-                })}
-              </EntryInfo.Meta>
-          ),
-        )}
-
         {item?.fileType && (
-          <EntryInfo.Meta label="File type">
+          <EntryInfo.Meta label="File type" tooltip="Module file type: JS, CSS">
             <EntryInfoMetaLink
               as={CustomComponentLink}
               {...getBundleModulesByFileTpe(item.fileType, fileTypeLabel)}
@@ -109,7 +272,7 @@ export const ModuleInfo = (props: ModuleInfoProps & React.ComponentProps<'div'>)
           </EntryInfo.Meta>
         )}
 
-        <EntryInfo.Meta label="Source">
+        <EntryInfo.Meta label="Source" tooltip="Module source type: first party, third party">
           <EntryInfoMetaLink
             as={CustomComponentLink}
             {...getBundleModulesBySource(item.thirdParty || false, sourceTypeLabel)}
@@ -118,6 +281,24 @@ export const ModuleInfo = (props: ModuleInfoProps & React.ComponentProps<'div'>)
             {sourceTypeLabel}
           </EntryInfoMetaLink>
         </EntryInfo.Meta>
+
+        {hasDuplicates && (
+          <EntryInfo.Meta label="Duplicates" tooltip="Module duplicate instances">
+            <DuplicateInstances
+              current={currentDuplicateInstances}
+              baseline={baselineDuplicateInstances}
+            />
+          </EntryInfo.Meta>
+        )}
+
+        <EntryInfo.Meta label="Chunks" tooltip="Chunks that contain the module">
+          <ChunksDelta
+            runs={item.runs}
+            chunks={chunks}
+            chunkIds={chunkIds}
+            customComponentLink={CustomComponentLink}
+          />
+        </EntryInfo.Meta>
       </Stack>
     </EntryInfo>
   );

package/src/components/package-info/package-info.tsx

@@ -1,5 +1,4 @@
 import React, { useMemo } from 'react';
-import noop from 'lodash/noop';
 import {
   BUNDLE_PACKAGES_DUPLICATE,
   PACKAGES_SEPARATOR,
@@ -79,14 +78,14 @@ export const PackageInfo = (props: PackageInfoProps & React.ComponentProps<'div'
   return (
     <EntryInfo
       itemTitle={packageTitle}
-      item={item}
+      item={item as any}
       labels={labels}
       tags={tags}
       runNameSelector="path"
       onClose={onClose}
       className={className}
     >
-      <EntryInfo.Meta label="Path">
+      <EntryInfo.Meta label="Path" tooltip="Package path">
         <FileName name={normalizedPackagePath} className={css.fileName} />
       </EntryInfo.Meta>
 

package/src/components/run-info/run-info.module.css

@@ -19,7 +19,7 @@
   margin-bottom: -3px !important;
 }
 
-.info {
+.title + .info {
   margin-top: var(--space-xxsmall);
 }
 

package/src/constants.ts

@@ -39,9 +39,30 @@ export const METRICS_WEBPACK_PACKAGES = ['webpack.packageCount', 'webpack.duplic
 export const SORT = {
   ASC: 'asc',
   DESC: 'desc',
-};
+} as const;
 
 export enum MetricsDisplayType {
   TABLE = 'table',
   TREEMAP = 'treemap',
 }
+
+export enum ModuleSizeMetric {
+  SIZE = 'value',
+  DUPLICATE_SIZE = 'duplicateSize',
+  TOTAL_SIZE = 'totalSize',
+}
+
+export const ModuleSizeMetrics = {
+  [ModuleSizeMetric.SIZE]: {
+    label: 'Size',
+    tooltip: 'Module size (excluding duplicate modules)',
+  },
+  [ModuleSizeMetric.TOTAL_SIZE]: {
+    label: 'Total size',
+    tooltip: 'Module total size (including duplicate modules)',
+  },
+  [ModuleSizeMetric.DUPLICATE_SIZE]: {
+    label: 'Duplicate size',
+    tooltip: 'Module duplicate size',
+  },
+};

package/src/hooks/rows-sort.ts

@@ -5,15 +5,9 @@ import orderBy from 'lodash/orderBy';
 import type { SortAction } from '../types';
 import { SORT } from '../constants';
 
-interface UseRowsSortParams {
-  rows: Array<unknown>;
-  initialField?: string;
-  initialDirection?: SortAction['direction'];
-  getCustomSort: (item: any) => Array<string | number | boolean>;
-}
-
 export const getSortFn =
-  (fieldPath: string, getCustomSort: UseRowsSortParams['getCustomSort']) => (item: unknown) => {
+  <TRow>(fieldPath: string, getCustomSort: UseRowsSortParams<TRow>['getCustomSort']) =>
+  (item: TRow) => {
     if (!fieldPath) {
       return getCustomSort(item);
     }
@@ -21,12 +15,25 @@ export const getSortFn =
     return get(item, fieldPath) || 0;
   };
 
-export const useRowsSort = ({
+interface UseRowsSortParams<TRow> {
+  rows: Array<TRow>;
+  initialField?: string;
+  initialDirection?: SortAction['direction'];
+  getCustomSort: (item: any) => Array<string | number | boolean>;
+}
+
+interface UseRowsSort<TRow> {
+  items: Array<TRow>;
+  sort: SortAction;
+  updateSort: (params: SortAction) => void;
+}
+
+export const useRowsSort = <TRow>({
   rows,
   initialField = 'runs[0].delta',
   initialDirection = 'desc',
   getCustomSort,
-}: UseRowsSortParams) => {
+}: UseRowsSortParams<TRow>): UseRowsSort<TRow> => {
   const [sort, updateSort] = useState({ field: initialField, direction: initialDirection });
 
   const orderedRows = useMemo(

package/src/types.d.ts

@@ -1,3 +1,6 @@
+import type { ReportMetricRow } from '@bundle-stats/utils';
+import type { Module } from '@bundle-stats/utils/types/webpack/types';
+
 export interface SortAction {
   field: string;
   direction: 'asc' | 'desc' | '';
@@ -15,3 +18,13 @@ type FilterGroupFieldData = {
 };
 
 type FilterFieldsData = Record<string, FilterFieldData | FilterGroupFieldData>;
+
+export type ReportMetricModuleRow = {
+  thirdParty: boolean;
+  duplicated: boolean;
+  fileType: string;
+} & Omit<ReportMetricRow, 'runs'> & {
+    runs: Array<
+      (Module & ReportMetricRun & { size: number; sizeDuplicate: number; sizeTotal: number }) | null
+    >;
+  };

package/types/components/bundle-modules/bundle-modules.d.ts

@@ -1,9 +1,8 @@
 import React from 'react';
 import { type Job } from '@bundle-stats/utils';
 import { WebpackChunk } from '@bundle-stats/utils';
-import { SortAction } from '../../types';
-import { ModuleMetric } from './bundle-modules.constants';
-import type { ReportMetricModuleRow } from './bundle-modules.types';
+import type { ReportMetricModuleRow, SortAction } from '../../types';
+import { ModuleSizeMetric } from '../../constants';
 interface BundleModulesProps extends React.ComponentProps<'div'> {
     jobs?: Array<Job>;
     items?: Array<ReportMetricModuleRow>;
@@ -21,8 +20,8 @@ interface BundleModulesProps extends React.ComponentProps<'div'> {
     entryId?: string;
     hideEntryInfo: () => void;
     showEntryInfo: (entryId: string) => void;
-    moduleMetric: ModuleMetric;
-    setModuleMetric: (newValue: ModuleMetric) => void;
+    moduleMetric: ModuleSizeMetric;
+    setModuleMetric: (newValue: ModuleSizeMetric) => void;
     customComponentLink: React.ElementType;
 }
 export declare const BundleModules: (props: BundleModulesProps) => React.JSX.Element;

package/types/components/bundle-modules/bundle-modules.utils.d.ts

@@ -1,8 +1,6 @@
-import { type WebpackChunk, type ReportMetricRow } from '@bundle-stats/utils';
-import { type Module } from '@bundle-stats/utils/lib-esm/webpack';
-import type { FilterFieldsData } from '../../types';
-import type { ReportMetricModuleRow } from './bundle-modules.types';
-export declare const addRowFlags: (row: Module & ReportMetricRow) => ReportMetricModuleRow;
+import type { WebpackChunk, ReportMetricRow } from '@bundle-stats/utils';
+import type { FilterFieldsData, ReportMetricModuleRow } from '../../types';
+export declare const addRowFlags: (row: ReportMetricRow) => ReportMetricModuleRow;
 export declare const getCustomSort: (item: ReportMetricRow) => (string | boolean)[];
 export declare const generateGetRowFilter: ({ chunkIds }: {
     chunkIds: Array<string>;

package/types/components/entry-info/entry-info.d.ts

@@ -1,29 +1,27 @@
+import type { ElementType, ReactNode } from 'react';
 import React from 'react';
-import { MetricRunInfo } from '@bundle-stats/utils';
+import type { ReportMetricRow } from '@bundle-stats/utils';
 interface EntryInfoMetaLinkProps {
-    as?: React.ElementType;
+    as?: ElementType;
 }
 export declare const EntryInfoMetaLink: (props: EntryInfoMetaLinkProps & React.ComponentProps<"a">) => React.JSX.Element;
 interface EntryInfoMetaProps {
     label: string;
-}
-interface EntryRun {
-    name: string;
+    tooltip?: ReactNode;
 }
 interface EntryInfoProps {
     itemTitle?: React.ReactNode;
-    item: {
-        label: string;
-        runs: Array<EntryRun & MetricRunInfo>;
-    };
+    item: ReportMetricRow;
     labels: Array<string>;
     runNameSelector?: string;
     runNameLabel?: string;
+    runSizeLabel?: string;
     tags?: React.ReactNode;
     onClose: () => void;
+    renderRunInfo?: (item: ReportMetricRow) => React.ReactNode;
 }
 export declare const EntryInfo: {
     (props: EntryInfoProps & React.ComponentProps<"div">): React.JSX.Element;
-    Meta: ({ className, label, children, }: EntryInfoMetaProps & React.ComponentProps<"p">) => React.JSX.Element;
+    Meta: ({ className, label, tooltip, children, }: EntryInfoMetaProps & React.ComponentProps<"p">) => React.JSX.Element;
 };
 export {};

package/types/components/module-info/module-info.d.ts

@@ -1,18 +1,12 @@
 import React from 'react';
-import { MetricRunInfo } from '@bundle-stats/utils';
-import { Module, MetaChunk } from '@bundle-stats/utils/types/webpack';
+import type { MetaChunk } from '@bundle-stats/utils/types/webpack';
+import type { ReportMetricModuleRow } from '../../types';
 interface ModuleInfoProps {
-    item: {
-        label: string;
-        changed?: boolean;
-        duplicated?: boolean;
-        thirdParty?: boolean;
-        fileType?: string;
-        runs: Array<Module & MetricRunInfo>;
-    };
+    item: ReportMetricModuleRow;
     chunks?: Array<MetaChunk>;
     chunkIds?: Array<string>;
     labels: Array<string>;
+    metricLabel?: string;
     customComponentLink?: React.ElementType;
     onClose: () => void;
 }

package/types/constants.d.ts

@@ -13,10 +13,29 @@ export declare const METRICS_WEBPACK_ASSETS: string[];
 export declare const METRICS_WEBPACK_MODULES: string[];
 export declare const METRICS_WEBPACK_PACKAGES: string[];
 export declare const SORT: {
-    ASC: string;
-    DESC: string;
+    readonly ASC: "asc";
+    readonly DESC: "desc";
 };
 export declare enum MetricsDisplayType {
     TABLE = "table",
     TREEMAP = "treemap"
 }
+export declare enum ModuleSizeMetric {
+    SIZE = "value",
+    DUPLICATE_SIZE = "duplicateSize",
+    TOTAL_SIZE = "totalSize"
+}
+export declare const ModuleSizeMetrics: {
+    value: {
+        label: string;
+        tooltip: string;
+    };
+    totalSize: {
+        label: string;
+        tooltip: string;
+    };
+    duplicateSize: {
+        label: string;
+        tooltip: string;
+    };
+};

package/types/hooks/rows-sort.d.ts

@@ -1,20 +1,15 @@
 import type { SortAction } from '../types';
-interface UseRowsSortParams {
-    rows: Array<unknown>;
+export declare const getSortFn: <TRow>(fieldPath: string, getCustomSort: UseRowsSortParams<TRow>["getCustomSort"]) => (item: TRow) => any;
+interface UseRowsSortParams<TRow> {
+    rows: Array<TRow>;
     initialField?: string;
     initialDirection?: SortAction['direction'];
     getCustomSort: (item: any) => Array<string | number | boolean>;
 }
-export declare const getSortFn: (fieldPath: string, getCustomSort: UseRowsSortParams["getCustomSort"]) => (item: unknown) => any;
-export declare const useRowsSort: ({ rows, initialField, initialDirection, getCustomSort, }: UseRowsSortParams) => {
-    sort: {
-        field: string;
-        direction: "" | "asc" | "desc";
-    };
-    updateSort: import("react").Dispatch<import("react").SetStateAction<{
-        field: string;
-        direction: "" | "asc" | "desc";
-    }>>;
-    items: unknown[];
-};
+interface UseRowsSort<TRow> {
+    items: Array<TRow>;
+    sort: SortAction;
+    updateSort: (params: SortAction) => void;
+}
+export declare const useRowsSort: <TRow>({ rows, initialField, initialDirection, getCustomSort, }: UseRowsSortParams<TRow>) => UseRowsSort<TRow>;
 export {};

package/lib/components/bundle-modules/bundle-modules.constants.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleMetric = void 0;
-var ModuleMetric;
-(function (ModuleMetric) {
-    ModuleMetric["SIZE"] = "value";
-    ModuleMetric["TOTAL_SIZE"] = "totalSize";
-})(ModuleMetric || (exports.ModuleMetric = ModuleMetric = {}));
-//# sourceMappingURL=bundle-modules.constants.js.map

package/lib/components/bundle-modules/bundle-modules.constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle-modules.constants.js","sourceRoot":"","sources":["../../../src/components/bundle-modules/bundle-modules.constants.ts"],"names":[],"mappings":";;;AAAA,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,8BAAc,CAAA;IACd,wCAAwB,CAAA;AAC1B,CAAC,EAHW,YAAY,4BAAZ,YAAY,QAGvB"}

package/lib-esm/components/bundle-modules/bundle-modules.constants.js

@@ -1,6 +0,0 @@
-export var ModuleMetric;
-(function (ModuleMetric) {
-    ModuleMetric["SIZE"] = "value";
-    ModuleMetric["TOTAL_SIZE"] = "totalSize";
-})(ModuleMetric || (ModuleMetric = {}));
-//# sourceMappingURL=bundle-modules.constants.js.map

package/lib-esm/components/bundle-modules/bundle-modules.constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle-modules.constants.js","sourceRoot":"","sources":["../../../src/components/bundle-modules/bundle-modules.constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,8BAAc,CAAA;IACd,wCAAwB,CAAA;AAC1B,CAAC,EAHW,YAAY,KAAZ,YAAY,QAGvB"}

package/src/components/bundle-modules/bundle-modules.constants.ts

@@ -1,4 +0,0 @@
-export enum ModuleMetric {
-  SIZE = 'value',
-  TOTAL_SIZE = 'totalSize',
-}

package/src/components/bundle-modules/bundle-modules.types.d.ts

@@ -1,9 +0,0 @@
-import type { Module } from '@bundle-stats/utils/lib-esm/webpack/types';
-import type { ReportMetricRun } from '@bundle-stats/utils/types/report/types';
-
-export type ReportMetricModuleRow = {
-  thirdParty: boolean;
-  duplicated: boolean;
-  fileType: string;
-} & ReportMetricRun &
-  Module;

package/types/components/bundle-modules/bundle-modules.constants.d.ts

@@ -1,4 +0,0 @@
-export declare enum ModuleMetric {
-    SIZE = "value",
-    TOTAL_SIZE = "totalSize"
-}