@bundle-stats/utils 3.3.0-beta.1 → 3.4.0-alpha.4

package/types/config/metrics.d.ts

@@ -0,0 +1,35 @@
+export const METRIC_TYPE_FILE_SIZE: "METRIC_TYPE_FILE_SIZE";
+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";

package/types/constants.d.ts

@@ -0,0 +1,165 @@
+export declare enum MetricTypeType {
+    'METRIC_TYPE_NUMERIC' = 0,
+    'METRIC_TYPE_SCORE' = 1,
+    'METRIC_TYPE_FILE_SIZE' = 2,
+    'METRIC_TYPE_DURATION' = 3,
+    'METRIC_TYPE_PERCENTAGE' = 4
+}
+export interface MetricTypeConfig {
+    label: string;
+    description: string;
+    type: MetricTypeType;
+}
+export interface MetricType extends MetricTypeConfig {
+    formatter: Function;
+    biggerIsBetter: boolean;
+}
+export declare enum MetricRunInfoDeltaType {
+    'HIGH_NEGATIVE' = 0,
+    'NEGATIVE' = 1,
+    'LOW_NEGATIVE' = 2,
+    'NO_CHANGE' = 3,
+    'LOW_POSITIVE' = 4,
+    'POSITIVE' = 5,
+    'HIGH_POSITIVE' = 6
+}
+export interface MetricRun {
+    value: number;
+}
+export interface MetricRunInfo {
+    value: number;
+    displayValue: string;
+    delta?: number;
+    displayDelta?: string;
+    displayDeltaPercentage?: string;
+    deltaType?: MetricRunInfoDeltaType;
+}
+export interface Metric {
+    value: number;
+}
+export interface ModuleMetric extends Metric {
+    name: string;
+    chunkIds: Array<String>;
+    duplicated: boolean;
+}
+export interface PackageMetric extends Metric {
+    path: string;
+}
+export interface WebpackMetricsModules {
+    metrics: {
+        duplicateCode: MetricRun;
+        duplicateModulesCount: MetricRun;
+        modules: Record<string, ModuleMetric>;
+    };
+}
+export interface WebpackMetricsPackages {
+    metrics: {
+        packages: Record<string, PackageMetric>;
+    };
+}
+export interface LighthouseSource {
+    lighthouseVersion: string;
+    fetchTime: string;
+    requestedUrl: string;
+    categories: {
+        [key: string]: {
+            score: number;
+        };
+    };
+    audits: {
+        [key: string]: {
+            score: number;
+            numericValue: number;
+        };
+    };
+}
+export interface LighthouseMetricsCategoryScores {
+    performanceScore: MetricRun;
+    accessibilityScore: MetricRun;
+    bestPracticesScore: MetricRun;
+    seoScore: MetricRun;
+    pwaScore: MetricRun;
+}
+export interface LighthouseMetricsScore {
+    score: MetricRun;
+}
+export interface LighthouseMetricsAudits {
+    speedIndex: MetricRun;
+    firstMeaningfulPaint: MetricRun;
+    timeToFirstByte: MetricRun;
+    firstInteractive: MetricRun;
+    totalByteWeight: MetricRun;
+    domSize: MetricRun;
+}
+export interface BrowsertimeSourceMetric {
+    median: number;
+}
+export interface BrowsertimeSource {
+    info?: {
+        browsertime: {
+            version: string;
+        };
+        timestamp: string;
+        url: string;
+    };
+    statistics?: {
+        timings: {
+            firstPaint: BrowsertimeSourceMetric;
+            fullyLoaded: BrowsertimeSourceMetric;
+            pageTimings: {
+                backEndTime: BrowsertimeSourceMetric;
+                domContentLoadedTime: BrowsertimeSourceMetric;
+                domInteractiveTime: BrowsertimeSourceMetric;
+                domainLookupTime: BrowsertimeSourceMetric;
+                frontEndTime: BrowsertimeSourceMetric;
+                pageDownloadTime: BrowsertimeSourceMetric;
+                pageLoadTime: BrowsertimeSourceMetric;
+                redirectionTime: BrowsertimeSourceMetric;
+                serverConnectionTime: BrowsertimeSourceMetric;
+                serverResponseTime: BrowsertimeSourceMetric;
+            };
+            paintTiming: {
+                'first-contentful-paint': BrowsertimeSourceMetric;
+            };
+            rumSpeedIndex: BrowsertimeSourceMetric;
+        };
+        visualmetrics: {
+            FirstVisualChange: BrowsertimeSourceMetric;
+            LastVisualChange: BrowsertimeSourceMetric;
+            PerceptualSpeedIndex: BrowsertimeSourceMetric;
+            SpeedIndex: BrowsertimeSourceMetric;
+            VisualComplete85: BrowsertimeSourceMetric;
+            VisualComplete95: BrowsertimeSourceMetric;
+            VisualComplete99: BrowsertimeSourceMetric;
+        };
+    };
+}
+export interface BrowsertimeMetrics {
+    firstPaint: MetricRun;
+    fullyLoaded: MetricRun;
+    backEndTime: MetricRun;
+    domContentLoadedTime: MetricRun;
+    domInteractiveTime: MetricRun;
+    domainLookupTime: MetricRun;
+    frontEndTime: MetricRun;
+    pageDownloadTime: MetricRun;
+    pageLoadTime: MetricRun;
+    redirectionTime: MetricRun;
+    serverConnectionTime: MetricRun;
+    serverResponseTime: MetricRun;
+    firstContentfulPaint: MetricRun;
+    rumSpeedIndex: MetricRun;
+    firstVisualChange: MetricRun;
+    lastVisualChange: MetricRun;
+    perceptualSpeedIndex: MetricRun;
+    speedIndex: MetricRun;
+    visualComplete85: MetricRun;
+    visualComplete95: MetricRun;
+    visualComplete99: MetricRun;
+}
+export declare enum InsightType {
+    ERROR = "ERROR",
+    WARNING = "WARNING",
+    INFO = "INFO",
+    SUCCESS = "SUCCESS"
+}

package/types/i18n.d.ts

@@ -0,0 +1,16 @@
+declare namespace _default {
+    const COMPONENT_LINK_TOTALS: string;
+    const COMPONENT_LINK_BUNDLE_ASSETS_INITIAL_JS: string;
+    const COMPONENT_LINK_BUNDLE_ASSETS_INITIAL_CSS: string;
+    const COMPONENT_LINK_BUNDLE_ASSETS_CACHE_INVALIDATION: string;
+    const COMPONENT_LINK_BUNDLE_ASSETS_COUNT: string;
+    const COMPONENT_LINK_BUNDLE_ASSETS_CHUNK_COUNT: string;
+    const COMPONENT_LINK_MODULES: string;
+    const COMPONENT_LINK_MODULES_DUPLICATE: string;
+    const COMPONENT_LINK_CHUNK_MODULES: string;
+    const COMPONENT_LINK_PACKAGES_COUNT: string;
+    const COMPONENT_LINK_PACKAGES_DUPLICATE: string;
+    const COMPONENT_LINK_VIEW_PACKAGE: string;
+    const COMPONENT_LINK_BUNDLE_ASSETS_BY_FILE_TYPE: string;
+}
+export default _default;

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./browsertime";
+export * from "./config";
+export * from "./constants";
+export * from "./jobs";
+export * from "./report";
+export * from "./utils";
+export * as transformers from "./transformers";

package/types/jobs/create-job.d.ts

@@ -0,0 +1 @@
+export function createJob(source: any, baseline: any, options?: {}): {};

package/types/jobs/create-jobs.d.ts

@@ -0,0 +1 @@
+export function createJobs(sources: any, options: any): any;

package/types/jobs/create-summary.d.ts

@@ -0,0 +1 @@
+export function createSummary(metricPaths: any, baselineSourceMetrics: any, currentSourceMetrics: any): any;

package/types/jobs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./create-job";
+export * from "./create-jobs";

package/types/lighthouse/compare.d.ts

@@ -0,0 +1 @@
+export function compare(jobs: any): import("../report/types").ReportRow[];

package/types/lighthouse/constants.d.ts

@@ -0,0 +1 @@
+export const SUMMARY_METRIC_PATHS: string[];

package/types/lighthouse/extract/audits.d.ts

@@ -0,0 +1,6 @@
+export function extractAudits(lighthouseSource: any): {
+    metrics: {};
+};
+export type CategoryAuditMetrics = {
+    metrics: any;
+};

package/types/lighthouse/extract/category-scores.d.ts

@@ -0,0 +1,6 @@
+export function extractCategoryScores(lighthouseSource: any): {
+    metrics: {};
+};
+export type CategoryScoresMetrics = {
+    metrics: any;
+};

package/types/lighthouse/extract/index.d.ts

@@ -0,0 +1 @@
+export function extract(webpackStats: any, baseline: any): {};

package/types/lighthouse/extract/score-category-scores.d.ts

@@ -0,0 +1,10 @@
+export function extractScoreCategoryScores(lighthouseSource: any, currentExtractedData?: {}): {
+    metrics: {
+        score: {
+            value: number;
+        };
+    };
+};
+export type CategoryScoresMetrics = {
+    metrics: any;
+};

package/types/lighthouse/filter.d.ts

@@ -0,0 +1 @@
+export function filter(source: Object): any;

package/types/lighthouse/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./compare";
+export * from "./constants";
+export * from "./extract";
+export * from "./filter";
+export * from "./metrics";
+export * from "./selectors";

package/types/lighthouse/metrics.d.ts

@@ -0,0 +1,65 @@
+export namespace metrics {
+    namespace score {
+        export const label: string;
+        export { METRIC_TYPE_SCORE as type };
+    }
+    namespace performanceScore {
+        const label_1: string;
+        export { label_1 as label };
+        export { METRIC_TYPE_SCORE as type };
+    }
+    namespace accessibilityScore {
+        const label_2: string;
+        export { label_2 as label };
+        export { METRIC_TYPE_SCORE as type };
+    }
+    namespace bestPracticesScore {
+        const label_3: string;
+        export { label_3 as label };
+        export { METRIC_TYPE_SCORE as type };
+    }
+    namespace seoScore {
+        const label_4: string;
+        export { label_4 as label };
+        export { METRIC_TYPE_SCORE as type };
+    }
+    namespace pwaScore {
+        const label_5: string;
+        export { label_5 as label };
+        export { METRIC_TYPE_SCORE as type };
+    }
+    namespace speedIndex {
+        const label_6: string;
+        export { label_6 as label };
+        export { METRIC_TYPE_DURATION as type };
+    }
+    namespace firstMeaningfulPaint {
+        const label_7: string;
+        export { label_7 as label };
+        export { METRIC_TYPE_DURATION as type };
+    }
+    namespace timeToFirstByte {
+        const label_8: string;
+        export { label_8 as label };
+        export { METRIC_TYPE_DURATION as type };
+    }
+    namespace firstInteractive {
+        const label_9: string;
+        export { label_9 as label };
+        export { METRIC_TYPE_DURATION as type };
+    }
+    namespace totalByteWeight {
+        const label_10: string;
+        export { label_10 as label };
+        export { METRIC_TYPE_FILE_SIZE as type };
+    }
+    namespace domSize {
+        const label_11: string;
+        export { label_11 as label };
+        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";

package/types/lighthouse/selectors.d.ts

@@ -0,0 +1 @@
+export function selectors(job: any): {};

package/types/polyfills.d.ts

@@ -0,0 +1 @@
+export {};

package/types/report/add-row-metric-data.d.ts

@@ -0,0 +1,8 @@
+import * as types from './types';
+export declare const getAddRowMetricData: (metricType?: string | undefined) => (row: types.ReportRow) => {
+    biggerIsBetter: any;
+    label: any;
+    changed: boolean;
+    runs: any[];
+    key: string;
+};

package/types/report/compare-metrics.d.ts

@@ -0,0 +1,2 @@
+import * as types from './types';
+export declare const compareMetrics: (jobs: Array<any>, selectMetrics: (job: any) => any, metricType: string, rowTransformers?: ((row: types.ReportRow) => types.ReportRow)[] | undefined) => types.ReportRow[];

package/types/report/create.d.ts

@@ -0,0 +1,14 @@
+export declare const createReport: (jobs: Array<any>) => {
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+    insights?: any;
+    createdAt: string;
+    version: string;
+    runs: any[];
+    summary: {};
+};

package/types/report/get-metric-changed.d.ts

@@ -0,0 +1,2 @@
+import * as types from './types';
+export declare const getMetricChanged: (runs: Array<types.MetricValue | null>) => boolean;

package/types/report/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./add-row-metric-data";
+export * from "./compare-metrics";
+export * from "./create";
+export * from "./get-metric-changed";
+export * from "./merge-metrics-by-key";

package/types/report/merge-metrics-by-key.d.ts

@@ -0,0 +1,4 @@
+import * as types from './types';
+declare type RunMetrics = Record<string, types.MetricValue>;
+export declare const mergeMetricsByKey: (runs: Array<RunMetrics>, rowTransformers?: ((row: types.ReportRow) => types.ReportRow)[] | undefined) => Array<types.ReportRow>;
+export {};

package/types/report/types.d.ts

@@ -0,0 +1,8 @@
+export interface MetricValue {
+    value: number;
+    name?: string;
+}
+export interface ReportRow {
+    key: string;
+    runs: Array<MetricValue | null>;
+}

package/types/transformers/budgets-insights.d.ts

@@ -0,0 +1,36 @@
+import { InsightType } from '../constants';
+interface OptionBudgetMetric {
+    metric: string;
+    value: number;
+}
+interface Options {
+    budgets?: Array<OptionBudgetMetric>;
+}
+interface BudgetInsight {
+    currentValue: number;
+    budgetValue: number;
+    failed: boolean;
+}
+interface BudgetInsightInfo {
+    type: InsightType;
+    message: {
+        template: string;
+        data: Record<string, unknown>;
+    };
+    source: {
+        metricId: string;
+        budgetInsight: BudgetInsight;
+    };
+}
+interface BudgetInsights {
+    [metricId: string]: BudgetInsight;
+}
+interface BudgetsInsightsOutput {
+    insights: {
+        budgets: BudgetInsights;
+    };
+}
+export declare const getExtract: (source: string) => (_: unknown, currentExtractedData: any, __: unknown, options?: Options) => BudgetsInsightsOutput | null;
+export declare const INFO_MESSAGE_TEMPLATE = "<%= metricLabel %> value (<%= currentValue %>) is <%= diffLabel %> <%= budgetValue %> budget";
+export declare const getInfo: (globalMetricId: string, budgetInsight: BudgetInsight) => BudgetInsightInfo;
+export {};

package/types/transformers/index.d.ts

@@ -0,0 +1 @@
+export * as budgetInsights from './budgets-insights';

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

@@ -0,0 +1,193 @@
+export function getAssetFileTypeFilters(value?: boolean): {};
+export function getAssetEntryTypeFilters(value?: boolean): {};
+export function getModuleSourceTypeFilters(value?: boolean): {
+    [x: string]: boolean;
+};
+export function getModuleChunkFilters(chunkIds: any, value: any): any;
+export function getModuleFileTypeFilters(value?: boolean): {};
+export namespace TOTALS {
+    const section: string;
+    const title: string;
+}
+export namespace BUNDLE_ASSETS_INITIAL_JS {
+    const section_1: string;
+    export { section_1 as section };
+    const title_1: string;
+    export { title_1 as title };
+    export const params: {
+        [x: string]: {
+            filters: {};
+        };
+    };
+}
+export namespace BUNDLE_ASSETS_INITIAL_CSS {
+    const section_2: string;
+    export { section_2 as section };
+    const title_2: string;
+    export { title_2 as title };
+    const params_1: {
+        [x: string]: {
+            filters: {};
+        };
+    };
+    export { params_1 as params };
+}
+export namespace BUNDLE_ASSETS_CACHE_INVALIDATION {
+    const section_3: string;
+    export { section_3 as section };
+    const title_3: string;
+    export { title_3 as title };
+    const params_2: {
+        [x: string]: {
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+    export { params_2 as params };
+}
+export namespace BUNDLE_ASSETS_COUNT {
+    const section_4: string;
+    export { section_4 as section };
+    const title_4: string;
+    export { title_4 as title };
+    const params_3: {
+        [x: string]: {
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+    export { params_3 as params };
+}
+export namespace BUNDLE_ASSETS_CHUNK_COUNT {
+    const section_5: string;
+    export { section_5 as section };
+    const title_5: string;
+    export { title_5 as title };
+    const params_4: {
+        [x: string]: {
+            filters: {};
+        };
+    };
+    export { params_4 as params };
+}
+export namespace BUNDLE_MODULES {
+    const section_6: string;
+    export { section_6 as section };
+    const title_6: string;
+    export { title_6 as title };
+    const params_5: {
+        [x: string]: {
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+    export { params_5 as params };
+}
+export namespace BUNDLE_MODULES_DUPLICATE {
+    const section_7: string;
+    export { section_7 as section };
+    const title_7: string;
+    export { title_7 as title };
+    const params_6: {
+        [x: string]: {
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+    export { params_6 as params };
+}
+export function getBundleModulesBySearch(search: any): {
+    section: string;
+    title: string;
+    params: {
+        [x: string]: {
+            search: any;
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+};
+export function getBundleModulesByChunk(chunkIds: any, chunkId: any, fileType?: string): {
+    section: string;
+    title: string;
+    params: {
+        [x: string]: {
+            filters: any;
+        };
+    };
+};
+export namespace BUNLDE_PACKAGES_COUNT {
+    const section_8: string;
+    export { section_8 as section };
+    const title_8: string;
+    export { title_8 as title };
+    const params_7: {
+        [x: string]: {
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+    export { params_7 as params };
+}
+export namespace BUNDLE_PACKAGES_DUPLICATE {
+    const section_9: string;
+    export { section_9 as section };
+    const title_9: string;
+    export { title_9 as title };
+    const params_8: {
+        [x: string]: {
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+    export { params_8 as params };
+}
+export function getBundleAssetsFileTypeComponentLink(fileType: any, label: any): {
+    section: string;
+    title: string;
+    params: {
+        [x: string]: {
+            filters: {};
+        };
+    };
+};
+export function getBundlePackagesByNameComponentLink(search: any): {
+    section: string;
+    title: string;
+    params: {
+        [x: string]: {
+            search: any;
+            filters: {
+                [x: string]: boolean;
+            };
+        };
+    };
+};
+export function getComponentStateQueryString(params?: {}): string;
+export const METRIC_COMPONENT_LINKS: Map<string, {
+    link: {
+        section: string;
+        title: string;
+    };
+    showDelta?: undefined;
+} | {
+    link: {
+        section: string;
+        title: string;
+        params: {
+            [x: string]: {
+                filters: {
+                    [x: string]: boolean;
+                };
+            };
+        };
+    };
+    showDelta: boolean;
+}>;

package/types/utils/date.d.ts

@@ -0,0 +1,2 @@
+export function formatDate(value: any): string;
+export function formatTime(value: any): string;

package/types/utils/delta.d.ts

@@ -0,0 +1,6 @@
+export function getDelta(baseline: any, current: any): {
+    delta: any;
+    deltaPercentage: number;
+};
+export function formatDelta(value: number, formatter: Function): string;
+export function getDeltaType(deltaValue: number, biggerIsBetter: boolean): string;

package/types/utils/file-types.d.ts

@@ -0,0 +1,4 @@
+export function getFilenameFileType(filename: string, patterns: Object): string;
+export function getFileType(filename: any): string;
+export function getModuleSourceFileType(moduleSourceFilename: string): string;
+export function getModuleFileType(moduleFilename: string): string;

package/types/utils/format.d.ts

@@ -0,0 +1,5 @@
+export function formatFileSize(val: any): string;
+export function formatDuration(val: any): string;
+export function formatNumber(val: any): string;
+export function formatCommit(commitSha: any): any;
+export function formatPercentage(val: any): string;