accessibility-checker/mjs/lib/ACBrowserManager.js

An automated testing tools for accessibility testing using Puppeteer, Selenium, or Zombie

import * as puppeteer from "puppeteer";
import { ACConfigManager } from "./common/config/ACConfigManager.js";
export class ACBrowserManager {
    static browserP;
    static config;
    static numInits;
    static pages = [];
    static async getBrowserChrome(force) {
        if (!ACBrowserManager.config) {
            ACBrowserManager.config = await ACConfigManager.getConfigUnsupported();
        }
        if (force || !ACBrowserManager.browserP) {
            let pupOptions = {
                headless: ACBrowserManager.config.headless,
                ignoreHTTPSErrors: ACBrowserManager.config.ignoreHTTPSErrors || false
            };
            if (ACBrowserManager.config.puppeteerArgs) {
                pupOptions.args = ACBrowserManager.config.puppeteerArgs;
            }
            return ACBrowserManager.browserP = puppeteer.launch(pupOptions);
        }
        else {
            return ACBrowserManager.browserP;
        }
    }
    static async close() {
        if (ACBrowserManager.browserP) {
            let browser = await ACBrowserManager.browserP;
            await browser.close();
            ACBrowserManager.browserP = null;
            ACBrowserManager.pages = [];
        }
    }
    /**
     * This function is responsible for building an iframe object with the provided URL or local file.
     *
     * @param {String} URLorLocalFile - Provide a URL or local file to scan.
     *
     * @return {Object} content - return an object which contains the iframeDoc and also the URL or
     *                               local file name.
     *
     * PRIVATE METHOD
     *
     * @memberOf this
     */
    static async buildIframeAndGetDoc(URLorLocalFileorContent) {
        if (!ACBrowserManager.config) {
            ACBrowserManager.config = await ACConfigManager.getConfigUnsupported();
        }
        const MAX_TABS = ACBrowserManager.config.maxTabs;
        const browser = await ACBrowserManager.getBrowserChrome(false);
        // Clear out any pages that are already closed
        ACBrowserManager.pages = ACBrowserManager.pages.filter((page) => page && !page.isClosed());
        // If there's an existing, ready page, use it
        let availPage;
        for (const page of ACBrowserManager.pages) {
            if (!availPage) {
                if (!page.aceBusy) {
                    availPage = page;
                    page.aceBusy = true;
                }
            }
        }
        if (!availPage) {
            // All pages are busy. Should we create a new one?
            if (ACBrowserManager.pages.length + ACBrowserManager.numInits >= MAX_TABS) {
                // Too many pages, restart
                return new Promise((resolve, reject) => {
                    setTimeout(async () => {
                        resolve(await ACBrowserManager.buildIframeAndGetDoc(URLorLocalFileorContent));
                    }, 500);
                });
            }
            else {
                // Let's create a new page
                ++ACBrowserManager.numInits;
                let newPage = await browser.newPage();
                newPage.on('console', msg => {
                    for (let i = 0; i < msg.args.length; ++i)
                        console.log(`${i}: ${msg.args[i]}`);
                });
                newPage.aceBusy = true;
                availPage = newPage;
                ACBrowserManager.pages.push(newPage);
                --ACBrowserManager.numInits;
            }
        }
        let err = null, retVal = null;
        async function nav() {
            try {
                if (URLorLocalFileorContent.toLowerCase().includes("<html")) {
                    // await page.goto(`data:text/html,encodeURIComponent(${URLorLocalFileorContent})`, { waitUntil: 'networkidle0' });
                    let urlStr = "data:text/html;charset=utf-8," + encodeURIComponent(URLorLocalFileorContent);
                    await availPage.goto(urlStr);
                }
                else {
                    await availPage.goto(URLorLocalFileorContent);
                }
            }
            catch (e) {
                err = `${e.message} ${URLorLocalFileorContent}`;
                console.error(err);
                return null;
            }
            return availPage;
        }
        try {
            retVal = await nav();
        }
        catch (e) {
        }
        if (!retVal) {
            // Page bad or unable to navigate, start over
            availPage.close();
            return new Promise((resolve, reject) => {
                setTimeout(async () => {
                    resolve(await ACBrowserManager.buildIframeAndGetDoc(URLorLocalFileorContent));
                }, 0);
            });
        }
        if (retVal === null) {
            console.log("[Internal Error:load content]", err);
        }
        return retVal;
    }
    ;
}
//# sourceMappingURL=ACBrowserManager.js.map