@bundle-stats/utils 4.7.5-alpha.0 → 4.7.5-beta.2

package/src/constants.ts

@@ -12,39 +12,73 @@ export enum InsightType {
   WARNING = 'warning',
 }
 
-export enum MetricTypeType {
-  METRIC_TYPE_NUMERIC = 'METRIC_TYPE_NUMERIC',
-  METRIC_TYPE_SCORE = 'METRIC_TYPE_SCORE',
-  METRIC_TYPE_FILE_SIZE = 'METRIC_TYPE_FILE_SIZE',
-  METRIC_TYPE_DURATION = 'METRIC_TYPE_DURATION',
-  METRIC_TYPE_PERCENTAGE = 'METRIC_TYPE_PERCENTAGE',
+/**
+ * Generic metric type names
+ */
+export enum MetricTypes {
+  Numeric = 'METRIC_TYPE_NUMERIC',
+  Score = 'METRIC_TYPE_SCORE',
+  FileSize = 'METRIC_TYPE_FILE_SIZE',
+  Duration = 'METRIC_TYPE_DURATION',
+  Percentage = 'METRIC_TYPE_PERCENTAGE',
 }
 
+/**
+ * Metric type base configuration
+ */
 export interface MetricTypeConfig {
-  label: string;
-  description: string;
-  type: MetricTypeType;
+  /**
+   * Increased values are regressions, decreased values are improvements
+   */
+  biggerIsBetter?: boolean | null;
+  /**
+   * Value formatter
+   */
+  formatter: (value: number | null) => string;
 }
 
-export interface MetricType extends MetricTypeConfig {
-  formatter: Function;
-  biggerIsBetter: boolean;
+/**
+ * Source metric configuration
+ */
+export interface MetricConfig {
+  label: string;
+  type: MetricTypes;
+  description?: string;
+  /**
+   * Documentation URL
+   */
+  url?: string;
+  /**
+   * Positive delta values are regressions and negative delta values are improvements
+   * overrides MetricTypeConfig['biggerIsBetter']
+   */
+  biggerIsBetter?: MetricTypeConfig['biggerIsBetter'];
+  /**
+   * Do not show the delta
+   */
+  skipDelta?: boolean;
 }
 
-export enum MetricRunInfoDeltaType {
-  'HIGH_NEGATIVE' = 'HIGH_NEGATIVE',
-  'NEGATIVE' = 'NEGATIVE',
-  'LOW_NEGATIVE' = 'LOW_NEGATIVE',
-  'NO_CHANGE' = 'NO_CHANGE',
-  'LOW_POSITIVE' = 'LOW_POSITIVE',
-  'POSITIVE' = 'POSITIVE',
-  'HIGH_POSITIVE' = 'HIGH_POSITIVE',
-}
+export type Metric = MetricTypeConfig & MetricConfig;
+
+export type MetricRunInfoDeltaType =
+  | 'HIGH_NEGATIVE'
+  | 'NEGATIVE'
+  | 'LOW_NEGATIVE'
+  | 'NO_CHANGE'
+  | 'LOW_POSITIVE'
+  | 'POSITIVE'
+  | 'HIGH_POSITIVE';
 
 export interface MetricRun {
   value: number;
 }
 
+export interface MetricRunDelta {
+  delta: number;
+  deltaPercentage: number;
+}
+
 export interface MetricRunInfo {
   value: number;
   displayValue: string;
@@ -53,6 +87,7 @@ export interface MetricRunInfo {
   deltaType?: MetricRunInfoDeltaType;
   displayDelta?: string;
   displayDeltaPercentage?: string;
+  regression?: boolean | null;
 }
 
 export type JobSection<T = object> = Record<Source, T>;
@@ -77,6 +112,7 @@ export interface JobInsight<T = object> {
 
 export interface JobInsightAssetsSizeTotalData {
   md: string;
+  text: string;
   info: MetricRunInfo;
 }
 export type JobInsightDuplicatePackagesData = Record<string, Array<string>>;
@@ -160,10 +196,10 @@ export interface BrowsertimeSource {
   info?: {
     browsertime: {
       version: string;
-    }
+    };
     timestamp: string;
     url: string;
-  }
+  };
   statistics?: {
     timings: {
       firstPaint: BrowsertimeSourceMetric;
@@ -179,12 +215,12 @@ export interface BrowsertimeSource {
         redirectionTime: BrowsertimeSourceMetric;
         serverConnectionTime: BrowsertimeSourceMetric;
         serverResponseTime: BrowsertimeSourceMetric;
-      }
+      };
       paintTiming: {
         'first-contentful-paint': BrowsertimeSourceMetric;
-      }
+      };
       rumSpeedIndex: BrowsertimeSourceMetric;
-    }
+    };
     visualmetrics: {
       FirstVisualChange: BrowsertimeSourceMetric;
       LastVisualChange: BrowsertimeSourceMetric;
@@ -193,8 +229,8 @@ export interface BrowsertimeSource {
       VisualComplete85: BrowsertimeSourceMetric;
       VisualComplete95: BrowsertimeSourceMetric;
       VisualComplete99: BrowsertimeSourceMetric;
-    }
-  }
+    };
+  };
 }
 
 export interface BrowsertimeMetrics {

package/src/lighthouse/metrics.js

@@ -1,55 +1,53 @@
-import {
-  METRIC_TYPE_SCORE, METRIC_TYPE_DURATION, METRIC_TYPE_FILE_SIZE, METRIC_TYPE_NUMERIC,
-} from '../config/metrics';
+import { MetricTypes } from '../constants';
 
 export const metrics = {
   score: {
     label: 'Score',
-    type: METRIC_TYPE_SCORE,
+    type: MetricTypes.Score,
   },
   performanceScore: {
     label: 'Performance',
-    type: METRIC_TYPE_SCORE,
+    type: MetricTypes.Score,
   },
   accessibilityScore: {
     label: 'Accessibility',
-    type: METRIC_TYPE_SCORE,
+    type: MetricTypes.Score,
   },
   bestPracticesScore: {
     label: 'Best Practices',
-    type: METRIC_TYPE_SCORE,
+    type: MetricTypes.Score,
   },
   seoScore: {
     label: 'SEO',
-    type: METRIC_TYPE_SCORE,
+    type: MetricTypes.Score,
   },
   pwaScore: {
     label: 'PWA',
-    type: METRIC_TYPE_SCORE,
+    type: MetricTypes.Score,
   },
 
   speedIndex: {
     label: 'Perceptual Speed Index',
-    type: METRIC_TYPE_DURATION,
+    type: MetricTypes.Duration,
   },
   firstMeaningfulPaint: {
     label: 'First Meaningful Paint',
-    type: METRIC_TYPE_DURATION,
+    type: MetricTypes.Duration,
   },
   timeToFirstByte: {
     label: 'Time To First Byte',
-    type: METRIC_TYPE_DURATION,
+    type: MetricTypes.Duration,
   },
   firstInteractive: {
     label: 'First Interactive',
-    type: METRIC_TYPE_DURATION,
+    type: MetricTypes.Duration,
   },
   totalByteWeight: {
     label: 'Total Weight',
-    type: METRIC_TYPE_FILE_SIZE,
+    type: MetricTypes.FileSize,
   },
   domSize: {
     label: 'DOM Size',
-    type: METRIC_TYPE_NUMERIC,
+    type: MetricTypes.Numeric,
   },
 };

package/src/report/add-row-metric-data.ts

@@ -3,6 +3,7 @@ import get from 'lodash/get';
 import { getGlobalMetricType, getMetricRunInfo } from '../utils/metrics';
 import { getMetricChanged } from './get-metric-changed';
 import * as types from './types';
+import { MetricTypes } from '../constants';
 
 /**
  * Add row metric diff data
@@ -15,7 +16,7 @@ export const getAddRowMetricData = (metricType?: string) => (row: types.ReportRo
   // - if the key is not matching an existing metric, use the default metricType
   const metric = getGlobalMetricType(
     key,
-    typeof metricType === 'string' && metricType, // explicit, avoid passing of map cb params
+    typeof metricType === 'string' ? (metricType as MetricTypes) : undefined, // explicit, avoid passing of map cb params
   );
   const { biggerIsBetter, label } = metric;
 
@@ -28,7 +29,7 @@ export const getAddRowMetricData = (metricType?: string) => (row: types.ReportRo
       metric,
       run.value,
       // Get baseline value only if not the latest run
-      (index + 1 < runs.length) ? get(runs, [index + 1, 'value'], 0) : undefined,
+      index + 1 < runs.length ? get(runs, [index + 1, 'value'], 0) : undefined,
     );
 
     return {

package/src/report/create.ts

@@ -44,7 +44,7 @@ export const createReport = (jobs: Array<Job>): Report => {
       return Object.assign(data, { label: metric.label });
     });
 
-    summary[sourceId] = summaryEntries;
+    summary[sourceId] = summaryEntries as any;
   }, {});
 
   const sectionsData = webpack.compare(jobs);

package/src/utils/component-links.ts

@@ -377,13 +377,7 @@ export const METRIC_COMPONENT_LINKS = new Map([
   ['webpack.totalSizeByTypeALL', { link: TOTALS }],
   ['webpack.totalInitialSizeJS', { link: BUNDLE_ASSETS_INITIAL_JS }],
   ['webpack.totalInitialSizeCSS', { link: BUNDLE_ASSETS_INITIAL_CSS }],
-  [
-    'webpack.cacheInvalidation',
-    {
-      link: BUNDLE_ASSETS_CACHE_INVALIDATION,
-      showDelta: false,
-    },
-  ],
+  ['webpack.cacheInvalidation', { link: BUNDLE_ASSETS_CACHE_INVALIDATION }],
   ['webpack.assetCount', { link: BUNDLE_ASSETS_COUNT }],
   ['webpack.chunkCount', { link: BUNDLE_ASSETS_CHUNK_COUNT }],
   ['webpack.moduleCount', { link: BUNDLE_MODULES }],

package/src/utils/delta.ts

@@ -0,0 +1,91 @@
+import round from 'lodash/round';
+
+import type {
+  MetricRun,
+  MetricRunDelta,
+  MetricRunInfoDeltaType,
+  MetricTypeConfig,
+} from '../constants';
+
+export function getDelta(baseline?: MetricRun | null, current?: MetricRun | null): MetricRunDelta {
+  const baselineValue = baseline?.value || 0;
+  const currentValue = current?.value || 0;
+
+  if (baselineValue === currentValue) {
+    return {
+      delta: 0,
+      deltaPercentage: 0,
+    };
+  }
+
+  if (baselineValue === 0) {
+    return {
+      delta: currentValue,
+      deltaPercentage: 100,
+    };
+  }
+
+  return {
+    delta: currentValue - baselineValue,
+    deltaPercentage: round((currentValue / baselineValue) * 100 - 100, 8),
+  };
+}
+
+/**
+ * Format delta output
+ */
+export function formatDelta(value: number, formatter: MetricTypeConfig['formatter']): string {
+  let sign = '';
+
+  if (value > 0) {
+    sign = '+';
+  } else if (value < 0) {
+    sign = '-';
+  }
+
+  let absValue = Math.abs(value);
+
+  if (absValue > 0 && absValue < 0.01) {
+    sign = `~${sign}`;
+    absValue = 0.01;
+  }
+
+  if (absValue > 0.01) {
+    absValue = round(absValue, 2);
+  }
+
+  return `${sign}${formatter(absValue)}`;
+}
+
+/**
+ * Get delta type
+ */
+export function getDeltaType(
+  deltaPercentageValue: number,
+  biggerIsBetter?: MetricTypeConfig['biggerIsBetter'],
+): MetricRunInfoDeltaType {
+  if (deltaPercentageValue < -50) {
+    return biggerIsBetter ? 'HIGH_NEGATIVE' : 'HIGH_POSITIVE';
+  }
+  if (deltaPercentageValue < -5) {
+    return biggerIsBetter ? 'NEGATIVE' : 'POSITIVE';
+  }
+
+  if (deltaPercentageValue < 0) {
+    return biggerIsBetter ? 'LOW_NEGATIVE' : 'LOW_POSITIVE';
+  }
+
+  if (deltaPercentageValue === 0) {
+    return 'NO_CHANGE';
+  }
+
+  if (deltaPercentageValue <= 5) {
+    return biggerIsBetter ? 'LOW_POSITIVE' : 'LOW_NEGATIVE';
+  }
+
+  if (deltaPercentageValue <= 50) {
+    return biggerIsBetter ? 'POSITIVE' : 'NEGATIVE';
+  }
+
+  return biggerIsBetter ? 'HIGH_POSITIVE' : 'HIGH_NEGATIVE';
+}

package/src/utils/metrics.ts

@@ -0,0 +1,81 @@
+import get from 'lodash/get';
+
+import { MetricRunInfo, Metric, MetricTypes, MetricConfig, MetricTypeConfig } from '../constants';
+import { METRIC_TYPE_CONFIGS } from '../config';
+import { metrics as webpackMetricTypes } from '../webpack/metrics';
+import { metrics as lighthouseMetricTypes } from '../lighthouse/metrics';
+import { metrics as browsertimeMeticTypes } from '../browsertime/metrics';
+import { formatPercentage } from './format';
+import { formatDelta, getDelta, getDeltaType } from './delta';
+
+export function createGetMetricType(metrics: Record<string, unknown>) {
+  return function getMetricType(key: string, type?: MetricTypes): Metric {
+    const metric = get(metrics, key) as MetricConfig;
+
+    if (metric?.type) {
+      return {
+        ...METRIC_TYPE_CONFIGS[metric.type],
+        ...metric,
+      };
+    }
+
+    const resolvedType = type || MetricTypes.Numeric;
+
+    return {
+      ...METRIC_TYPE_CONFIGS[resolvedType],
+      type: resolvedType,
+      label: key,
+    };
+  };
+}
+
+export function getGlobalMetricType(key: string, type?: MetricTypes): Metric {
+  const getMetricType = createGetMetricType({
+    webpack: webpackMetricTypes,
+    lighthouse: lighthouseMetricTypes,
+    browsertime: browsertimeMeticTypes,
+  });
+
+  return getMetricType(key, type);
+}
+
+export function getMetricRunInfo(
+  metricType: MetricTypeConfig,
+  current: number,
+  baseline?: number,
+): MetricRunInfo {
+  const { formatter, biggerIsBetter } = metricType;
+
+  const runInfo = {
+    value: current,
+    displayValue: formatter(current),
+  };
+
+  // Skip computing delta fields when the baseline is missing
+  if (typeof baseline === 'undefined') {
+    return runInfo;
+  }
+
+  const { delta, deltaPercentage } = getDelta({ value: baseline }, { value: current });
+
+  // Resolve regression/improvement flag
+  let regression;
+
+  if (biggerIsBetter === null) {
+    regression = null;
+  } else if ((biggerIsBetter === true && delta > 0) || (biggerIsBetter === false && delta < 0)) {
+    regression = false;
+  } else if ((biggerIsBetter === false && delta > 0) || (biggerIsBetter === true && delta < 0)) {
+    regression = true;
+  }
+
+  return {
+    ...runInfo,
+    delta,
+    deltaPercentage,
+    displayDelta: formatDelta(delta, formatter),
+    displayDeltaPercentage: formatDelta(deltaPercentage, formatPercentage),
+    deltaType: getDeltaType(deltaPercentage, biggerIsBetter),
+    regression,
+  };
+}

package/src/webpack/compare.js

@@ -1,4 +1,4 @@
-import { METRIC_TYPE_FILE_SIZE } from '../config/metrics';
+import { MetricTypes } from '../constants';
 import { compareMetrics } from '../report/compare-metrics';
 import {
   SECTION_WEBPACK_STATS,
@@ -18,9 +18,8 @@ import { selectors } from './selectors';
  *
  * @return {Object[]} Compared stats metrics
  */
-const compareStats = (jobs, rowTransformers) => compareMetrics(
-  jobs, selectors.stats, undefined, rowTransformers,
-);
+const compareStats = (jobs, rowTransformers) =>
+  compareMetrics(jobs, selectors.stats, undefined, rowTransformers);
 
 /**
  * Compare size metrics
@@ -30,7 +29,8 @@ const compareStats = (jobs, rowTransformers) => compareMetrics(
  *
  * @return {Object[]} Compared size metrics
  */
-const compareSizes = (jobs, rowTransformers) => compareMetrics(jobs, selectors.sizes, undefined, rowTransformers);
+const compareSizes = (jobs, rowTransformers) =>
+  compareMetrics(jobs, selectors.sizes, undefined, rowTransformers);
 
 /**
  * Compare asset metrics
@@ -40,7 +40,8 @@ const compareSizes = (jobs, rowTransformers) => compareMetrics(jobs, selectors.s
  *
  * @return {Object[]} Compared asset metrics
  */
-const compareAssets = (jobs, rowTransformers) => compareMetrics(jobs, selectors.assets, METRIC_TYPE_FILE_SIZE, rowTransformers);
+const compareAssets = (jobs, rowTransformers) =>
+  compareMetrics(jobs, selectors.assets, MetricTypes.FileSize, rowTransformers);
 
 /**
  * Compare all modules
@@ -49,7 +50,8 @@ const compareAssets = (jobs, rowTransformers) => compareMetrics(jobs, selectors.
  * @param {Array<Function>} [rowTransformers]
  * @return {Object[]} Compared module metrics
  */
-const compareModules = (jobs, rowTransformers) => compareMetrics(jobs, selectors.modules, METRIC_TYPE_FILE_SIZE, rowTransformers);
+const compareModules = (jobs, rowTransformers) =>
+  compareMetrics(jobs, selectors.modules, MetricTypes.FileSize, rowTransformers);
 
 /**
  * Compare package metrics
@@ -59,7 +61,8 @@ const compareModules = (jobs, rowTransformers) => compareMetrics(jobs, selectors
  *
  * @return {Object[]} Compared package metrics
  */
-const comparePackages = (jobs, rowTransformers) => compareMetrics(jobs, selectors.packages, METRIC_TYPE_FILE_SIZE, rowTransformers);
+const comparePackages = (jobs, rowTransformers) =>
+  compareMetrics(jobs, selectors.packages, MetricTypes.FileSize, rowTransformers);
 
 export const compareBySection = {
   [SECTION_WEBPACK_STATS]: compareStats,
@@ -75,7 +78,11 @@ export const compareBySection = {
  * @param {Object[]} jobs - List of jobs to compare
  * @return {Object} Compared metrics by section
  */
-export const compare = (jobs) => SECTIONS.reduce((agg, sectionId) => ({
-  ...agg,
-  [sectionId]: compareBySection[sectionId](jobs),
-}), {});
+export const compare = (jobs) =>
+  SECTIONS.reduce(
+  (agg, sectionId) => ({
+    ...agg,
+    [sectionId]: compareBySection[sectionId](jobs),
+  }),
+  {},
+);

package/src/webpack/{metrics.js → metrics.ts}

@@ -1,115 +1,116 @@
-import {
-  METRIC_TYPE_FILE_SIZE,
-  METRIC_TYPE_NUMERIC,
-  METRIC_TYPE_PERCENTAGE,
-} from '../config/metrics';
 import { FILE_TYPE_LABELS } from '../config/file-types';
 import { Metric } from './types';
+import { MetricTypes, MetricConfig } from '../constants';
 
-export const metrics = {
+type WebpackMetrics = Partial<Record<Metric, MetricConfig>> & {
+  sizes: Partial<Record<Metric, MetricConfig>>;
+};
+
+export const metrics: WebpackMetrics = {
   [Metric.BUNDLE_SIZE]: {
     label: 'Bundle Size',
     description: 'The total file size of the assets generated or processed by the bundler',
     url: 'https://relative-ci.com/documentation/metrics-and-data#assets',
-    type: METRIC_TYPE_FILE_SIZE,
+    type: MetricTypes.FileSize,
   },
   [Metric.INITIAL_SIZE_JS]: {
     label: 'Initial JS',
     description: 'The total file size of the JavaScript initial chunks',
     url: 'https://relative-ci.com/documentation/metrics-and-data#assets',
-    type: METRIC_TYPE_FILE_SIZE,
+    type: MetricTypes.FileSize,
   },
   [Metric.INITIAL_SIZE_CSS]: {
     label: 'Initial CSS',
     description: 'The total file size of the CSS initial chunks',
     url: 'https://relative-ci.com/documentation/metrics-and-data#assets',
-    type: METRIC_TYPE_FILE_SIZE,
+    type: MetricTypes.FileSize,
   },
   [Metric.CACHE_INVALIDATION]: {
     label: 'Cache Invalidation',
     description:
       'The ratio between the total of the changed assets and the total file size(Bundle Size)',
     url: 'https://relative-ci.com/documentation/metrics-and-data#assets',
-    type: METRIC_TYPE_PERCENTAGE,
-    biggerIsBetter: false,
+    type: MetricTypes.Percentage,
+    biggerIsBetter: null,
+    skipDelta: true,
   },
   [Metric.CHUNK_COUNT]: {
     label: 'Chunks',
     description: 'The total number of chunks generated by the bundler',
     url: 'https://relative-ci.com/documentation/metrics-and-data#assets',
-    type: METRIC_TYPE_NUMERIC,
-    biggerIsBetter: false,
+    type: MetricTypes.Numeric,
+    biggerIsBetter: null,
   },
   [Metric.ASSET_COUNT]: {
     label: 'Assets',
     description: 'Total number of assets generated or produced by the bundler',
     url: 'https://relative-ci.com/documentation/metrics-and-data#assets',
-    type: METRIC_TYPE_NUMERIC,
-    biggerIsBetter: false,
+    type: MetricTypes.Numeric,
+    biggerIsBetter: null,
   },
   [Metric.MODULE_COUNT]: {
     label: 'Modules',
     description: 'The total number of bundled modules',
     url: 'https://relative-ci.com/documentation/metrics-and-data#modules-1',
-    type: METRIC_TYPE_NUMERIC,
-    biggerIsBetter: false,
+    type: MetricTypes.Numeric,
+    biggerIsBetter: null,
   },
   [Metric.DUPLICATE_MODULES_COUNT]: {
     label: 'Duplicate Modules',
     description: 'The total number of modules that belong to more than one chunk',
     url: 'https://relative-ci.com/documentation/metrics-and-data#modules-1',
-    type: METRIC_TYPE_NUMERIC,
-    biggerIsBetter: false,
+    type: MetricTypes.Numeric,
+    biggerIsBetter: null,
   },
   [Metric.DUPLICATE_CODE]: {
     label: 'Duplicate Code',
     description: 'The percentage of total duplicate module size from the total module size',
     url: 'https://relative-ci.com/documentation/metrics-and-data#modules-1',
-    type: METRIC_TYPE_PERCENTAGE,
+    type: MetricTypes.Percentage,
     biggerIsBetter: false,
   },
   [Metric.PACKAGE_COUNT]: {
     label: 'Packages',
     description: 'The total number of bundled packages',
     url: 'https://relative-ci.com/documentation/metrics-and-data#packages',
-    type: METRIC_TYPE_NUMERIC,
+    type: MetricTypes.Numeric,
     biggerIsBetter: false,
   },
   [Metric.DUPLICATE_PACKAGES_COUNT]: {
     label: 'Duplicate Packages',
     description: 'The total number of duplicate packages',
     url: 'https://relative-ci.com/documentation/metrics-and-data#packages',
-    type: METRIC_TYPE_NUMERIC,
+    type: MetricTypes.Numeric,
     biggerIsBetter: false,
   },
   sizes: {
     [Metric.TOTAL_SIZE_JS]: {
       label: FILE_TYPE_LABELS.JS,
-      type: METRIC_TYPE_FILE_SIZE,
+      type: MetricTypes.FileSize,
     },
     [Metric.TOTAL_SIZE_CSS]: {
       label: FILE_TYPE_LABELS.CSS,
-      type: METRIC_TYPE_FILE_SIZE,
+      type: MetricTypes.FileSize,
     },
     [Metric.TOTAL_SIZE_IMG]: {
       label: FILE_TYPE_LABELS.IMG,
-      type: METRIC_TYPE_FILE_SIZE,
+      type: MetricTypes.FileSize,
     },
     [Metric.TOTAL_SIZE_MEDIA]: {
       label: FILE_TYPE_LABELS.MEDIA,
-      type: METRIC_TYPE_FILE_SIZE,
+      type: MetricTypes.FileSize,
     },
     [Metric.TOTAL_SIZE_FONT]: {
       label: FILE_TYPE_LABELS.FONT,
-      type: METRIC_TYPE_FILE_SIZE,
+      type: MetricTypes.FileSize,
     },
     [Metric.TOTAL_SIZE_HTML]: {
       label: FILE_TYPE_LABELS.HTML,
-      type: METRIC_TYPE_FILE_SIZE,
+      type: MetricTypes.FileSize,
     },
     [Metric.TOTAL_SIZE_OTHER]: {
       label: FILE_TYPE_LABELS.OTHER,
-      type: METRIC_TYPE_FILE_SIZE,
+      type: MetricTypes.FileSize,
     },
   },
 };