lighthouse 11.7.0-dev.20240408 → 11.7.1

package/core/gather/gatherers/global-listeners.js

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview
+ * A gatherer to collect information about the event listeners registered on the
+ * global object. For now, the scope is narrowed to events that occur on and
+ * around page unload, but this can be expanded in the future.
+ */
+
+import log from 'lighthouse-logger';
+
+import BaseGatherer from '../base-gatherer.js';
+
+class GlobalListeners extends BaseGatherer {
+  /** @type {LH.Gatherer.GathererMeta} */
+  meta = {
+    supportedModes: ['snapshot', 'timespan', 'navigation'],
+  };
+
+  /**
+   * @param {LH.Crdp.DOMDebugger.EventListener} listener
+   * @return {listener is {type: 'pagehide'|'unload'|'visibilitychange'} & LH.Crdp.DOMDebugger.EventListener}
+   */
+  static _filterForAllowlistedTypes(listener) {
+    return listener.type === 'pagehide' ||
+      listener.type === 'unload' ||
+      listener.type === 'visibilitychange';
+  }
+
+  /**
+   * @param { LH.Artifacts.GlobalListener } listener
+   * @return { string }
+   */
+  getListenerIndentifier(listener) {
+    return `${listener.type}:${listener.scriptId}:${listener.columnNumber}:${listener.lineNumber}`;
+  }
+
+  /**
+   * @param { LH.Artifacts['GlobalListeners'] } listeners
+   * @return { LH.Artifacts['GlobalListeners'] }
+   */
+  dedupeListeners(listeners) {
+    const seenListeners = new Set();
+    return listeners.filter(listener => {
+      const id = this.getListenerIndentifier(listener);
+      if (!seenListeners.has(id)) {
+        seenListeners.add(id);
+        return true;
+      } else {
+        return false;
+      }
+    });
+  }
+
+  /**
+   * @param {LH.Gatherer.Context} passContext
+   * @return {Promise<LH.Artifacts['GlobalListeners']>}
+   */
+  async getArtifact(passContext) {
+    const session = passContext.driver.defaultSession;
+
+    /** @type {Array<LH.Artifacts.GlobalListener>} */
+    const listeners = [];
+
+    for (const executionContext of passContext.driver.targetManager.mainFrameExecutionContexts()) {
+      // Get a RemoteObject handle to `window`.
+      let objectId;
+      try {
+        const {result} = await session.sendCommand('Runtime.evaluate', {
+          expression: 'window',
+          returnByValue: false,
+          uniqueContextId: executionContext.uniqueId,
+        });
+        if (!result.objectId) {
+          throw new Error('Error fetching information about the global object');
+        }
+        objectId = result.objectId;
+      } catch (err) {
+        // Execution context is no longer valid, but don't let that fail the gatherer.
+        log.warn('Execution context is no longer valid', executionContext, err);
+        continue;
+      }
+
+      // And get all its listeners of interest.
+      const response = await session.sendCommand('DOMDebugger.getEventListeners', {objectId});
+      for (const listener of response.listeners) {
+        if (GlobalListeners._filterForAllowlistedTypes(listener)) {
+          const {type, scriptId, lineNumber, columnNumber} = listener;
+          listeners.push({
+            type,
+            scriptId,
+            lineNumber,
+            columnNumber,
+          });
+        }
+      }
+    }
+
+    // Dedupe listeners with same underlying data.
+    return this.dedupeListeners(listeners);
+  }
+}
+
+export default GlobalListeners;

package/core/gather/gatherers/script-elements.d.ts

@@ -0,0 +1,21 @@
+export default ScriptElements;
+/**
+ * @fileoverview Gets JavaScript file contents.
+ */
+declare class ScriptElements extends BaseGatherer {
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.Context} context
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @return {Promise<LH.Artifacts['ScriptElements']>}
+     */
+    _getArtifact(context: LH.Gatherer.Context, networkRecords: LH.Artifacts.NetworkRequest[]): Promise<LH.Artifacts['ScriptElements']>;
+    /**
+     * @param {LH.Gatherer.Context<'DevtoolsLog'>} context
+     */
+    getArtifact(context: LH.Gatherer.Context<'DevtoolsLog'>): Promise<import("../../index.js").Artifacts.ScriptElement[]>;
+}
+import BaseGatherer from '../base-gatherer.js';
+import { NetworkRequest } from '../../lib/network-request.js';
+//# sourceMappingURL=script-elements.d.ts.map

package/core/gather/gatherers/script-elements.js

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import BaseGatherer from '../base-gatherer.js';
+import {NetworkRecords} from '../../computed/network-records.js';
+import {NetworkRequest} from '../../lib/network-request.js';
+import {pageFunctions} from '../../lib/page-functions.js';
+import DevtoolsLog from './devtools-log.js';
+
+/* global getNodeDetails */
+
+/**
+ * @return {LH.Artifacts['ScriptElements']}
+ */
+/* c8 ignore start */
+function collectAllScriptElements() {
+  /** @type {HTMLScriptElement[]} */
+  // @ts-expect-error - getElementsInDocument put into scope via stringification
+  const scripts = getElementsInDocument('script'); // eslint-disable-line no-undef
+
+  return scripts.map(script => {
+    return {
+      type: script.type || null,
+      src: script.src || null,
+      id: script.id || null,
+      async: script.async,
+      defer: script.defer,
+      source: script.closest('head') ? 'head' : 'body',
+      // @ts-expect-error - getNodeDetails put into scope via stringification
+      node: getNodeDetails(script),
+    };
+  });
+}
+/* c8 ignore stop */
+
+/**
+ * @fileoverview Gets JavaScript file contents.
+ */
+class ScriptElements extends BaseGatherer {
+  /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+  meta = {
+    supportedModes: ['timespan', 'navigation'],
+    dependencies: {DevtoolsLog: DevtoolsLog.symbol},
+  };
+
+  /**
+   * @param {LH.Gatherer.Context} context
+   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+   * @return {Promise<LH.Artifacts['ScriptElements']>}
+   */
+  async _getArtifact(context, networkRecords) {
+    const executionContext = context.driver.executionContext;
+
+    const scripts = await executionContext.evaluate(collectAllScriptElements, {
+      args: [],
+      useIsolation: true,
+      deps: [
+        pageFunctions.getNodeDetails,
+        pageFunctions.getElementsInDocument,
+      ],
+    });
+
+    const scriptRecords = networkRecords
+      .filter(record => record.resourceType === NetworkRequest.TYPES.Script)
+      .filter(record => record.sessionTargetType === 'page');
+
+    for (let i = 0; i < scriptRecords.length; i++) {
+      const record = scriptRecords[i];
+
+      const matchedScriptElement = scripts.find(script => script.src === record.url);
+      if (!matchedScriptElement) {
+        scripts.push({
+          type: null,
+          src: record.url,
+          id: null,
+          async: false,
+          defer: false,
+          source: 'network',
+          node: null,
+        });
+      }
+    }
+
+    return scripts;
+  }
+
+  /**
+   * @param {LH.Gatherer.Context<'DevtoolsLog'>} context
+   */
+  async getArtifact(context) {
+    const devtoolsLog = context.dependencies.DevtoolsLog;
+    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
+    return this._getArtifact(context, networkRecords);
+  }
+}
+
+export default ScriptElements;

package/core/gather/gatherers/seo/embedded-content.d.ts

@@ -0,0 +1,10 @@
+export default EmbeddedContent;
+declare class EmbeddedContent extends BaseGatherer {
+    /**
+     * @param {LH.Gatherer.Context} passContext
+     * @return {Promise<LH.Artifacts['EmbeddedContent']>}
+     */
+    getArtifact(passContext: LH.Gatherer.Context): Promise<LH.Artifacts['EmbeddedContent']>;
+}
+import BaseGatherer from '../../base-gatherer.js';
+//# sourceMappingURL=embedded-content.d.ts.map

package/core/gather/gatherers/seo/embedded-content.js

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* globals getElementsInDocument getNodeDetails */
+
+import BaseGatherer from '../../base-gatherer.js';
+import {pageFunctions} from '../../../lib/page-functions.js';
+
+/**
+ * @return {LH.Artifacts.EmbeddedContentInfo[]}
+ */
+function getEmbeddedContent() {
+  const functions = /** @type {typeof pageFunctions} */ ({
+    // @ts-expect-error - getElementsInDocument put into scope via stringification
+    getElementsInDocument,
+    // @ts-expect-error - getNodeDetails put into scope via stringification
+    getNodeDetails,
+  });
+
+  const selector = 'object, embed, applet';
+  const elements = functions.getElementsInDocument(selector);
+  return elements
+    .map(node => ({
+      tagName: node.tagName,
+      type: node.getAttribute('type'),
+      src: node.getAttribute('src'),
+      data: node.getAttribute('data'),
+      code: node.getAttribute('code'),
+      params: Array.from(node.children)
+        .filter(el => el.tagName === 'PARAM')
+        .map(el => ({
+          name: el.getAttribute('name') || '',
+          value: el.getAttribute('value') || '',
+        })),
+      node: functions.getNodeDetails(node),
+    }));
+}
+
+class EmbeddedContent extends BaseGatherer {
+  /** @type {LH.Gatherer.GathererMeta} */
+  meta = {
+    supportedModes: ['snapshot', 'navigation'],
+  };
+
+  /**
+   * @param {LH.Gatherer.Context} passContext
+   * @return {Promise<LH.Artifacts['EmbeddedContent']>}
+   */
+  getArtifact(passContext) {
+    return passContext.driver.executionContext.evaluate(getEmbeddedContent, {
+      args: [],
+      deps: [
+        pageFunctions.getElementsInDocument,
+        pageFunctions.getNodeDetails,
+      ],
+    });
+  }
+}
+
+export default EmbeddedContent;

package/core/gather/gatherers/seo/tap-targets.d.ts

@@ -0,0 +1,21 @@
+export default TapTargets;
+declare class TapTargets extends BaseGatherer {
+    /**
+     * @param {LH.Gatherer.ProtocolSession} session
+     * @param {string} className
+     * @return {Promise<string>}
+     */
+    addStyleRule(session: LH.Gatherer.ProtocolSession, className: string): Promise<string>;
+    /**
+     * @param {LH.Gatherer.ProtocolSession} session
+     * @param {string} styleSheetId
+     */
+    removeStyleRule(session: LH.Gatherer.ProtocolSession, styleSheetId: string): Promise<void>;
+    /**
+     * @param {LH.Gatherer.Context} passContext
+     * @return {Promise<LH.Artifacts.TapTarget[]>} All visible tap targets with their positions and sizes
+     */
+    getArtifact(passContext: LH.Gatherer.Context): Promise<LH.Artifacts.TapTarget[]>;
+}
+import BaseGatherer from '../../base-gatherer.js';
+//# sourceMappingURL=tap-targets.d.ts.map