@jsenv/core 25.6.2 → 27.0.0-alpha.0

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 { trackPageToNotify } from "./trackPageToNotify.js"
-import { executeHtmlFile } from "./executeHtmlFile.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 = trackPageToNotify(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
-}

package/src/internal/browser_launcher/trackPageToNotify.js

@@ -1,77 +0,0 @@
-export const trackPageToNotify = (page, { onError, onConsole }) => {
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-error
-  const removeErrorListener = registerEvent({
-    object: page,
-    eventType: "error",
-    callback: onError,
-  })
-
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-pageerror
-  const removePageErrorListener = registerEvent({
-    object: page,
-    eventType: "pageerror",
-    callback: onError,
-  })
-
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console
-  const removeConsoleListener = registerEvent({
-    object: page,
-    eventType: "console",
-    // https://github.com/microsoft/playwright/blob/master/docs/api.md#event-console
-    callback: async (consoleMessage) => {
-      onConsole({
-        type: consoleMessage.type(),
-        text: appendNewLine(extractTextFromConsoleMessage(consoleMessage)),
-      })
-    },
-  })
-
-  return () => {
-    removeErrorListener()
-    removePageErrorListener()
-    removeConsoleListener()
-  }
-}
-
-const appendNewLine = (string) => `${string}
-`
-
-const extractTextFromConsoleMessage = (consoleMessage) => {
-  return consoleMessage.text()
-  // ensure we use a string so that istanbul won't try
-  // to put any coverage statement inside it
-  // ideally we should use uneval no ?
-  // eslint-disable-next-line no-new-func
-  //   const functionEvaluatedBrowserSide = new Function(
-  //     "value",
-  //     `if (value instanceof Error) {
-  //   return value.stack
-  // }
-  // return value`,
-  //   )
-  //   const argValues = await Promise.all(
-  //     message.args().map(async (arg) => {
-  //       const jsHandle = arg
-  //       try {
-  //         return await jsHandle.executionContext().evaluate(functionEvaluatedBrowserSide, jsHandle)
-  //       } catch (e) {
-  //         return String(jsHandle)
-  //       }
-  //     }),
-  //   )
-  //   const text = argValues.reduce((previous, value, index) => {
-  //     let string
-  //     if (typeof value === "object") string = JSON.stringify(value, null, "  ")
-  //     else string = String(value)
-  //     if (index === 0) return `${previous}${string}`
-  //     return `${previous} ${string}`
-  //   }, "")
-  //   return text
-}
-
-const registerEvent = ({ object, eventType, callback }) => {
-  object.on(eventType, callback)
-  return () => {
-    object.removeListener(eventType, callback)
-  }
-}

package/src/internal/browser_runtime/browser_runtime.js

@@ -1,224 +0,0 @@
-/* eslint-env browser */
-
-import { installBrowserErrorStackRemapping } from "../error-stack-remapping/installBrowserErrorStackRemapping.js"
-import { fetchUrl } from "../browser_utils/fetch_browser.js"
-import { fetchAndEvalUsingFetch } from "../browser_utils/fetchAndEvalUsingFetch.js"
-import { unevalException } from "../unevalException.js"
-import { memoize } from "../memoize.js"
-
-import { displayErrorInDocument } from "./displayErrorInDocument.js"
-import { displayErrorNotification } from "./displayErrorNotification.js"
-import { createBrowserRuntime } from "./createBrowserRuntime.js"
-
-const getNavigationStartTime = () => {
-  try {
-    return window.performance.timing.navigationStart
-  } catch (e) {
-    return Date.now()
-  }
-}
-
-const navigationStartTime = getNavigationStartTime()
-
-const readyPromise = new Promise((resolve) => {
-  if (document.readyState === "complete") {
-    resolve()
-  } else {
-    const loadCallback = () => {
-      window.removeEventListener("load", loadCallback)
-      resolve()
-    }
-    window.addEventListener("load", loadCallback)
-  }
-})
-
-const fileExecutionMap = {}
-
-const executionResultPromise = readyPromise.then(async () => {
-  const fileExecutionResultMap = {}
-  const fileExecutionResultPromises = []
-  let status = "completed"
-  let exceptionSource = ""
-  Object.keys(fileExecutionMap).forEach((key) => {
-    fileExecutionResultMap[key] = null // to get always same order for Object.keys(executionResult)
-    const fileExecutionResultPromise = fileExecutionMap[key]
-    fileExecutionResultPromises.push(fileExecutionResultPromise)
-    fileExecutionResultPromise.then((fileExecutionResult) => {
-      fileExecutionResultMap[key] = fileExecutionResult
-      if (fileExecutionResult.status === "errored") {
-        status = "errored"
-        exceptionSource = fileExecutionResult.exceptionSource
-      }
-    })
-  })
-  await Promise.all(fileExecutionResultPromises)
-
-  return {
-    status,
-    ...(status === "errored" ? { exceptionSource } : {}),
-    startTime: navigationStartTime,
-    endTime: Date.now(),
-    fileExecutionResultMap,
-  }
-})
-
-const executeFileUsingDynamicImport = async (
-  specifier,
-  identifier = specifier,
-) => {
-  const { currentScript } = document
-  const fileExecutionResultPromise = (async () => {
-    try {
-      const url = new URL(specifier, document.location.href).href
-      performance.mark(`jsenv_file_import_start`)
-      const namespace = await import(url)
-      performance.measure(`jsenv_file_import`, `jsenv_file_import_start`)
-      const executionResult = {
-        status: "completed",
-        namespace,
-        coverage: readCoverage(),
-      }
-      return executionResult
-    } catch (e) {
-      performance.measure(`jsenv_file_import`, `jsenv_file_import_start`)
-      const executionResult = {
-        status: "errored",
-        error: e,
-        coverage: readCoverage(),
-      }
-      onExecutionError(executionResult, { currentScript })
-      return executionResult
-    }
-  })()
-  fileExecutionMap[identifier] = fileExecutionResultPromise
-  return fileExecutionResultPromise
-}
-
-const executeFileUsingSystemJs = (specifier) => {
-  // si on a déja importer ce fichier ??
-  // if (specifier in fileExecutionMap) {
-
-  // }
-
-  const { currentScript } = document
-
-  const fileExecutionResultPromise = (async () => {
-    const browserRuntime = await getBrowserRuntime()
-    const executionResult = await browserRuntime.executeFile(specifier, {
-      measurePerformance: true,
-      collectPerformance: true,
-    })
-    if (executionResult.status === "errored") {
-      onExecutionError(executionResult, { currentScript })
-    }
-    return executionResult
-  })()
-  fileExecutionMap[specifier] = fileExecutionResultPromise
-  return fileExecutionResultPromise
-}
-
-const onExecutionError = (
-  executionResult,
-  {
-    currentScript,
-    errorExposureInConsole = true,
-    errorExposureInNotification = false,
-    errorExposureInDocument = true,
-  },
-) => {
-  const error = executionResult.error
-  if (error && error.code === "NETWORK_FAILURE") {
-    if (currentScript) {
-      const errorEvent = new Event("error")
-      currentScript.dispatchEvent(errorEvent)
-    }
-  } else if (typeof error === "object") {
-    const { parsingError } = error
-    const globalErrorEvent = new Event("error")
-    if (parsingError) {
-      globalErrorEvent.filename = parsingError.filename
-      globalErrorEvent.lineno = parsingError.lineNumber
-      globalErrorEvent.message = parsingError.message
-      globalErrorEvent.colno = parsingError.columnNumber
-    } else {
-      globalErrorEvent.filename = error.filename
-      globalErrorEvent.lineno = error.lineno
-      globalErrorEvent.message = error.message
-      globalErrorEvent.colno = error.columnno
-    }
-    window.dispatchEvent(globalErrorEvent)
-  }
-
-  if (errorExposureInConsole) {
-    console.error(error)
-  }
-  if (errorExposureInNotification) {
-    displayErrorNotification(error)
-  }
-  if (errorExposureInDocument) {
-    displayErrorInDocument(error)
-  }
-
-  executionResult.exceptionSource = unevalException(error)
-  delete executionResult.error
-}
-
-const getBrowserRuntime = memoize(async () => {
-  const compileServerOrigin = document.location.origin
-  const compileServerResponse = await fetchUrl(
-    `${compileServerOrigin}/__jsenv_compile_profile__`,
-  )
-  const compileServerMeta = await compileServerResponse.json()
-  const { jsenvDirectoryRelativeUrl, errorStackRemapping } = compileServerMeta
-  const jsenvDirectoryServerUrl = `${compileServerOrigin}/${jsenvDirectoryRelativeUrl}`
-  const afterJsenvDirectory = document.location.href.slice(
-    jsenvDirectoryServerUrl.length,
-  )
-  const parts = afterJsenvDirectory.split("/")
-  const compileId = parts[0]
-
-  const browserRuntime = await createBrowserRuntime({
-    compileServerOrigin,
-    jsenvDirectoryRelativeUrl,
-    compileId,
-  })
-
-  if (errorStackRemapping && Error.captureStackTrace) {
-    const { sourcemapMainFileRelativeUrl, sourcemapMappingFileRelativeUrl } =
-      compileServerMeta
-    await fetchAndEvalUsingFetch(
-      `${compileServerOrigin}/${sourcemapMainFileRelativeUrl}`,
-    )
-    const { SourceMapConsumer } = window.sourceMap
-    SourceMapConsumer.initialize({
-      "lib/mappings.wasm": `${compileServerOrigin}/${sourcemapMappingFileRelativeUrl}`,
-    })
-    const { getErrorOriginalStackString } = installBrowserErrorStackRemapping({
-      SourceMapConsumer,
-    })
-    const errorTransform = async (error) => {
-      // code can throw something else than an error
-      // in that case return it unchanged
-      if (!error || !(error instanceof Error)) return error
-      const originalStack = await getErrorOriginalStackString(error)
-      error.stack = originalStack
-      return error
-    }
-    const executeFile = browserRuntime.executeFile
-    browserRuntime.executeFile = (file, options = {}) => {
-      return executeFile(file, { errorTransform, ...options })
-    }
-  }
-  return browserRuntime
-})
-
-const livereloadingCallbacks = {}
-
-const readCoverage = () => window.__coverage__
-
-window.__jsenv__ = {
-  livereloadingCallbacks,
-  executionResultPromise,
-  executeFileUsingDynamicImport,
-  executeFileUsingSystemJs,
-}