lighthouse 9.6.7 → 10.0.0

package/core/audits/dobetterweb/js-libraries.js

@@ -0,0 +1,87 @@
+/**
+ * @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 Diagnostic audit that lists all JavaScript libraries detected on the page
+ */
+
+
+import {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on the Javascript libraries that are used on the page. */
+  title: 'Detected JavaScript libraries',
+  /** Description of a Lighthouse audit that tells the user what this audit is detecting. This is displayed after a user expands the section to see more. No character length limits. */
+  description: 'All front-end JavaScript libraries detected on the page. [Learn more about this JavaScript library detection diagnostic audit](https://developer.chrome.com/docs/lighthouse/best-practices/js-libraries/).',
+  /** Label for a column in a data table; entries will be the version numbers of the detected Javascript libraries.  */
+  columnVersion: 'Version',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class JsLibrariesAudit extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'js-libraries',
+      title: str_(UIStrings.title),
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Stacks'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    const libDetails = artifacts.Stacks
+      .filter(stack => stack.detector === 'js')
+      // Don't show the fast paths in the table.
+      .filter(stack => !stack.id.endsWith('-fast'))
+      .map(stack => ({
+        name: stack.name,
+        version: stack.version,
+        npm: stack.npm,
+      }));
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'name', valueType: 'text', label: str_(i18n.UIStrings.columnName)},
+      {key: 'version', valueType: 'text', label: str_(UIStrings.columnVersion)},
+    ];
+    const details = Audit.makeTableDetails(headings, libDetails);
+
+    const debugData = {
+      type: /** @type {const} */ ('debugdata'),
+      stacks: artifacts.Stacks.map(stack => {
+        return {
+          id: stack.id,
+          version: stack.version,
+        };
+      }),
+    };
+
+    if (!libDetails.length) {
+      return {score: null, notApplicable: true};
+    }
+
+    return {
+      score: 1, // Always pass for now.
+      details: {
+        ...details,
+        debugData,
+      },
+    };
+  }
+}
+
+export default JsLibrariesAudit;
+export {UIStrings};

package/core/audits/dobetterweb/no-document-write.d.ts

@@ -0,0 +1,16 @@
+export default NoDocWriteAudit;
+declare class NoDocWriteAudit extends ViolationAudit {
+    /**
+     * @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;
+}
+import ViolationAudit from "../violation-audit.js";
+//# sourceMappingURL=no-document-write.d.ts.map

package/core/audits/dobetterweb/no-document-write.js

@@ -0,0 +1,84 @@
+/**
+ * @license Copyright 2016 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 see if it's using document.write(). document.write() has terrible performance characteristics.
+ *
+ * *Intervention*
+ * There is a Chrome intervention for the API: https://developers.google.com/web/updates/2016/08/removing-document-write
+ * The intervention appears to only be enabled when the user is on a slow connnection. https://chromestatus.com/features#document.write
+ * When it's enabled, _some_ calls to document.write() will just not do anything. They're just no-ops.
+ *  - "some" == mostly third-party situations. src: https://cs.chromium.org/chromium/src/third_party/blink/renderer/core/script/document_write_intervention.cc?l=109&rcl=61a806621861e9abc07b3a57a6f2edae188d1742
+ * If this happens, there will be an error message in the console. src: https://cs.chromium.org/chromium/src/third_party/blink/renderer/core/script/document_write_intervention.cc?l=51-61&rcl=61a806621861e9abc07b3a57a6f2edae188d1742
+ *  - Lighthouse doesn't report here on that situation, though it'll show up in `errors-in-console`
+ * The intervention may also not block the .write() (because the connection wasn't slow),
+ * but it will emit a console warning.
+ *  - Lighthouse will also report that here, as the .write() call succeeded.
+ * Demo URL: https://output.jsbin.com/qopijux/quiet
+ *
+ * *This Audit*
+ * This audit reports on document.write() calls which the intervention didn't stop.
+ * (They worked as intended). If that happens, the browser emits a verbose-level violation
+ * console message (hidden by default) that says:
+ *     "Parser was blocked due to document.write(<script>)". src: https://cs.chromium.org/chromium/src/third_party/blink/renderer/core/frame/performance_monitor.cc?l=294-300&rcl=40b90cafad9f219e0845879ed8648bdcc96116dc
+ */
+
+
+import ViolationAudit from '../violation-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on the page's use of the `document.write` API. This descriptive title is shown to users when the page does not use `document.write`. */
+  title: 'Avoids `document.write()`',
+  /** Title of a Lighthouse audit that provides detail on the page's use of the `document.write` API. This imperative title is shown to users when the page does use `document.write`. */
+  failureTitle: 'Avoid `document.write()`',
+  /** Description of a Lighthouse audit that tells the user why they should avoid `document.write`. 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: 'For users on slow connections, external scripts dynamically injected via ' +
+      '`document.write()` can delay page load by tens of seconds. ' +
+      '[Learn how to avoid document.write()](https://developer.chrome.com/docs/lighthouse/best-practices/no-document-write/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class NoDocWriteAudit extends ViolationAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'no-document-write',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['ConsoleMessages', 'SourceMaps', 'Scripts'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const results =
+      await ViolationAudit.getViolationResults(artifacts, context, /document\.write/);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'source', valueType: 'source-location', label: str_(i18n.UIStrings.columnSource)},
+    ];
+    // TODO(bckenny): see TODO in geolocation-on-start
+    const details = ViolationAudit.makeTableDetails(headings, results);
+
+    return {
+      score: Number(results.length === 0),
+      details,
+    };
+  }
+}
+
+export default NoDocWriteAudit;
+export {UIStrings};

package/core/audits/dobetterweb/notification-on-start.d.ts

@@ -0,0 +1,16 @@
+export default NotificationOnStart;
+declare class NotificationOnStart extends ViolationAudit {
+    /**
+     * @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;
+}
+import ViolationAudit from "../violation-audit.js";
+//# sourceMappingURL=notification-on-start.d.ts.map

package/core/audits/dobetterweb/notification-on-start.js

@@ -0,0 +1,68 @@
+/**
+ * @license Copyright 2016 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 Audits a page to see if it is requesting usage of the notification API on
+ * page load. This is often a sign of poor user experience because it lacks context.
+ */
+
+
+import ViolationAudit from '../violation-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on the page's notification permission requests. This descriptive title is shown to users when the page does not ask for notification permission on load. */
+  title: 'Avoids requesting the notification permission on page load',
+  /** Title of a Lighthouse audit that provides detail on the page's notification permission requests. This descriptive title is shown to users when the page does ask for notification permission on load. */
+  failureTitle: 'Requests the notification permission on page load',
+  /** Description of a Lighthouse audit that tells the user why they should not ask for notification permission on load. 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: 'Users are mistrustful of or confused by sites that request to send ' +
+      'notifications without context. Consider tying the request to user gestures ' +
+      'instead. [Learn more about responsibly getting permission for notifications](https://developer.chrome.com/docs/lighthouse/best-practices/notification-on-start/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class NotificationOnStart extends ViolationAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'notification-on-start',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['ConsoleMessages', 'SourceMaps', 'Scripts'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const results =
+      await ViolationAudit.getViolationResults(artifacts, context, /notification permission/);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'source', valueType: 'source-location', label: str_(i18n.UIStrings.columnSource)},
+    ];
+    // TODO(bckenny): see TODO in geolocation-on-start
+    const details = ViolationAudit.makeTableDetails(headings, results);
+
+    return {
+      score: Number(results.length === 0),
+      details,
+    };
+  }
+}
+
+export default NotificationOnStart;
+export {UIStrings};

package/core/audits/dobetterweb/paste-preventing-inputs.d.ts

@@ -0,0 +1,15 @@
+export default PastePreventingInputsAudit;
+declare class PastePreventingInputsAudit extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=paste-preventing-inputs.d.ts.map

package/core/audits/dobetterweb/paste-preventing-inputs.js

@@ -0,0 +1,67 @@
+/**
+ * @license Copyright 2023 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 the ability to paste into input fields. This descriptive title is shown to users when the page allows pasting of content into input fields. */
+  title: 'Allows users to paste into input fields',
+  /** Title of a Lighthouse audit that provides detail on the ability to paste into input fields. This descriptive title is shown to users when the page does not allow pasting of content into input fields. */
+  failureTitle: 'Prevents users from pasting into input fields',
+  /** Description of a Lighthouse audit that tells the user why they should allow pasting of content into input fields. This is displayed after a user expands the section to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
+  description: 'Preventing input pasting is a UX anti-pattern, ' +
+      'and undermines good security policy. ' +
+      '[Learn more about user-friendly input fields](https://developer.chrome.com/docs/lighthouse/best-practices/paste-preventing-inputs/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class PastePreventingInputsAudit extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'paste-preventing-inputs',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Inputs'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    const inputsWithPreventsPaste = artifacts.Inputs.inputs.filter(input => input.preventsPaste);
+
+    /** @type {LH.Audit.Details.Table['items']} */
+    const items = [];
+
+    inputsWithPreventsPaste.forEach(input => {
+      items.push({
+        node: Audit.makeNodeItem(input.node),
+        type: input.type,
+      });
+    });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'node', valueType: 'node', label: str_(i18n.UIStrings.columnFailingElem)},
+    ];
+
+    return {
+      score: Number(inputsWithPreventsPaste.length === 0),
+      details: Audit.makeTableDetails(headings, items),
+    };
+  }
+}
+
+export default PastePreventingInputsAudit;
+export {UIStrings};

package/core/audits/dobetterweb/uses-http2.d.ts

@@ -0,0 +1,72 @@
+export default UsesHTTP2Audit;
+export type Simulator = import('../../lib/dependency-graph/simulator/simulator').Simulator;
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+declare class UsesHTTP2Audit extends Audit {
+    /**
+     * Computes the estimated effect all results being converted to use http/2, the max of:
+     *
+     * - end time of the last long task in the provided graph
+     * - end time of the last node in the graph
+     *
+     * @param {Array<{url: string}>} results
+     * @param {Node} graph
+     * @param {Simulator} simulator
+     * @return {number}
+     */
+    static computeWasteWithTTIGraph(results: Array<{
+        url: string;
+    }>, graph: Node, simulator: Simulator): number;
+    /**
+     * Determines whether a network request is a "static resource" that would benefit from H2 multiplexing.
+     * XHRs, tracking pixels, etc generally don't benefit as much because they aren't requested en-masse
+     * for the same origin at the exact same time.
+     *
+     * @param {LH.Artifacts.NetworkRequest} networkRequest
+     * @param {LH.Artifacts.EntityClassification} classifiedEntities
+     * @return {boolean}
+     */
+    static isStaticAsset(networkRequest: LH.Artifacts.NetworkRequest, classifiedEntities: LH.Artifacts.EntityClassification): boolean;
+    /**
+     * Determine the set of resources that aren't HTTP/2 but should be.
+     * We're a little conservative about what we surface for a few reasons:
+     *
+     *    - The simulator approximation of HTTP/2 is a little more generous than reality.
+     *    - There's a bit of debate surrounding HTTP/2 due to its worse performance in environments with high packet loss.**
+     *    - It's something that you'd have absolutely zero control over with a third-party (can't defer to fix it for example).
+     *
+     * Therefore, we only surface requests that were...
+     *
+     *    - Served over HTTP/1.1 or earlier
+     *    - Served over an origin that serves at least 6 static asset requests
+     *      (if there aren't more requests than browser's max/host, multiplexing isn't as big a deal)
+     *    - Not served on localhost (h2 is a pain to deal with locally & and CI)
+     *
+     * ** = https://news.ycombinator.com/item?id=19086639
+     *      https://www.twilio.com/blog/2017/10/http2-issues.html
+     *      https://www.cachefly.com/http-2-is-not-a-magic-bullet/
+     *
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Artifacts.EntityClassification} classifiedEntities
+     * @return {Array<{url: string, protocol: string}>}
+     */
+    static determineNonHttp2Resources(networkRecords: Array<LH.Artifacts.NetworkRequest>, classifiedEntities: LH.Artifacts.EntityClassification): Array<{
+        url: string;
+        protocol: string;
+    }>;
+    /**
+     * @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;
+    const columnProtocol: string;
+}
+import { Audit } from "../audit.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+import { EntityClassification } from "../../computed/entity-classification.js";
+//# sourceMappingURL=uses-http2.d.ts.map