lighthouse 9.6.7 → 10.0.0

package/core/audits/lcp-lazy-loaded.js

@@ -0,0 +1,84 @@
+/**
+ * @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.
+ */
+
+import {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on whether the largest above-the-fold image was loaded with sufficient priority. This descriptive title is shown to users when the image was loaded properly. */
+  title: 'Largest Contentful Paint image was not lazily loaded',
+  /** Title of a Lighthouse audit that provides detail on whether the largest above-the-fold image was loaded with sufficient priority. This descriptive title is shown to users when the image was loaded inefficiently using the `loading=lazy` attribute. */
+  failureTitle: 'Largest Contentful Paint image was lazily loaded',
+  /** Description of a Lighthouse audit that tells the user why the advice is important. This is displayed after a user expands the section to see more. No character length limits. */
+  description: 'Above-the-fold images that are lazily loaded render later in the page lifecycle, which can delay the largest contentful paint. [Learn more about optimal lazy loading](https://web.dev/lcp-lazy-loading/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class LargestContentfulPaintLazyLoaded extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'lcp-lazy-loaded',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['TraceElements', 'ViewportDimensions', 'ImageElements'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts.ImageElement} image
+   * @param {LH.Artifacts.ViewportDimensions} viewportDimensions
+   * @return {boolean}
+   */
+  static isImageInViewport(image, viewportDimensions) {
+    const imageTop = image.clientRect.top;
+    const viewportHeight = viewportDimensions.innerHeight;
+    return imageTop < viewportHeight;
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    const lcpElement = artifacts.TraceElements.find(element => {
+      return element.traceEventType === 'largest-contentful-paint' && element.type === 'image';
+    });
+    const lcpElementImage = lcpElement ? artifacts.ImageElements.find(elem => {
+      return elem.node.devtoolsNodePath === lcpElement.node.devtoolsNodePath;
+    }) : undefined;
+
+
+    if (!lcpElementImage ||
+      !this.isImageInViewport(lcpElementImage, artifacts.ViewportDimensions)) {
+      return {score: null, notApplicable: true};
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'node', valueType: 'node', label: str_(i18n.UIStrings.columnElement)},
+    ];
+
+    const details = Audit.makeTableDetails(headings, [
+      {
+        node: Audit.makeNodeItem(lcpElementImage.node),
+      },
+    ]);
+
+    return {
+      score: lcpElementImage.loading === 'lazy' ? 0 : 1,
+      details,
+    };
+  }
+}
+
+export default LargestContentfulPaintLazyLoaded;
+export {UIStrings};

package/core/audits/long-tasks.d.ts

@@ -0,0 +1,16 @@
+export default LongTasks;
+declare class LongTasks extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+    const displayValue: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=long-tasks.d.ts.map

package/core/audits/long-tasks.js

@@ -0,0 +1,124 @@
+/**
+ * @license Copyright 2020 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.
+ */
+
+import {Audit} from './audit.js';
+import {NetworkRecords} from '../computed/network-records.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {MainThreadTasks} from '../computed/main-thread-tasks.js';
+import {PageDependencyGraph} from '../computed/page-dependency-graph.js';
+import {LoadSimulator} from '../computed/load-simulator.js';
+import {getJavaScriptURLs, getAttributableURLForTask} from '../lib/tracehouse/task-summary.js';
+
+/** We don't always have timing data for short tasks, if we're missing timing data. Treat it as though it were 0ms. */
+const DEFAULT_TIMING = {startTime: 0, endTime: 0, duration: 0};
+
+const UIStrings = {
+  /** Title of a diagnostic LH audit that provides details on the longest running tasks that occur when the page loads. */
+  title: 'Avoid long main-thread tasks',
+  /** Description of a diagnostic LH audit that shows the user the longest running tasks that occur when the page loads. */
+  description: 'Lists the longest tasks on the main thread, ' +
+    'useful for identifying worst contributors to input delay. ' +
+    '[Learn how to avoid long main-thread tasks](https://web.dev/long-tasks-devtools/)',
+  /** [ICU Syntax] Label identifying the number of long-running CPU tasks that occurred while loading a web page. */
+  displayValue: `{itemCount, plural,
+  =1 {# long task found}
+  other {# long tasks found}
+  }`,
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class LongTasks extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'long-tasks',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'URL'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const settings = context.settings || {};
+    const URL = artifacts.URL;
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const tasks = await MainThreadTasks.request(trace, context);
+    const devtoolsLog = artifacts.devtoolsLogs[LongTasks.DEFAULT_PASS];
+    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
+
+    /** @type {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>} */
+    const taskTimingsByEvent = new Map();
+
+    if (settings.throttlingMethod === 'simulate') {
+      const simulatorOptions = {devtoolsLog, settings: context.settings};
+      const pageGraph = await PageDependencyGraph.request({trace, devtoolsLog, URL}, context);
+      const simulator = await LoadSimulator.request(simulatorOptions, context);
+      const simulation = await simulator.simulate(pageGraph, {label: 'long-tasks-diagnostic'});
+      for (const [node, timing] of simulation.nodeTimings.entries()) {
+        if (node.type !== 'cpu') continue;
+        taskTimingsByEvent.set(node.event, timing);
+      }
+    } else {
+      for (const task of tasks) {
+        if (task.unbounded || task.parent) continue;
+        taskTimingsByEvent.set(task.event, task);
+      }
+    }
+
+    const jsURLs = getJavaScriptURLs(networkRecords);
+    // Only consider up to 20 long, top-level (no parent) tasks that have an explicit endTime
+    const longtasks = tasks
+      .map(t => {
+        const timing = taskTimingsByEvent.get(t.event) || DEFAULT_TIMING;
+        return {...t, duration: timing.duration, startTime: timing.startTime};
+      })
+      .filter(t => t.duration >= 50 && !t.unbounded && !t.parent)
+      .sort((a, b) => b.duration - a.duration)
+      .slice(0, 20);
+
+    // TODO(beytoven): Add start time that matches with the simulated throttling
+    const results = longtasks.map(task => ({
+      url: getAttributableURLForTask(task, jsURLs),
+      duration: task.duration,
+      startTime: task.startTime,
+    }));
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
+      {key: 'startTime', valueType: 'ms', granularity: 1, label: str_(i18n.UIStrings.columnStartTime)},
+      {key: 'duration', valueType: 'ms', granularity: 1, label: str_(i18n.UIStrings.columnDuration)},
+      /* eslint-enable max-len */
+    ];
+
+    const tableDetails = Audit.makeTableDetails(headings, results);
+
+    let displayValue;
+    if (results.length > 0) {
+      displayValue = str_(UIStrings.displayValue, {itemCount: results.length});
+    }
+
+    return {
+      score: results.length === 0 ? 1 : 0,
+      notApplicable: results.length === 0,
+      details: tableDetails,
+      displayValue,
+    };
+  }
+}
+
+export default LongTasks;
+export {UIStrings};

package/core/audits/main-thread-tasks.d.ts

@@ -0,0 +1,11 @@
+export default MainThreadTasks;
+declare class MainThreadTasks extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=main-thread-tasks.d.ts.map

package/core/audits/main-thread-tasks.js

@@ -0,0 +1,58 @@
+/**
+ * @license Copyright 2019 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.
+ */
+
+import {Audit} from './audit.js';
+import {MainThreadTasks as MainThreadTasksComputed} from '../computed/main-thread-tasks.js';
+
+class MainThreadTasks extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'main-thread-tasks',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: 'Tasks',
+      description: 'Lists the toplevel main thread tasks that executed during page load.',
+      requiredArtifacts: ['traces'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const tasks = await MainThreadTasksComputed.request(trace, context);
+
+    const results = tasks
+      // Filter to just the sizable toplevel tasks; toplevel tasks are tasks without a parent.
+      .filter(task => task.duration > 5 && !task.parent)
+      .map(task => {
+        return {
+          duration: task.duration,
+          startTime: task.startTime,
+        };
+      });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'startTime', valueType: 'ms', granularity: 1, label: 'Start Time'},
+      {key: 'duration', valueType: 'ms', granularity: 1, label: 'End Time'},
+    ];
+
+    const tableDetails = Audit.makeTableDetails(headings, results);
+
+    return {
+      score: 1,
+      details: tableDetails,
+    };
+  }
+}
+
+export default MainThreadTasks;

package/core/audits/mainthread-work-breakdown.d.ts

@@ -0,0 +1,28 @@
+export default MainThreadWorkBreakdown;
+export type TaskGroupIds = import('../lib/tracehouse/task-groups.js').TaskGroupIds;
+/** @typedef {import('../lib/tracehouse/task-groups.js').TaskGroupIds} TaskGroupIds */
+declare class MainThreadWorkBreakdown extends Audit {
+    /**
+     * @return {LH.Audit.ScoreOptions}
+     */
+    static get defaultOptions(): import("../../types/audit.js").default.ScoreOptions;
+    /**
+     * @param {LH.Artifacts.TaskNode[]} tasks
+     * @return {Map<TaskGroupIds, number>}
+     */
+    static getExecutionTimingsByGroup(tasks: LH.Artifacts.TaskNode[]): Map<TaskGroupIds, number>;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnCategory: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=mainthread-work-breakdown.d.ts.map

package/core/audits/mainthread-work-breakdown.js

@@ -0,0 +1,135 @@
+/**
+ * @license Copyright 2017 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.
+ */
+
+/**
+ * @fileoverview Audit a page to show a breakdown of execution timings on the main thread
+ */
+
+
+import {Audit} from './audit.js';
+import {taskGroups} from '../lib/tracehouse/task-groups.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {MainThreadTasks} from '../computed/main-thread-tasks.js';
+
+const UIStrings = {
+  /** Title of a diagnostic audit that provides detail on the main thread work the browser did to load the page. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
+  title: 'Minimizes main-thread work',
+  /** Title of a diagnostic audit that provides detail on the main thread work the browser did to load the page. This imperative title is shown to users when there is a significant amount of execution time that could be reduced. */
+  failureTitle: 'Minimize main-thread work',
+  /** Description of a Lighthouse audit that tells the user *why* they should reduce JS execution times. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Consider reducing the time spent parsing, compiling and executing JS. ' +
+    'You may find delivering smaller JS payloads helps with this. ' +
+    '[Learn how to minimize main-thread work](https://developer.chrome.com/docs/lighthouse/performance/mainthread-work-breakdown/)',
+  /** Label for the Main Thread Category column in data tables, rows will have a main thread Category and main thread Task Name. */
+  columnCategory: 'Category',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/** @typedef {import('../lib/tracehouse/task-groups.js').TaskGroupIds} TaskGroupIds */
+
+class MainThreadWorkBreakdown extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'mainthread-work-breakdown',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      requiredArtifacts: ['traces'],
+    };
+  }
+
+  /**
+   * @return {LH.Audit.ScoreOptions}
+   */
+  static get defaultOptions() {
+    return {
+      // see https://www.desmos.com/calculator/vhglu1x8zv
+      p10: 2017,
+      median: 4000,
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts.TaskNode[]} tasks
+   * @return {Map<TaskGroupIds, number>}
+   */
+  static getExecutionTimingsByGroup(tasks) {
+    /** @type {Map<TaskGroupIds, number>} */
+    const result = new Map();
+
+    for (const task of tasks) {
+      const originalTime = result.get(task.group.id) || 0;
+      result.set(task.group.id, originalTime + task.selfTime);
+    }
+
+    return result;
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const settings = context.settings || {};
+    const trace = artifacts.traces[MainThreadWorkBreakdown.DEFAULT_PASS];
+
+    const tasks = await MainThreadTasks.request(trace, context);
+    const multiplier = settings.throttlingMethod === 'simulate' ?
+      settings.throttling.cpuSlowdownMultiplier : 1;
+
+    const executionTimings = MainThreadWorkBreakdown.getExecutionTimingsByGroup(tasks);
+
+    let totalExecutionTime = 0;
+    /** @type {Record<string, number>} */
+    const categoryTotals = {};
+    const results = Array.from(executionTimings).map(([groupId, rawDuration]) => {
+      const duration = rawDuration * multiplier;
+      totalExecutionTime += duration;
+
+      const categoryTotal = categoryTotals[groupId] || 0;
+      categoryTotals[groupId] = categoryTotal + duration;
+
+      return {
+        group: groupId,
+        groupLabel: taskGroups[groupId].label,
+        duration: duration,
+      };
+    });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'groupLabel', valueType: 'text', label: str_(UIStrings.columnCategory)},
+      {key: 'duration', valueType: 'ms', granularity: 1, label: str_(i18n.UIStrings.columnTimeSpent)},
+      /* eslint-enable max-len */
+    ];
+
+    results.sort((a, b) => categoryTotals[b.group] - categoryTotals[a.group]);
+    const tableDetails = MainThreadWorkBreakdown.makeTableDetails(headings, results);
+
+    const score = Audit.computeLogNormalScore(
+      {p10: context.options.p10, median: context.options.median},
+      totalExecutionTime
+    );
+
+    return {
+      score,
+      numericValue: totalExecutionTime,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.seconds, {timeInMs: totalExecutionTime}),
+      details: tableDetails,
+    };
+  }
+}
+
+export default MainThreadWorkBreakdown;
+export {UIStrings};

package/core/audits/manual/manual-audit.d.ts

@@ -0,0 +1,13 @@
+export default ManualAudit;
+declare class ManualAudit extends Audit {
+    /**
+     * @return {Pick<LH.Audit.Meta, 'scoreDisplayMode'|'requiredArtifacts'>}
+     */
+    static get partialMeta(): Pick<import("../../../types/audit.js").default.Meta, "scoreDisplayMode" | "requiredArtifacts">;
+    /**
+     * @return {LH.Audit.Product}
+     */
+    static audit(): LH.Audit.Product;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=manual-audit.d.ts.map

package/core/audits/manual/manual-audit.js

@@ -0,0 +1,36 @@
+/**
+ * @license Copyright 2017 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.
+ */
+
+/**
+ * @fileoverview Base class for audits that the user should verify manually on
+ * their site.
+ */
+
+import {Audit} from '../audit.js';
+
+class ManualAudit extends Audit {
+  /**
+   * @return {Pick<LH.Audit.Meta, 'scoreDisplayMode'|'requiredArtifacts'>}
+   */
+  static get partialMeta() {
+    return {
+      scoreDisplayMode: Audit.SCORING_MODES.MANUAL,
+      requiredArtifacts: [],
+    };
+  }
+
+  /**
+   * @return {LH.Audit.Product}
+   */
+  static audit() {
+    return {
+      score: 0,
+      // displayValue: '(needs manual verification)'
+    };
+  }
+}
+
+export default ManualAudit;

package/core/audits/manual/pwa-cross-browser.d.ts

@@ -0,0 +1,12 @@
+export default PWACrossBrowser;
+/**
+ * @fileoverview Manual PWA audit for cross browser support.
+ */
+declare class PWACrossBrowser extends ManualAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import ManualAudit from "./manual-audit.js";
+//# sourceMappingURL=pwa-cross-browser.d.ts.map

package/core/audits/manual/pwa-cross-browser.js

@@ -0,0 +1,40 @@
+
+/**
+ * @license Copyright 2017 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.
+ */
+
+import ManualAudit from './manual-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that prompts the user to manually check that their site works across different web browsers. */
+  title: 'Site works cross-browser',
+  /** Description of a Lighthouse audit that tells the user why they should make sites work across different browsers. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'To reach the most number of users, sites should work across ' +
+  'every major browser. [Learn about cross-browser compatibility](https://developer.chrome.com/docs/lighthouse/pwa/pwa-cross-browser/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/**
+ * @fileoverview Manual PWA audit for cross browser support.
+ */
+
+class PWACrossBrowser extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'pwa-cross-browser',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+    }, super.partialMeta);
+  }
+}
+
+export default PWACrossBrowser;
+export {UIStrings};
+

package/core/audits/manual/pwa-each-page-has-url.d.ts

@@ -0,0 +1,12 @@
+export default PWAEachPageHasURL;
+/**
+ * @fileoverview Manual PWA audit to ensure every page has a deep link.
+ */
+declare class PWAEachPageHasURL extends ManualAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import ManualAudit from "./manual-audit.js";
+//# sourceMappingURL=pwa-each-page-has-url.d.ts.map

package/core/audits/manual/pwa-each-page-has-url.js

@@ -0,0 +1,38 @@
+/**
+ * @license Copyright 2017 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.
+ */
+
+import ManualAudit from './manual-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that prompts the user to manually check that each page on their website uses a unique URL. */
+  title: 'Each page has a URL',
+  /** Description of a Lighthouse audit that tells the user why they should use unique URLs for each web page. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Ensure individual pages are deep linkable via URL and that URLs are ' +
+      'unique for the purpose of shareability on social media. [Learn more about providing deep links](https://developer.chrome.com/docs/lighthouse/pwa/pwa-each-page-has-url/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/**
+ * @fileoverview Manual PWA audit to ensure every page has a deep link.
+ */
+
+class PWAEachPageHasURL extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'pwa-each-page-has-url',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+    }, super.partialMeta);
+  }
+}
+
+export default PWAEachPageHasURL;
+export {UIStrings};

package/core/audits/manual/pwa-page-transitions.d.ts

@@ -0,0 +1,12 @@
+export default PWAPageTransitions;
+/**
+ * @fileoverview Manual PWA audit for janky-free page transitions.
+ */
+declare class PWAPageTransitions extends ManualAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import ManualAudit from "./manual-audit.js";
+//# sourceMappingURL=pwa-page-transitions.d.ts.map

package/core/audits/manual/pwa-page-transitions.js

@@ -0,0 +1,38 @@
+/**
+ * @license Copyright 2017 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.
+ */
+
+import ManualAudit from './manual-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that prompts the user to manually check that page transitions (navigating to other pages on a website) shouldn't feel like they are waiting for the network to load. */
+  title: 'Page transitions don\'t feel like they block on the network',
+  /** Description of a Lighthouse audit that tells the user why they should make transitions in their web app feel fast. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Transitions should feel snappy as you tap around, even on a slow network. ' +
+    'This experience is key to a user\'s perception of performance. [Learn more about page transitions](https://developer.chrome.com/docs/lighthouse/pwa/pwa-page-transitions/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/**
+ * @fileoverview Manual PWA audit for janky-free page transitions.
+ */
+
+class PWAPageTransitions extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'pwa-page-transitions',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+    }, super.partialMeta);
+  }
+}
+
+export default PWAPageTransitions;
+export {UIStrings};