@axe-core/puppeteer 4.6.2-alpha.379 → 4.7.0

package/dist/index.mjs

@@ -0,0 +1,443 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/axePuppeteer.ts
+import assert from "assert";
+
+// src/browser.ts
+function pageIsLoaded() {
+  return document.readyState === "complete";
+}
+function axeRunPartialSupport() {
+  return typeof window.axe.runPartial === "function";
+}
+function axeConfigure(config) {
+  if (config) {
+    window.axe.configure(config);
+  }
+  window.axe.configure({
+    branding: { application: "axe-puppeteer" }
+  });
+}
+function axeGetFrameContext(context) {
+  return window.axe.utils.getFrameContexts(context);
+}
+function axeShadowSelect(axeSelector) {
+  return window.axe.utils.shadowSelect(axeSelector);
+}
+function axeRunPartial(context, options) {
+  return window.axe.runPartial(context, options);
+}
+function axeFinishRun(options) {
+  return window.axe.finishRun(JSON.parse(window.partialResults), options);
+}
+function axeRunLegacy(context, options) {
+  return window.axe.run(context || document, options || {});
+}
+function chunkResultString(chunk) {
+  window.partialResults ??= "";
+  window.partialResults += chunk;
+}
+
+// src/legacy.ts
+import * as fs from "fs";
+async function injectJS(frame, { source, selector, logOnError, args }) {
+  if (!frame) {
+    return;
+  }
+  const frames = await frame.$$(selector);
+  const injections = [];
+  for (const frameElement of frames) {
+    const subFrame = await frameElement.contentFrame();
+    const p = injectJS(subFrame, {
+      source,
+      selector,
+      args,
+      logOnError: true
+    });
+    injections.push(p);
+  }
+  const reportError = () => {
+    console.error(`Failed to inject axe-core into frame (${frame.url()})`);
+  };
+  let injectP;
+  if (!source) {
+    injectP = injectJSModule(frame);
+  } else {
+    injectP = injectJSSource(frame, source, args);
+  }
+  if (logOnError) {
+    injectP = injectP.catch(reportError);
+  }
+  injections.push(injectP);
+  return Promise.all(injections).then(() => void 0);
+}
+async function injectJSModule(frame) {
+  const source = fs.readFileSync(__require.resolve("axe-core"), "utf8");
+  await injectJSSource(frame, source);
+}
+function injectJSSource(frame, source, args = []) {
+  return frame.evaluate(source, ...args);
+}
+function iframeSelector(disabledFrameSelectors) {
+  let selector = "iframe";
+  for (const disabledFrameSelector of disabledFrameSelectors) {
+    selector += `:not(${disabledFrameSelector})`;
+  }
+  return selector;
+}
+
+// src/axePartialRunner.ts
+var AxePartialRunner = class {
+  constructor(partialPromise, initiator = false) {
+    this.initiator = initiator;
+    this.partialPromise = caught(partialPromise);
+  }
+  partialPromise;
+  childRunners = [];
+  addChildResults(childResultRunner) {
+    this.childRunners.push(childResultRunner);
+  }
+  async getPartials() {
+    try {
+      const parentPartial = await this.partialPromise;
+      const childPromises = this.childRunners.map((childRunner) => {
+        return childRunner ? caught(childRunner.getPartials()) : [null];
+      });
+      const childPartials = (await Promise.all(childPromises)).flat(1);
+      return [parentPartial, ...childPartials];
+    } catch (e) {
+      if (this.initiator) {
+        throw e;
+      }
+      return [null];
+    }
+  }
+};
+var caught = ((f) => {
+  return (p) => (p.catch(f), p);
+})(() => {
+});
+
+// src/utils.ts
+import * as fs2 from "fs";
+async function frameSourceInject(frame, source, config) {
+  await assertFrameReady(frame);
+  if (!source) {
+    const pathFile = __require.resolve("axe-core");
+    source = fs2.readFileSync(pathFile, "utf8");
+  }
+  await frame.evaluate(source);
+  await frame.evaluate(axeConfigure, config);
+}
+function arrayify(src) {
+  if (!Array.isArray(src)) {
+    return [src];
+  }
+  return src;
+}
+function normalizeContext(includes, excludes, disabledFrameSelectors) {
+  const base = {
+    exclude: []
+  };
+  if (excludes.length && Array.isArray(base.exclude)) {
+    base.exclude.push(...excludes);
+  }
+  if (disabledFrameSelectors.length && Array.isArray(base.exclude)) {
+    const frameExcludes = disabledFrameSelectors.map((frame) => [frame, "*"]);
+    base.exclude.push(...frameExcludes);
+  }
+  if (includes.length) {
+    base.include = includes;
+  }
+  return base;
+}
+async function getChildFrame(frame, childSelector) {
+  const frameElm = await frame.evaluateHandle(axeShadowSelect, childSelector);
+  return await frameElm.asElement()?.contentFrame() || null;
+}
+async function assertFrameReady(frame) {
+  let pageReady = false;
+  try {
+    pageReady = await frame.evaluate(pageIsLoaded);
+  } catch {
+  }
+  if (!pageReady) {
+    throw new Error("Page/Frame is not ready");
+  }
+}
+
+// src/axePuppeteer.ts
+var AxePuppeteer = class {
+  frame;
+  axeSource;
+  includes;
+  excludes;
+  axeOptions;
+  config;
+  disabledFrameSelectors;
+  page;
+  legacyMode = false;
+  errorUrl;
+  constructor(pageFrame, source) {
+    if ("mainFrame" in pageFrame) {
+      if ("browser" in pageFrame) {
+        this.page = pageFrame;
+      } else {
+        console.warn(
+          "AxePuppeteer support for Puppeteer <= 3.0.3 is deprecated"
+        );
+      }
+      this.frame = pageFrame.mainFrame();
+    } else {
+      console.warn(
+        "AxePuppeteer construction with Frame objects is deprecated."
+      );
+      this.frame = pageFrame;
+    }
+    this.axeSource = source;
+    this.includes = [];
+    this.excludes = [];
+    this.axeOptions = {};
+    this.config = null;
+    this.disabledFrameSelectors = [];
+    this.errorUrl = "https://github.com/dequelabs/axe-core-npm/blob/develop/packages/puppeteer/error-handling.md";
+  }
+  /**
+   * Selector to include in analysis.
+   * This may be called any number of times.
+   */
+  include(selector) {
+    this.includes.push(selector);
+    return this;
+  }
+  /**
+   * Selector to exclude in analysis.
+   * This may be called any number of times.
+   */
+  exclude(selector) {
+    this.excludes.push(selector);
+    return this;
+  }
+  /**
+   * Set options to be passed into axe-core
+   */
+  options(options) {
+    this.axeOptions = options;
+    return this;
+  }
+  /**
+   * Limit analysis to only the specified rules.
+   * Cannot be used with `AxeBuilder#withTags`
+   */
+  withRules(rules) {
+    rules = arrayify(rules);
+    if (!this.axeOptions) {
+      this.axeOptions = {};
+    }
+    this.axeOptions.runOnly = {
+      type: "rule",
+      values: rules
+    };
+    return this;
+  }
+  /**
+   * Limit analysis to only specified tags.
+   * Cannot be used with `AxeBuilder#withRules`
+   */
+  withTags(tags) {
+    tags = arrayify(tags);
+    if (!this.axeOptions) {
+      this.axeOptions = {};
+    }
+    this.axeOptions.runOnly = {
+      type: "tag",
+      values: tags
+    };
+    return this;
+  }
+  /**
+   * Set the list of rules to skip when running an analysis.
+   */
+  disableRules(rules) {
+    rules = arrayify(rules);
+    const newRules = {};
+    for (const rule of rules) {
+      newRules[rule] = {
+        enabled: false
+      };
+    }
+    this.axeOptions.rules = newRules;
+    return this;
+  }
+  /**
+   * Set configuration for `axe-core`.
+   * This value is passed directly to `axe.configure()`
+   */
+  configure(config) {
+    assert(
+      typeof config === "object",
+      "AxePuppeteer needs an object to configure. See axe-core configure API."
+    );
+    this.config = config;
+    return this;
+  }
+  /**
+   * Exclude specific frames from a test
+   */
+  disableFrame(selector) {
+    this.disabledFrameSelectors.push(selector);
+    return this;
+  }
+  /**
+   * Use frameMessenger with <same_origin_only>
+   *
+   * This disables use of axe.runPartial() which is called in each frame, and
+   * axe.finishRun() which is called in a blank page. This uses axe.run() instead,
+   * but with the restriction that cross-origin frames will not be tested.
+   */
+  setLegacyMode(legacyMode = true) {
+    this.legacyMode = legacyMode;
+    return this;
+  }
+  async analyze(callback) {
+    try {
+      const axeResults = await this.analyzePromise();
+      if (callback) {
+        callback(null, axeResults);
+      }
+      return axeResults;
+    } catch (err) {
+      if (callback) {
+        callback(err);
+        return null;
+      }
+      throw err;
+    }
+  }
+  async analyzePromise() {
+    const { frame, axeSource, config } = this;
+    const context = normalizeContext(
+      this.includes,
+      this.excludes,
+      this.disabledFrameSelectors
+    );
+    await frameSourceInject(frame, axeSource, config);
+    const runPartialSupported = await frame.evaluate(axeRunPartialSupport);
+    if (runPartialSupported !== true || this.page === void 0 || this.legacyMode) {
+      return this.runLegacy(context);
+    }
+    const partialRunner = await this.runPartialRecursive(frame, context);
+    const partials = await partialRunner.getPartials();
+    try {
+      return await this.finishRun(partials);
+    } catch (error) {
+      throw new Error(
+        `${error.message}
+ Please check out ${this.errorUrl}`
+      );
+    }
+  }
+  async runPartialRecursive(frame, context) {
+    const frameContexts = await frame.evaluate(axeGetFrameContext, context);
+    const options = this.axeOptions;
+    const partialPromise = frame.evaluate(axeRunPartial, context, options);
+    const initiator = frame === this.frame;
+    const axePartialRunner = new AxePartialRunner(partialPromise, initiator);
+    for (const { frameSelector, frameContext } of frameContexts) {
+      try {
+        let childResults = null;
+        const childFrame = await getChildFrame(frame, frameSelector);
+        if (childFrame) {
+          await frameSourceInject(childFrame, this.axeSource, this.config);
+          childResults = await this.runPartialRecursive(
+            childFrame,
+            frameContext
+          );
+        }
+        axePartialRunner.addChildResults(childResults);
+      } catch {
+        axePartialRunner.addChildResults(null);
+      }
+    }
+    return axePartialRunner;
+  }
+  async finishRun(partialResults) {
+    const { axeOptions, axeSource, config, page } = this;
+    assert(page, "Running AxePuppeteer with a frame object is deprecated");
+    const browser = page.browser();
+    const blankPage = await browser.newPage();
+    assert(
+      blankPage,
+      "Please make sure that you have popup blockers disabled."
+    );
+    await frameSourceInject(blankPage.mainFrame(), axeSource, config);
+    const sizeLimit = 6e7;
+    const partialString = JSON.stringify(partialResults);
+    async function chunkResults(result) {
+      const chunk = result.substring(0, sizeLimit);
+      await blankPage.evaluate(chunkResultString, chunk);
+      if (result.length > sizeLimit) {
+        return await chunkResults(result.substr(sizeLimit));
+      }
+    }
+    await chunkResults(partialString);
+    return await blankPage.evaluate(axeFinishRun, axeOptions).finally(async () => {
+      await blankPage.close();
+    });
+  }
+  async runLegacy(context) {
+    const options = this.axeOptions;
+    const selector = iframeSelector(this.disabledFrameSelectors);
+    const source = this.axeSource;
+    let config = this.config;
+    if (!this.legacyMode) {
+      config = {
+        ...config || {},
+        allowedOrigins: ["<unsafe_all_origins>"]
+      };
+    }
+    await injectJS(this.frame, { source, selector });
+    await injectJS(this.frame, {
+      source: axeConfigure,
+      selector,
+      args: [config]
+    });
+    return this.frame.evaluate(axeRunLegacy, context, options);
+  }
+};
+
+// src/load-page.ts
+async function loadPage(browser, url, pageOpts = {}) {
+  const page = await browser.newPage();
+  await page.setBypassCSP(true);
+  await page.goto(url, pageOpts.opts);
+  return new OwningAxePuppeteer(page, pageOpts.source);
+}
+var OwningAxePuppeteer = class extends AxePuppeteer {
+  newPage;
+  constructor(page, source) {
+    super(page, source);
+    this.newPage = page;
+  }
+  async analyze(callback) {
+    try {
+      return await super.analyze(callback);
+    } finally {
+      await this.newPage.close();
+    }
+  }
+};
+
+// src/index.ts
+var src_default = AxePuppeteer;
+export {
+  AxePuppeteer,
+  src_default as default,
+  loadPage
+};

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@axe-core/puppeteer",
-  "version": "4.6.2-alpha.379+2e0fdb4",
+  "version": "4.7.0",
   "description": "Provides a chainable axe API for Puppeteer and automatically injects into all frames",
   "repository": {
     "type": "git",
     "url": "https://github.com/dequelabs/axe-core-npm.git"
   },
   "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "files": [
     "/dist"
   ],
@@ -15,8 +23,9 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup src/index.ts --dts --format esm,cjs",
     "test": "mocha 'test/**/*.test.ts'",
+    "test:esm": "node esmTest.mjs",
     "coverage": "nyc npm run test",
     "prepublishOnly": "npm run build"
   },
@@ -39,6 +48,7 @@
     "source-map-support": "^0.5.21",
     "test-listen": "^1.1.0",
     "ts-node": "^10.9.1",
+    "tsup": "^6.7.0",
     "typescript": "^4.8.4"
   },
   "dependencies": {
@@ -77,5 +87,5 @@
     "functions": 85,
     "lines": 85
   },
-  "gitHead": "2e0fdb4a4661040b9b8dbb91bed1a96142e4fe0c"
+  "gitHead": "623da3a516cbf1c7a0a0461b23a8c98f094cc18d"
 }

package/dist/axePartialRunner.d.ts

@@ -1,11 +0,0 @@
-import * as axe from 'axe-core';
-export declare type PartialResults = Parameters<typeof axe.finishRun>[0];
-export declare class AxePartialRunner {
-    private initiator;
-    private partialPromise;
-    private childRunners;
-    constructor(partialPromise: Promise<axe.PartialResult>, initiator?: boolean);
-    addChildResults(childResultRunner: AxePartialRunner | null): void;
-    getPartials(): Promise<PartialResults>;
-}
-export declare const caught: <T>(p: Promise<T>) => Promise<T>;

package/dist/axePartialRunner.js

@@ -1,45 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.caught = exports.AxePartialRunner = void 0;
-class AxePartialRunner {
-    constructor(partialPromise, initiator = false) {
-        this.initiator = initiator;
-        this.childRunners = [];
-        this.partialPromise = (0, exports.caught)(partialPromise);
-    }
-    addChildResults(childResultRunner) {
-        this.childRunners.push(childResultRunner);
-    }
-    getPartials() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const parentPartial = yield this.partialPromise;
-                const childPromises = this.childRunners.map(childRunner => {
-                    return childRunner ? (0, exports.caught)(childRunner.getPartials()) : [null];
-                });
-                const childPartials = (yield Promise.all(childPromises)).flat(1);
-                return [parentPartial, ...childPartials];
-            }
-            catch (e) {
-                if (this.initiator) {
-                    throw e;
-                }
-                return [null];
-            }
-        });
-    }
-}
-exports.AxePartialRunner = AxePartialRunner;
-exports.caught = ((f) => {
-    return (p) => (p.catch(f), p);
-})(() => { });
-//# sourceMappingURL=axePartialRunner.js.map

package/dist/axePartialRunner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"axePartialRunner.js","sourceRoot":"","sources":["../src/axePartialRunner.ts"],"names":[],"mappings":";;;;;;;;;;;;AAcA,MAAa,gBAAgB;IAI3B,YACE,cAA0C,EAClC,YAAqB,KAAK;QAA1B,cAAS,GAAT,SAAS,CAAiB;QAJ5B,iBAAY,GAAmC,EAAE,CAAC;QAMxD,IAAI,CAAC,cAAc,GAAG,IAAA,cAAM,EAAC,cAAc,CAAC,CAAC;IAC/C,CAAC;IAEM,eAAe,CAAC,iBAA0C;QAC/D,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAC5C,CAAC;IAEY,WAAW;;YACtB,IAAI;gBACF,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC;gBAChD,MAAM,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE;oBACxD,OAAO,WAAW,CAAC,CAAC,CAAC,IAAA,cAAM,EAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBAClE,CAAC,CAAC,CAAC;gBACH,MAAM,aAAa,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACjE,OAAO,CAAC,aAAa,EAAE,GAAG,aAAa,CAAC,CAAC;aAC1C;YAAC,OAAO,CAAC,EAAE;gBACV,IAAI,IAAI,CAAC,SAAS,EAAE;oBAClB,MAAM,CAAC,CAAC;iBACT;gBACD,OAAO,CAAC,IAAI,CAAC,CAAC;aACf;QACH,CAAC;KAAA;CACF;AA9BD,4CA8BC;AAIY,QAAA,MAAM,GAAG,CAAC,CAAC,CAAa,EAAE,EAAE;IACvC,OAAO,CAAI,CAAa,EAAc,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE3D,CAAC,CAAC,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC"}

package/dist/axePuppeteer.d.ts

@@ -1,31 +0,0 @@
-import { RunOptions, Spec, AxeResults, SerialFrameSelector } from 'axe-core';
-import { Frame, Page } from 'puppeteer';
-import { AnalyzeCB } from './types';
-export declare class AxePuppeteer {
-    private frame;
-    private axeSource?;
-    private includes;
-    private excludes;
-    private axeOptions;
-    private config;
-    private disabledFrameSelectors;
-    private page;
-    private legacyMode;
-    private errorUrl;
-    constructor(pageFrame: Page | Frame, source?: string);
-    include(selector: SerialFrameSelector): this;
-    exclude(selector: SerialFrameSelector): this;
-    options(options: RunOptions): this;
-    withRules(rules: string | string[]): this;
-    withTags(tags: string | string[]): this;
-    disableRules(rules: string | string[]): this;
-    configure(config: Spec): this;
-    disableFrame(selector: string): this;
-    setLegacyMode(legacyMode?: boolean): this;
-    analyze(): Promise<AxeResults>;
-    analyze<T extends AnalyzeCB>(callback?: T): Promise<AxeResults | null>;
-    private analyzePromise;
-    private runPartialRecursive;
-    private finishRun;
-    private runLegacy;
-}