lighthouse 9.5.0-dev.20230117 → 9.5.0-dev.20230119

package/flow-report/test/sample-flow.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export declare const flowResult: LH.FlowResult;
+//# sourceMappingURL=sample-flow.d.ts.map

package/flow-report/test/setup/env-setup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+declare const rootHooks: {
+    beforeAll(): void;
+    beforeEach(): void;
+};
+export { rootHooks, };
+//# sourceMappingURL=env-setup.d.ts.map

package/flow-report/test/sidebar/flow-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=flow-test.d.ts.map

package/flow-report/test/sidebar/sidebar-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=sidebar-test.d.ts.map

package/flow-report/test/summary/category-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=category-test.d.ts.map

package/flow-report/test/summary/summary-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=summary-test.d.ts.map

package/flow-report/test/topbar-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=topbar-test.d.ts.map

package/flow-report/test/util-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=util-test.d.ts.map

package/flow-report/test/wrappers/category-score-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=category-score-test.d.ts.map

package/flow-report/test/wrappers/markdown-test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export {};
+//# sourceMappingURL=markdown-test.d.ts.map

package/flow-report/tsconfig.json

@@ -19,7 +19,7 @@
     "**/*.ts",
     "**/*.tsx",
     "./types",
-    "../types/test.d.ts",
+    "../types/internal/test.d.ts",
     "../root.js",
     "../esm-utils.js",
     "../core/test/test-env/fake-timers.js",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "9.5.0-dev.20230117",
+  "version": "9.5.0-dev.20230119",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -13,7 +13,8 @@
     "node": ">=16.16"
   },
   "scripts": {
-    "prepack": "yarn build-report --standalone --flow --esm",
+    "prepack": "yarn build-report --standalone --flow --esm && yarn build-types",
+    "postpack": "yarn clean-types",
     "build-all": "npm-run-posix-or-windows build-all:task",
     "build-all:task": "yarn build-report && yarn build-cdt-lib && yarn build-devtools && concurrently 'yarn build-extension' 'yarn build-lr' 'yarn build-viewer' 'yarn build-treemap' 'yarn build-smokehouse-bundle' && yarn build-pack",
     "build-all:task:windows": "yarn build-report && yarn build-cdt-lib && yarn build-extension && yarn build-devtools && yarn build-lr && yarn build-viewer && yarn build-treemap && yarn build-smokehouse-bundle",
@@ -29,9 +30,11 @@
     "build-sample-reports": "yarn build-report && node build/build-sample-reports.js",
     "build-treemap": "node ./build/build-treemap.js",
     "build-viewer": "node ./build/build-viewer.js",
+    "build-types": "yarn type-check && rsync -a .tmp/tsbuildinfo/ ./ --include='*.d.ts' --include='*.d.cts' --exclude='*.map' --exclude='*.tsbuildinfo'",
     "reset-link": "(yarn unlink || true) && yarn link && yarn link lighthouse",
     "c8": "bash core/scripts/c8.sh",
     "clean": "rm -r dist proto/scripts/*.json proto/scripts/*_pb2.* proto/scripts/*_pb.* proto/scripts/__pycache__ proto/scripts/*.pyc *.report.html *.report.dom.html *.report.json *.devtoolslog.json *.trace.json shared/localization/locales/*.ctc.json || true",
+    "clean-types": "git clean -xfq '*.d.ts' '*.d.cts' -e 'node_modules/' -e 'dist/' -e '.tmp/' -e '**/types/'",
     "lint": "[ \"$CI\" = true ] && eslint --quiet -f codeframe . || eslint .",
     "smoke": "node cli/test/smokehouse/frontends/smokehouse-bin.js",
     "debug": "node --inspect-brk ./cli/index.js",

package/report/clients/bundle.d.ts

@@ -0,0 +1,6 @@
+export { DOM } from "../renderer/dom.js";
+export { ReportRenderer } from "../renderer/report-renderer.js";
+export { ReportUIFeatures } from "../renderer/report-ui-features.js";
+export { renderReport } from "../renderer/api.js";
+export { swapLocale, format } from "../../shared/localization/i18n-module.js";
+//# sourceMappingURL=bundle.d.ts.map

package/report/clients/standalone.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=standalone.d.ts.map

package/report/generator/file-namer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generate a filenamePrefix of hostname_YYYY-MM-DD_HH-MM-SS.
+ * @param {{finalDisplayedUrl: string, fetchTime: string}} lhr
+ * @return {string}
+ */
+export function getLhrFilenamePrefix(lhr: {
+    finalDisplayedUrl: string;
+    fetchTime: string;
+}): string;
+/**
+ * @fileoverview
+ * @suppress {reportUnknownTypes}
+ */
+/**
+ * Generate a filenamePrefix of name_YYYY-MM-DD_HH-MM-SS
+ * Date/time uses the local timezone, however Node has unreliable ICU
+ * support, so we must construct a YYYY-MM-DD date format manually. :/
+ * @param {string} name
+ * @param {string|undefined} fetchTime
+ */
+export function getFilenamePrefix(name: string, fetchTime: string | undefined): string;
+/**
+ * Generate a filenamePrefix of name_YYYY-MM-DD_HH-MM-SS.
+ * @param {{name: string, steps: Array<{lhr: {fetchTime: string}}>}} flowResult
+ * @return {string}
+ */
+export function getFlowResultFilenamePrefix(flowResult: {
+    name: string;
+    steps: {
+        lhr: {
+            fetchTime: string;
+        };
+    }[];
+}): string;
+//# sourceMappingURL=file-namer.d.ts.map

package/report/generator/flow-report-assets.d.ts

@@ -0,0 +1,9 @@
+export namespace flowReportAssets {
+    export { FLOW_REPORT_TEMPLATE };
+    export const FLOW_REPORT_CSS: string;
+    export { FLOW_REPORT_JAVASCRIPT };
+}
+declare const FLOW_REPORT_TEMPLATE: string;
+declare const FLOW_REPORT_JAVASCRIPT: string;
+export {};
+//# sourceMappingURL=flow-report-assets.d.ts.map

package/report/generator/report-assets.d.ts

@@ -0,0 +1,8 @@
+export const reportAssets: {
+    FLOW_REPORT_TEMPLATE: string;
+    FLOW_REPORT_CSS: string;
+    FLOW_REPORT_JAVASCRIPT: string;
+    REPORT_TEMPLATE: string;
+    REPORT_JAVASCRIPT: string;
+};
+//# sourceMappingURL=report-assets.d.ts.map

package/report/generator/report-generator.d.ts

@@ -0,0 +1,59 @@
+export type LHResult = import('../../types/lhr/lhr').default;
+export type FlowResult = import('../../types/lhr/flow-result').default;
+/** @typedef {import('../../types/lhr/lhr').default} LHResult */
+/** @typedef {import('../../types/lhr/flow-result').default} FlowResult */
+export class ReportGenerator {
+    /**
+     * Replaces all the specified strings in source without serial replacements.
+     * @param {string} source
+     * @param {!Array<{search: string, replacement: string}>} replacements
+     * @return {string}
+     */
+    static replaceStrings(source: string, replacements: Array<{
+        search: string;
+        replacement: string;
+    }>): string;
+    /**
+     * @param {unknown} object
+     * @return {string}
+     */
+    static sanitizeJson(object: unknown): string;
+    /**
+     * Returns the standalone report HTML as a string with the report JSON and renderer JS inlined.
+     * @param {LHResult} lhr
+     * @return {string}
+     */
+    static generateReportHtml(lhr: LHResult): string;
+    /**
+     * Returns the standalone flow report HTML as a string with the report JSON and renderer JS inlined.
+     * @param {FlowResult} flow
+     * @return {string}
+     */
+    static generateFlowReportHtml(flow: FlowResult): string;
+    /**
+     * Converts the results to a CSV formatted string
+     * Each row describes the result of 1 audit with
+     *  - the name of the category the audit belongs to
+     *  - the name of the audit
+     *  - a description of the audit
+     *  - the score type that is used for the audit
+     *  - the score value of the audit
+     *
+     * @param {LHResult} lhr
+     * @return {string}
+     */
+    static generateReportCSV(lhr: LHResult): string;
+    /**
+     * @param {LHResult|FlowResult} result
+     * @return {result is FlowResult}
+     */
+    static isFlowResult(result: LHResult | FlowResult): result is import("../../types/lhr/flow-result").default;
+    /**
+     * Creates the results output in a format based on the `mode`.
+     * @param {LHResult|FlowResult} result
+     * @param {LHResult['configSettings']['output']} outputModes
+     * @return {string|string[]}
+     */
+    static generateReport(result: LHResult | FlowResult, outputModes: LHResult['configSettings']['output']): string | string[];
+}
+//# sourceMappingURL=report-generator.d.ts.map

package/report/renderer/api.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {LH.Result} lhr
+ * @param {LH.Renderer.Options} opts
+ * @return {HTMLElement}
+ */
+export function renderReport(lhr: LH.Result, opts?: LH.Renderer.Options): HTMLElement;
+/**
+ * @param {LH.ReportResult.Category} category
+ * @param {Parameters<CategoryRenderer['renderCategoryScore']>[2]=} options
+ * @return {DocumentFragment}
+ */
+export function renderCategoryScore(category: LH.ReportResult.Category, options?: [category: import("../types/report-result.js").default.Category, groupDefinitions: Record<string, import("../../types/lhr/lhr.js").default.ReportGroup>, options?: {
+    gatherMode: import("../../types/lhr/lhr.js").default.GatherMode;
+    omitLabel?: boolean | undefined;
+    onPageAnchorRendered?: ((link: HTMLAnchorElement) => void) | undefined;
+} | undefined][2] | undefined): DocumentFragment;
+/**
+ * @param {Blob} blob
+ * @param {string} filename
+ */
+export function saveFile(blob: Blob, filename: string): void;
+/**
+ * @param {string} markdownText
+ * @return {Element}
+ */
+export function convertMarkdownCodeSnippets(markdownText: string): Element;
+/**
+ * @return {DocumentFragment}
+ */
+export function createStylesElement(): DocumentFragment;
+//# sourceMappingURL=api.d.ts.map

package/report/renderer/category-renderer.d.ts

@@ -0,0 +1,176 @@
+export class CategoryRenderer {
+    /**
+     * @param {DOM} dom
+     * @param {DetailsRenderer} detailsRenderer
+     */
+    constructor(dom: DOM, detailsRenderer: DetailsRenderer);
+    /** @type {DOM} */
+    dom: DOM;
+    /** @type {DetailsRenderer} */
+    detailsRenderer: DetailsRenderer;
+    /**
+     * Display info per top-level clump. Define on class to avoid race with Util init.
+     */
+    get _clumpTitles(): {
+        warning: string;
+        manual: string;
+        passed: string;
+        notApplicable: string;
+    };
+    /**
+     * @param {LH.ReportResult.AuditRef} audit
+     * @return {Element}
+     */
+    renderAudit(audit: LH.ReportResult.AuditRef): Element;
+    /**
+     * Populate an DOM tree with audit details. Used by renderAudit and renderOpportunity
+     * @param {LH.ReportResult.AuditRef} audit
+     * @param {DocumentFragment} component
+     * @return {!Element}
+     */
+    populateAuditValues(audit: LH.ReportResult.AuditRef, component: DocumentFragment): Element;
+    /**
+     * Inject the final screenshot next to the score gauge of the first category (likely Performance)
+     * @param {HTMLElement} categoriesEl
+     * @param {LH.ReportResult['audits']} audits
+     * @param {Element} scoreScaleEl
+     */
+    injectFinalScreenshot(categoriesEl: HTMLElement, audits: LH.ReportResult['audits'], scoreScaleEl: Element): null | undefined;
+    /**
+     * @return {Element}
+     */
+    _createChevron(): Element;
+    /**
+     * @param {Element} element DOM node to populate with values.
+     * @param {number|null} score
+     * @param {string} scoreDisplayMode
+     * @return {!Element}
+     */
+    _setRatingClass(element: Element, score: number | null, scoreDisplayMode: string): Element;
+    /**
+     * @param {LH.ReportResult.Category} category
+     * @param {Record<string, LH.Result.ReportGroup>} groupDefinitions
+     * @param {{gatherMode: LH.Result.GatherMode}=} options
+     * @return {DocumentFragment}
+     */
+    renderCategoryHeader(category: LH.ReportResult.Category, groupDefinitions: Record<string, LH.Result.ReportGroup>, options?: {
+        gatherMode: LH.Result.GatherMode;
+    } | undefined): DocumentFragment;
+    /**
+     * Renders the group container for a group of audits. Individual audit elements can be added
+     * directly to the returned element.
+     * @param {LH.Result.ReportGroup} group
+     * @return {[Element, Element | null]}
+     */
+    renderAuditGroup(group: LH.Result.ReportGroup): [Element, Element | null];
+    /**
+     * Takes an array of auditRefs, groups them if requested, then returns an
+     * array of audit and audit-group elements.
+     * @param {Array<LH.ReportResult.AuditRef>} auditRefs
+     * @param {Object<string, LH.Result.ReportGroup>} groupDefinitions
+     * @return {Array<Element>}
+     */
+    _renderGroupedAudits(auditRefs: Array<LH.ReportResult.AuditRef>, groupDefinitions: {
+        [x: string]: LH.Result.ReportGroup;
+    }): Array<Element>;
+    /**
+     * Take a set of audits, group them if they have groups, then render in a top-level
+     * clump that can't be expanded/collapsed.
+     * @param {Array<LH.ReportResult.AuditRef>} auditRefs
+     * @param {Object<string, LH.Result.ReportGroup>} groupDefinitions
+     * @return {Element}
+     */
+    renderUnexpandableClump(auditRefs: Array<LH.ReportResult.AuditRef>, groupDefinitions: {
+        [x: string]: LH.Result.ReportGroup;
+    }): Element;
+    /**
+     * Take a set of audits and render in a top-level, expandable clump that starts
+     * in a collapsed state.
+     * @param {Exclude<TopLevelClumpId, 'failed'>} clumpId
+     * @param {{auditRefs: Array<LH.ReportResult.AuditRef>, description?: string}} clumpOpts
+     * @return {!Element}
+     */
+    renderClump(clumpId: Exclude<TopLevelClumpId, 'failed'>, { auditRefs, description }: {
+        auditRefs: Array<LH.ReportResult.AuditRef>;
+        description?: string;
+    }): Element;
+    /**
+     * @param {LH.ReportResult.Category} category
+     * @param {Record<string, LH.Result.ReportGroup>} groupDefinitions
+     * @param {{gatherMode: LH.Result.GatherMode, omitLabel?: boolean, onPageAnchorRendered?: (link: HTMLAnchorElement) => void}=} options
+     * @return {DocumentFragment}
+     */
+    renderCategoryScore(category: LH.ReportResult.Category, groupDefinitions: Record<string, LH.Result.ReportGroup>, options?: {
+        gatherMode: LH.Result.GatherMode;
+        omitLabel?: boolean | undefined;
+        onPageAnchorRendered?: ((link: HTMLAnchorElement) => void) | undefined;
+    } | undefined): DocumentFragment;
+    /**
+     * @param {LH.ReportResult.Category} category
+     * @param {Record<string, LH.Result.ReportGroup>} groupDefinitions
+     * @return {DocumentFragment}
+     */
+    renderScoreGauge(category: LH.ReportResult.Category, groupDefinitions: Record<string, LH.Result.ReportGroup>): DocumentFragment;
+    /**
+     * @param {LH.ReportResult.Category} category
+     * @return {DocumentFragment}
+     */
+    renderCategoryFraction(category: LH.ReportResult.Category): DocumentFragment;
+    /**
+     * Returns true if an LH category has any non-"notApplicable" audits.
+     * @param {LH.ReportResult.Category} category
+     * @return {boolean}
+     */
+    hasApplicableAudits(category: LH.ReportResult.Category): boolean;
+    /**
+     * Define the score arc of the gauge
+     * Credit to xgad for the original technique: https://codepen.io/xgad/post/svg-radial-progress-meters
+     * @param {SVGCircleElement} arcElem
+     * @param {number} percent
+     */
+    _setGaugeArc(arcElem: SVGCircleElement, percent: number): void;
+    /**
+     * @param {LH.ReportResult.AuditRef} audit
+     * @return {boolean}
+     */
+    _auditHasWarning(audit: LH.ReportResult.AuditRef): boolean;
+    /**
+     * Returns the id of the top-level clump to put this audit in.
+     * @param {LH.ReportResult.AuditRef} auditRef
+     * @return {TopLevelClumpId}
+     */
+    _getClumpIdForAuditRef(auditRef: LH.ReportResult.AuditRef): TopLevelClumpId;
+    /**
+     * Renders a set of top level sections (clumps), under a status of failed, warning,
+     * manual, passed, or notApplicable. The result ends up something like:
+     *
+     * failed clump
+     *   ├── audit 1 (w/o group)
+     *   ├── audit 2 (w/o group)
+     *   ├── audit group
+     *   |  ├── audit 3
+     *   |  └── audit 4
+     *   └── audit group
+     *      ├── audit 5
+     *      └── audit 6
+     * other clump (e.g. 'manual')
+     *   ├── audit 1
+     *   ├── audit 2
+     *   ├── …
+     *   ⋮
+     * @param {LH.ReportResult.Category} category
+     * @param {Object<string, LH.Result.ReportGroup>=} groupDefinitions
+     * @param {{gatherMode: LH.Result.GatherMode}=} options
+     * @return {Element}
+     */
+    render(category: LH.ReportResult.Category, groupDefinitions?: {
+        [x: string]: LH.Result.ReportGroup;
+    } | undefined, options?: {
+        gatherMode: LH.Result.GatherMode;
+    } | undefined): Element;
+}
+export type DOM = import('./dom.js').DOM;
+export type ReportRenderer = import('./report-renderer.js').ReportRenderer;
+export type DetailsRenderer = import('./details-renderer.js').DetailsRenderer;
+export type TopLevelClumpId = 'failed' | 'warning' | 'manual' | 'passed' | 'notApplicable';
+//# sourceMappingURL=category-renderer.d.ts.map

package/report/renderer/components.d.ts

@@ -0,0 +1,10 @@
+/** @typedef {'3pFilter'|'audit'|'categoryHeader'|'chevron'|'clump'|'crc'|'crcChain'|'elementScreenshot'|'footer'|'fraction'|'gauge'|'gaugePwa'|'heading'|'metric'|'opportunity'|'opportunityHeader'|'scorescale'|'scoresWrapper'|'snippet'|'snippetContent'|'snippetHeader'|'snippetLine'|'styles'|'topbar'|'warningsToplevel'} ComponentName */
+/**
+ * @param {DOM} dom
+ * @param {ComponentName} componentName
+ * @return {DocumentFragment}
+ */
+export function createComponent(dom: DOM, componentName: ComponentName): DocumentFragment;
+export type DOM = import('./dom.js').DOM;
+export type ComponentName = '3pFilter' | 'audit' | 'categoryHeader' | 'chevron' | 'clump' | 'crc' | 'crcChain' | 'elementScreenshot' | 'footer' | 'fraction' | 'gauge' | 'gaugePwa' | 'heading' | 'metric' | 'opportunity' | 'opportunityHeader' | 'scorescale' | 'scoresWrapper' | 'snippet' | 'snippetContent' | 'snippetHeader' | 'snippetLine' | 'styles' | 'topbar' | 'warningsToplevel';
+//# sourceMappingURL=components.d.ts.map

package/report/renderer/crc-details-renderer.d.ts

@@ -0,0 +1,73 @@
+export type DOM = import('./dom.js').DOM;
+export type DetailsRenderer = import('./details-renderer.js').DetailsRenderer;
+export type CRCSegment = {
+    node: LH.Audit.Details.SimpleCriticalRequestNode[string];
+    isLastChild: boolean;
+    hasChildren: boolean;
+    startTime: number;
+    transferSize: number;
+    treeMarkers: boolean[];
+};
+/** @typedef {import('./dom.js').DOM} DOM */
+/** @typedef {import('./details-renderer.js').DetailsRenderer} DetailsRenderer */
+/**
+ * @typedef CRCSegment
+ * @property {LH.Audit.Details.SimpleCriticalRequestNode[string]} node
+ * @property {boolean} isLastChild
+ * @property {boolean} hasChildren
+ * @property {number} startTime
+ * @property {number} transferSize
+ * @property {boolean[]} treeMarkers
+ */
+export class CriticalRequestChainRenderer {
+    /**
+     * Create render context for critical-request-chain tree display.
+     * @param {LH.Audit.Details.SimpleCriticalRequestNode} tree
+     * @return {{tree: LH.Audit.Details.SimpleCriticalRequestNode, startTime: number, transferSize: number}}
+     */
+    static initTree(tree: LH.Audit.Details.SimpleCriticalRequestNode): {
+        tree: LH.Audit.Details.SimpleCriticalRequestNode;
+        startTime: number;
+        transferSize: number;
+    };
+    /**
+     * Helper to create context for each critical-request-chain node based on its
+     * parent. Calculates if this node is the last child, whether it has any
+     * children itself and what the tree looks like all the way back up to the root,
+     * so the tree markers can be drawn correctly.
+     * @param {LH.Audit.Details.SimpleCriticalRequestNode} parent
+     * @param {string} id
+     * @param {number} startTime
+     * @param {number} transferSize
+     * @param {Array<boolean>=} treeMarkers
+     * @param {boolean=} parentIsLastChild
+     * @return {CRCSegment}
+     */
+    static createSegment(parent: LH.Audit.Details.SimpleCriticalRequestNode, id: string, startTime: number, transferSize: number, treeMarkers?: Array<boolean> | undefined, parentIsLastChild?: boolean | undefined): CRCSegment;
+    /**
+     * Creates the DOM for a tree segment.
+     * @param {DOM} dom
+     * @param {CRCSegment} segment
+     * @param {DetailsRenderer} detailsRenderer
+     * @return {Node}
+     */
+    static createChainNode(dom: DOM, segment: CRCSegment, detailsRenderer: DetailsRenderer): Node;
+    /**
+     * Recursively builds a tree from segments.
+     * @param {DOM} dom
+     * @param {DocumentFragment} tmpl
+     * @param {CRCSegment} segment
+     * @param {Element} elem Parent element.
+     * @param {LH.Audit.Details.CriticalRequestChain} details
+     * @param {DetailsRenderer} detailsRenderer
+     */
+    static buildTree(dom: DOM, tmpl: DocumentFragment, segment: CRCSegment, elem: Element, details: LH.Audit.Details.CriticalRequestChain, detailsRenderer: DetailsRenderer): void;
+    /**
+     * @param {DOM} dom
+     * @param {LH.Audit.Details.CriticalRequestChain} details
+     * @param {DetailsRenderer} detailsRenderer
+     * @return {Element}
+     */
+    static render(dom: DOM, details: LH.Audit.Details.CriticalRequestChain, detailsRenderer: DetailsRenderer): Element;
+}
+//# sourceMappingURL=crc-details-renderer.d.ts.map