feat: stringify helpers only if used (#602)

puppeteer · Jul 10, 2023 · b7d8cdd · b7d8cdd
1 parent b95ff12
commit b7d8cdd
Show file tree

Hide file tree

Showing 3 changed files with 11 additions and 1,275 deletions.
diff --git a/__snapshots__/lighthouse.test.ts.js b/__snapshots__/lighthouse.test.ts.js
@@ -87,133 +87,6 @@ const puppeteer = require('puppeteer'); // v20.7.4 or later
 
   await browser.close();
 
-  async function waitForElement(step, frame, timeout) {
-    const {
-      count = 1,
-      operator = '>=',
-      visible = true,
-      properties,
-      attributes,
-    } = step;
-    const compFn = {
-      '==': (a, b) => a === b,
-      '>=': (a, b) => a >= b,
-      '<=': (a, b) => a <= b,
-    }[operator];
-    await waitForFunction(async () => {
-      const elements = await querySelectorsAll(step.selectors, frame);
-      let result = compFn(elements.length, count);
-      const elementsHandle = await frame.evaluateHandle((...elements) => {
-        return elements;
-      }, ...elements);
-      await Promise.all(elements.map((element) => element.dispose()));
-      if (result && (properties || attributes)) {
-        result = await elementsHandle.evaluate(
-          (elements, properties, attributes) => {
-            for (const element of elements) {
-              if (attributes) {
-                for (const [name, value] of Object.entries(attributes)) {
-                  if (element.getAttribute(name) !== value) {
-                    return false;
-                  }
-                }
-              }
-              if (properties) {
-                if (!isDeepMatch(properties, element)) {
-                  return false;
-                }
-              }
-            }
-            return true;
-
-            function isDeepMatch(a, b) {
-              if (a === b) {
-                return true;
-              }
-              if ((a && !b) || (!a && b)) {
-                return false;
-              }
-              if (!(a instanceof Object) || !(b instanceof Object)) {
-                return false;
-              }
-              for (const [key, value] of Object.entries(a)) {
-                if (!isDeepMatch(value, b[key])) {
-                  return false;
-                }
-              }
-              return true;
-            }
-          },
-          properties,
-          attributes
-        );
-      }
-      await elementsHandle.dispose();
-      return result === visible;
-    }, timeout);
-  }
-
-  async function querySelectorsAll(selectors, frame) {
-    for (const selector of selectors) {
-      const result = await querySelectorAll(selector, frame);
-      if (result.length) {
-        return result;
-      }
-    }
-    return [];
-  }
-
-  async function querySelectorAll(selector, frame) {
-    if (!Array.isArray(selector)) {
-      selector = [selector];
-    }
-    if (!selector.length) {
-      throw new Error('Empty selector provided to querySelectorAll');
-    }
-    let elements = [];
-    for (let i = 0; i < selector.length; i++) {
-      const part = selector[i];
-      if (i === 0) {
-        elements = await frame.$$(part);
-      } else {
-        const tmpElements = elements;
-        elements = [];
-        for (const el of tmpElements) {
-          elements.push(...(await el.$$(part)));
-        }
-      }
-      if (elements.length === 0) {
-        return [];
-      }
-      if (i < selector.length - 1) {
-        const tmpElements = [];
-        for (const el of elements) {
-          const newEl = (await el.evaluateHandle(el => el.shadowRoot ? el.shadowRoot : el)).asElement();
-          if (newEl) {
-            tmpElements.push(newEl);
-          }
-        }
-        elements = tmpElements;
-      }
-    }
-    return elements;
-  }
-
-  async function waitForFunction(fn, timeout) {
-    let isActive = true;
-    const timeoutId = setTimeout(() => {
-      isActive = false;
-    }, timeout);
-    while (isActive) {
-      const result = await fn();
-      if (result) {
-        clearTimeout(timeoutId);
-        return;
-      }
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-    throw new Error('Timed out');
-  }
 })().catch(err => {
   console.error(err);
   process.exit(1);