@jsenv/core 26.0.1 → 27.0.0-alpha.10

package/src/internal/browser_launcher/execute_html_file.js

@@ -1,355 +0,0 @@
-import {
-  resolveUrl,
-  assertFilePresence,
-  urlToRelativeUrl,
-  urlToExtension,
-} from "@jsenv/filesystem"
-
-import { COMPILE_PROXY_BUILD_URL } from "@jsenv/core/dist/build_manifest.js"
-import { filterV8Coverage } from "@jsenv/core/src/internal/coverage/v8_coverage_from_directory.js"
-import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/internal/coverage/istanbul_coverage_composition.js"
-import { evalSource } from "@jsenv/core/src/internal/node_launcher/eval_source.js"
-import { escapeRegexpSpecialCharacters } from "@jsenv/core/src/internal/regexp_escape.js"
-
-import { getBrowserRuntimeProfile } from "./browser_runtime_profile.js"
-
-export const executeHtmlFile = async (
-  fileRelativeUrl,
-  {
-    runtime,
-    executeOperation,
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileServerId,
-    jsenvDirectoryRelativeUrl,
-    page,
-
-    // measurePerformance,
-    collectPerformance,
-    collectCoverage,
-    coverageIgnorePredicate,
-    coverageForceIstanbul,
-    coveragePlaywrightAPIAvailable,
-    transformErrorHook,
-    forceSource,
-    forceCompilation,
-  },
-) => {
-  const fileUrl = resolveUrl(fileRelativeUrl, projectDirectoryUrl)
-  if (urlToExtension(fileUrl) !== ".html") {
-    throw new Error(
-      `the file to execute must use .html extension, received ${fileRelativeUrl}.`,
-    )
-  }
-
-  await assertFilePresence(fileUrl)
-
-  const compileProxyProjectRelativeUrl = urlToRelativeUrl(
-    COMPILE_PROXY_BUILD_URL,
-    projectDirectoryUrl,
-  )
-  const compileProxyClientUrl = resolveUrl(
-    compileProxyProjectRelativeUrl,
-    compileServerOrigin,
-  )
-  executeOperation.throwIfAborted()
-  await page.goto(compileProxyClientUrl)
-  executeOperation.throwIfAborted()
-
-  const coverageHandledFromOutside =
-    coveragePlaywrightAPIAvailable && !coverageForceIstanbul
-  const browserRuntimeProfile = await getBrowserRuntimeProfile({
-    page,
-    compileServerId,
-    runtime,
-    // js coverage
-    // When instrumentation CAN be handed by playwright
-    // https://playwright.dev/docs/api/class-chromiumcoverage#chromiumcoveragestartjscoverageoptions
-    // coverageHandledFromOutside is true and "transform-instrument" becomes non mandatory
-    coverageHandledFromOutside,
-    forceSource,
-    forceCompilation,
-  })
-
-  try {
-    let executionResult
-    const { compileId } = browserRuntimeProfile
-    executeOperation.throwIfAborted()
-    if (compileId) {
-      executionResult = await executeCompiledVersion({
-        projectDirectoryUrl,
-        compileServerOrigin,
-        fileRelativeUrl,
-        page,
-        jsenvDirectoryRelativeUrl,
-        compileId,
-        collectCoverage,
-        transformErrorHook,
-      })
-    } else {
-      executionResult = await executeSource({
-        projectDirectoryUrl,
-        compileServerOrigin,
-        fileRelativeUrl,
-        page,
-        collectCoverage,
-        coverageIgnorePredicate,
-        transformErrorHook,
-      })
-    }
-
-    if (collectPerformance) {
-      const performance = await page.evaluate(
-        /* istanbul ignore next */
-        () => {
-          // eslint-disable-next-line no-undef
-          const { performance } = window
-          if (!performance) {
-            return null
-          }
-
-          const measures = {}
-          const measurePerfEntries = performance.getEntriesByType("measure")
-          measurePerfEntries.forEach((measurePerfEntry) => {
-            measures[measurePerfEntry.name] = measurePerfEntry.duration
-          })
-
-          return {
-            timeOrigin: performance.timeOrigin,
-            timing: performance.timing.toJSON(),
-            navigation: performance.navigation.toJSON(),
-            measures,
-          }
-        },
-      )
-      executionResult.performance = performance
-    }
-
-    return executionResult
-  } catch (error) {
-    // if browser is closed due to abort
-    // before it is able to finish evaluate we can safely ignore
-    // and rethrow with current abort error
-    if (executeOperation.signal.aborted && isBrowserClosedError(error)) {
-      executeOperation.throwIfAborted()
-    }
-    throw error
-  }
-}
-
-const isBrowserClosedError = (error) => {
-  if (error.message.match(/browserContext.newPage: Browser closed/)) {
-    return true
-  }
-
-  if (error.message.match(/^Protocol error \(.*?\): Target closed/)) {
-    return true
-  }
-
-  return false
-}
-
-const executeSource = async ({
-  projectDirectoryUrl,
-  compileServerOrigin,
-  fileRelativeUrl,
-  page,
-  collectCoverage,
-  coverageIgnorePredicate,
-  transformErrorHook,
-}) => {
-  let transformResult = (result) => result
-
-  if (collectCoverage) {
-    await page.coverage.startJSCoverage({
-      // reportAnonymousScripts: true,
-    })
-    transformResult = composeTransformer(transformResult, async (result) => {
-      const v8CoveragesWithWebUrls = await page.coverage.stopJSCoverage()
-      // we convert urls starting with http:// to file:// because we later
-      // convert the url to filesystem path in istanbulCoverageFromV8Coverage function
-      const v8CoveragesWithFsUrls = v8CoveragesWithWebUrls.map(
-        (v8CoveragesWithWebUrl) => {
-          const relativeUrl = urlToRelativeUrl(
-            v8CoveragesWithWebUrl.url,
-            compileServerOrigin,
-          )
-          const fsUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-          return {
-            ...v8CoveragesWithWebUrl,
-            url: fsUrl,
-          }
-        },
-      )
-      const coverage = filterV8Coverage(
-        { result: v8CoveragesWithFsUrls },
-        {
-          coverageIgnorePredicate,
-        },
-      )
-      return {
-        ...result,
-        coverage,
-      }
-    })
-  } else {
-    transformResult = composeTransformer(transformResult, (result) => {
-      const { namespace: fileExecutionResultMap } = result
-      Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
-        delete fileExecutionResultMap[fileRelativeUrl].coverage
-      })
-      return result
-    })
-  }
-
-  const fileClientUrl = resolveUrl(fileRelativeUrl, `${compileServerOrigin}/`)
-  await page.goto(fileClientUrl, { timeout: 0 })
-
-  const executionResult = await page.evaluate(
-    /* istanbul ignore next */
-    () => {
-      // eslint-disable-next-line no-undef
-      return window.__jsenv__.executionResultPromise
-    },
-  )
-
-  const { fileExecutionResultMap } = executionResult
-  const fileErrored = Object.keys(fileExecutionResultMap).find(
-    (fileRelativeUrl) => {
-      const fileExecutionResult = fileExecutionResultMap[fileRelativeUrl]
-      return fileExecutionResult.status === "errored"
-    },
-  )
-
-  if (fileErrored) {
-    const { exceptionSource } = fileExecutionResultMap[fileErrored]
-    const error = evalException(exceptionSource, {
-      projectDirectoryUrl,
-      compileServerOrigin,
-      transformErrorHook,
-    })
-    return transformResult({
-      status: "errored",
-      error,
-      namespace: fileExecutionResultMap,
-    })
-  }
-
-  return transformResult({
-    status: "completed",
-    namespace: fileExecutionResultMap,
-  })
-}
-
-const executeCompiledVersion = async ({
-  projectDirectoryUrl,
-  compileServerOrigin,
-  fileRelativeUrl,
-  page,
-  jsenvDirectoryRelativeUrl,
-  compileId,
-  collectCoverage,
-  transformErrorHook,
-}) => {
-  let transformResult = (result) => result
-  if (collectCoverage) {
-    transformResult = composeTransformer(transformResult, async (result) => {
-      result.coverage = generateCoverageForPage(fileExecutionResultMap)
-      return result
-    })
-  } else {
-    transformResult = composeTransformer(transformResult, (result) => {
-      const { namespace: fileExecutionResultMap } = result
-      Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
-        delete fileExecutionResultMap[fileRelativeUrl].coverage
-      })
-      return result
-    })
-  }
-
-  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
-  const compileDirectoryRemoteUrl = resolveUrl(
-    compileDirectoryRelativeUrl,
-    compileServerOrigin,
-  )
-  const fileClientUrl = resolveUrl(fileRelativeUrl, compileDirectoryRemoteUrl)
-  await page.goto(fileClientUrl, { timeout: 0 })
-
-  const executionResult = await page.evaluate(
-    /* eslint-disable no-undef */
-    /* istanbul ignore next */
-    () => {
-      return window.__jsenv__.executionResultPromise
-    },
-    /* eslint-enable no-undef */
-  )
-
-  const { fileExecutionResultMap } = executionResult
-  const fileErrored = Object.keys(fileExecutionResultMap).find(
-    (fileRelativeUrl) => {
-      const fileExecutionResult = fileExecutionResultMap[fileRelativeUrl]
-      return fileExecutionResult.status === "errored"
-    },
-  )
-
-  if (fileErrored) {
-    const { exceptionSource } = fileExecutionResultMap[fileErrored]
-    const error = evalException(exceptionSource, {
-      projectDirectoryUrl,
-      compileServerOrigin,
-      transformErrorHook,
-    })
-    return transformResult({
-      status: "errored",
-      error,
-      namespace: fileExecutionResultMap,
-    })
-  }
-
-  return transformResult({
-    status: "completed",
-    namespace: fileExecutionResultMap,
-  })
-}
-
-const generateCoverageForPage = (fileExecutionResultMap) => {
-  let istanbulCoverageComposed = null
-  Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
-    const istanbulCoverage = fileExecutionResultMap[fileRelativeUrl].coverage
-    istanbulCoverageComposed = istanbulCoverageComposed
-      ? composeTwoFileByFileIstanbulCoverages(
-          istanbulCoverageComposed,
-          istanbulCoverage,
-        )
-      : istanbulCoverage
-  })
-
-  return istanbulCoverageComposed
-}
-
-const evalException = (
-  exceptionSource,
-  { projectDirectoryUrl, compileServerOrigin, transformErrorHook },
-) => {
-  let error = evalSource(exceptionSource)
-
-  if (error && error instanceof Error) {
-    const remoteRootRegexp = new RegExp(
-      escapeRegexpSpecialCharacters(`${compileServerOrigin}/`),
-      "g",
-    )
-    error.stack = error.stack.replace(remoteRootRegexp, projectDirectoryUrl)
-    error.message = error.message.replace(remoteRootRegexp, projectDirectoryUrl)
-
-    error = transformErrorHook(error)
-  }
-
-  return error
-}
-
-const composeTransformer = (previousTransformer, transformer) => {
-  return (value) => {
-    const transformedValue = previousTransformer(value)
-    return transformer(transformedValue)
-  }
-}

package/src/internal/browser_launcher/from_playwright.js

@@ -1,320 +0,0 @@
-// https://github.com/microsoft/playwright/blob/master/docs/api.md
-
-import { createDetailedMessage } from "@jsenv/logger"
-import {
-  Abort,
-  createCallbackListNotifiedOnce,
-  createCallbackList,
-  raceProcessTeardownEvents,
-} from "@jsenv/abort"
-import { memoize } from "@jsenv/filesystem"
-
-import { trackPageErrorsAndLogs } from "./page_errors_and_logs.js"
-import { executeHtmlFile } from "./execute_html_file.js"
-
-export const createRuntimeFromPlaywright = ({
-  browserName,
-  browserVersion,
-  coveragePlaywrightAPIAvailable = false,
-  ignoreErrorHook = () => false,
-  transformErrorHook = (error) => error,
-  tab = false,
-}) => {
-  const runtime = {
-    name: browserName,
-    version: browserVersion,
-  }
-
-  let browserAndContextPromise
-  runtime.launch = async ({
-    signal = new AbortController().signal,
-    executablePath,
-    browserServerLogLevel,
-
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileServerId,
-    jsenvDirectoryRelativeUrl,
-
-    collectPerformance,
-    measurePerformance,
-    collectCoverage,
-    coverageIgnorePredicate,
-    coverageForceIstanbul,
-
-    headless = true,
-    stopOnExit = true,
-    ignoreHTTPSErrors = true,
-    stopAfterAllExecutionCallbackList,
-    forceCompilation,
-  }) => {
-    const stopCallbackList = createCallbackListNotifiedOnce()
-    const stoppedCallbackList = createCallbackListNotifiedOnce()
-    const errorCallbackList = createCallbackList()
-    const outputCallbackList = createCallbackList()
-
-    const stop = memoize(async (reason) => {
-      await stopCallbackList.notify({ reason })
-      stoppedCallbackList.notify({ reason })
-      return { graceful: false }
-    })
-    const closeBrowser = async () => {
-      const { browser } = await browserAndContextPromise
-      browserAndContextPromise = null
-      await stopBrowser(browser)
-    }
-
-    if (
-      !browserAndContextPromise ||
-      !tab ||
-      !stopAfterAllExecutionCallbackList
-    ) {
-      browserAndContextPromise = (async () => {
-        const browser = await launchBrowserUsingPlaywright({
-          signal,
-          browserName,
-          stopOnExit,
-          playwrightOptions: {
-            headless,
-            executablePath,
-          },
-        })
-        const browserContext = await browser.newContext({ ignoreHTTPSErrors })
-        return { browser, browserContext }
-      })()
-
-      // when using chromium tab during multiple executions we reuse the chromium browser
-      // and only once all executions are done we close the browser
-      if (tab && stopAfterAllExecutionCallbackList) {
-        stopAfterAllExecutionCallbackList.add(async () => {
-          await closeBrowser()
-        })
-      } else {
-        stopCallbackList.add(async () => {
-          await closeBrowser()
-        })
-      }
-    }
-
-    const { browser, browserContext } = await browserAndContextPromise
-    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
-    browser.on("disconnected", () => {
-      stop()
-    })
-
-    const page = await browserContext.newPage()
-    stoppedCallbackList.add(async () => {
-      try {
-        await page.close()
-      } catch (e) {
-        if (isTargetClosedError(e)) {
-          return
-        }
-        throw e
-      }
-    })
-    const stopTrackingToNotify = trackPageErrorsAndLogs(page, {
-      onError: (error) => {
-        error = transformErrorHook(error)
-        if (!ignoreErrorHook(error)) {
-          errorCallbackList.notify(error)
-        }
-      },
-      onConsole: outputCallbackList.notify,
-    })
-    stoppedCallbackList.add(stopTrackingToNotify)
-
-    const execute = createExecuteHook({
-      page,
-      runtime,
-      browserServerLogLevel,
-
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileServerId,
-      jsenvDirectoryRelativeUrl,
-
-      collectPerformance,
-      measurePerformance,
-      collectCoverage,
-      coverageIgnorePredicate,
-      coverageForceIstanbul,
-
-      coveragePlaywrightAPIAvailable,
-      transformErrorHook,
-      forceCompilation,
-    })
-
-    return {
-      stopCallbackList,
-      stoppedCallbackList,
-      errorCallbackList,
-      outputCallbackList,
-      execute,
-      stop,
-    }
-  }
-  if (!tab) {
-    runtime.tab = createRuntimeFromPlaywright({
-      browserName,
-      browserVersion,
-      coveragePlaywrightAPIAvailable,
-      ignoreErrorHook,
-      transformErrorHook,
-      tab: true,
-    })
-  }
-  return runtime
-}
-
-const stopBrowser = async (browser) => {
-  const disconnected = browser.isConnected()
-    ? new Promise((resolve) => {
-        const disconnectedCallback = () => {
-          browser.removeListener("disconnected", disconnectedCallback)
-          resolve()
-        }
-        browser.on("disconnected", disconnectedCallback)
-      })
-    : Promise.resolve()
-
-  // for some reason without this 100ms timeout
-  // browser.close() never resolves (playwright does not like something)
-  await new Promise((resolve) => setTimeout(resolve, 100))
-
-  try {
-    await browser.close()
-  } catch (e) {
-    if (isTargetClosedError(e)) {
-      return
-    }
-    throw e
-  }
-  await disconnected
-}
-
-const launchBrowserUsingPlaywright = async ({
-  signal,
-  browserName,
-  stopOnExit,
-  playwrightOptions,
-}) => {
-  const launchBrowserOperation = Abort.startOperation()
-  launchBrowserOperation.addAbortSignal(signal)
-  const playwright = await importPlaywright({ browserName })
-  if (stopOnExit) {
-    launchBrowserOperation.addAbortSource((abort) => {
-      return raceProcessTeardownEvents(
-        {
-          SIGHUP: true,
-          SIGTERM: true,
-          SIGINT: true,
-          beforeExit: true,
-          exit: true,
-        },
-        abort,
-      )
-    })
-  }
-
-  const browserClass = playwright[browserName]
-  try {
-    const browser = await browserClass.launch({
-      ...playwrightOptions,
-      // let's handle them to close properly browser + remove listener
-      // instead of relying on playwright to do so
-      handleSIGINT: false,
-      handleSIGTERM: false,
-      handleSIGHUP: false,
-    })
-    launchBrowserOperation.throwIfAborted()
-    return browser
-  } catch (e) {
-    if (launchBrowserOperation.signal.aborted && isTargetClosedError(e)) {
-      // rethrow the abort error
-      launchBrowserOperation.throwIfAborted()
-    }
-    throw e
-  } finally {
-    await launchBrowserOperation.end()
-  }
-}
-
-const importPlaywright = async ({ browserName }) => {
-  try {
-    const namespace = await import("playwright")
-    return namespace
-  } catch (e) {
-    if (e.code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(
-        createDetailedMessage(
-          `"playwright" not found. You need playwright in your dependencies when using "${browserName}Runtime"`,
-          {
-            suggestion: `npm install --save-dev playwright`,
-          },
-        ),
-        { cause: e },
-      )
-    }
-    throw e
-  }
-}
-
-const createExecuteHook = ({
-  page,
-  runtime,
-  projectDirectoryUrl,
-  compileServerOrigin,
-  compileServerId,
-  jsenvDirectoryRelativeUrl,
-
-  collectPerformance,
-  measurePerformance,
-  collectCoverage,
-  coverageIgnorePredicate,
-  coverageForceIstanbul,
-
-  coveragePlaywrightAPIAvailable,
-  transformErrorHook,
-  forceCompilation,
-}) => {
-  const execute = async ({ signal, fileRelativeUrl }) => {
-    const executeOperation = Abort.startOperation()
-    executeOperation.addAbortSignal(signal)
-    executeOperation.throwIfAborted()
-    const result = await executeHtmlFile(fileRelativeUrl, {
-      runtime,
-      executeOperation,
-
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileServerId,
-      jsenvDirectoryRelativeUrl,
-
-      page,
-      measurePerformance,
-      collectPerformance,
-      collectCoverage,
-      coverageForceIstanbul,
-      coveragePlaywrightAPIAvailable,
-      coverageIgnorePredicate,
-      transformErrorHook,
-      forceCompilation,
-    })
-    return result
-  }
-  return execute
-}
-
-const isTargetClosedError = (error) => {
-  if (error.message.match(/Protocol error \(.*?\): Target closed/)) {
-    return true
-  }
-  if (error.message.match(/Protocol error \(.*?\): Browser.*?closed/)) {
-    return true
-  }
-  if (error.message.includes("browserContext.close: Browser closed")) {
-    return true
-  }
-  return false
-}