@jsenv/core 23.7.1 → 23.8.0

package/src/internal/browser-launcher/jsenv-browser-system.js

@@ -1,199 +1,199 @@
-/* eslint-env browser */
-
-import { unevalException } from "../unevalException.js"
-import { createBrowserRuntime } from "../runtime/createBrowserRuntime/createBrowserRuntime.js"
-import { installBrowserErrorStackRemapping } from "../error-stack-remapping/installBrowserErrorStackRemapping.js"
-import { fetchUrl } from "../browser-utils/fetch-browser.js"
-import { fetchAndEvalUsingFetch } from "../browser-utils/fetchAndEvalUsingFetch.js"
-import { memoize } from "../memoize.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,
-      }
-      return executionResult
-    } catch (e) {
-      performance.measure(`jsenv_file_import`, `jsenv_file_import_start`)
-      const executionResult = {
-        status: "errored",
-        exceptionSource: unevalException(e),
-      }
-      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 }) => {
-  // eslint-disable-next-line no-eval
-  const originalError = window.eval(executionResult.exceptionSource)
-  if (originalError.code === "NETWORK_FAILURE") {
-    if (currentScript) {
-      const errorEvent = new Event("error")
-      currentScript.dispatchEvent(errorEvent)
-    }
-  } else {
-    const { parsingError } = originalError
-    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 = originalError.filename
-      globalErrorEvent.lineno = originalError.lineno
-      globalErrorEvent.message = originalError.message
-      globalErrorEvent.colno = originalError.columnno
-    }
-    window.dispatchEvent(globalErrorEvent)
-  }
-}
-
-const getBrowserRuntime = memoize(async () => {
-  const compileServerOrigin = document.location.origin
-  const compileMetaResponse = await fetchUrl(
-    `${compileServerOrigin}/.jsenv/__compile_server_meta__.json`,
-  )
-  const compileMeta = await compileMetaResponse.json()
-  const { outDirectoryRelativeUrl, errorStackRemapping } = compileMeta
-  const outDirectoryUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
-  const afterOutDirectory = document.location.href.slice(outDirectoryUrl.length)
-  const parts = afterOutDirectory.split("/")
-  const compileId = parts[0]
-
-  const browserRuntime = await createBrowserRuntime({
-    compileServerOrigin,
-    outDirectoryRelativeUrl,
-    compileId,
-  })
-
-  if (errorStackRemapping && Error.captureStackTrace) {
-    const { sourcemapMainFileRelativeUrl, sourcemapMappingFileRelativeUrl } =
-      compileMeta
-
-    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 = {}
-
-window.__jsenv__ = {
-  livereloadingCallbacks,
-  executionResultPromise,
-  executeFileUsingDynamicImport,
-  executeFileUsingSystemJs,
-}
+/* eslint-env browser */
+
+import { unevalException } from "../unevalException.js"
+import { createBrowserRuntime } from "../runtime/createBrowserRuntime/createBrowserRuntime.js"
+import { installBrowserErrorStackRemapping } from "../error-stack-remapping/installBrowserErrorStackRemapping.js"
+import { fetchUrl } from "../browser-utils/fetch-browser.js"
+import { fetchAndEvalUsingFetch } from "../browser-utils/fetchAndEvalUsingFetch.js"
+import { memoize } from "../memoize.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,
+      }
+      return executionResult
+    } catch (e) {
+      performance.measure(`jsenv_file_import`, `jsenv_file_import_start`)
+      const executionResult = {
+        status: "errored",
+        exceptionSource: unevalException(e),
+      }
+      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 }) => {
+  // eslint-disable-next-line no-eval
+  const originalError = window.eval(executionResult.exceptionSource)
+  if (originalError.code === "NETWORK_FAILURE") {
+    if (currentScript) {
+      const errorEvent = new Event("error")
+      currentScript.dispatchEvent(errorEvent)
+    }
+  } else {
+    const { parsingError } = originalError
+    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 = originalError.filename
+      globalErrorEvent.lineno = originalError.lineno
+      globalErrorEvent.message = originalError.message
+      globalErrorEvent.colno = originalError.columnno
+    }
+    window.dispatchEvent(globalErrorEvent)
+  }
+}
+
+const getBrowserRuntime = memoize(async () => {
+  const compileServerOrigin = document.location.origin
+  const compileMetaResponse = await fetchUrl(
+    `${compileServerOrigin}/.jsenv/__compile_server_meta__.json`,
+  )
+  const compileMeta = await compileMetaResponse.json()
+  const { outDirectoryRelativeUrl, errorStackRemapping } = compileMeta
+  const outDirectoryUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
+  const afterOutDirectory = document.location.href.slice(outDirectoryUrl.length)
+  const parts = afterOutDirectory.split("/")
+  const compileId = parts[0]
+
+  const browserRuntime = await createBrowserRuntime({
+    compileServerOrigin,
+    outDirectoryRelativeUrl,
+    compileId,
+  })
+
+  if (errorStackRemapping && Error.captureStackTrace) {
+    const { sourcemapMainFileRelativeUrl, sourcemapMappingFileRelativeUrl } =
+      compileMeta
+
+    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 = {}
+
+window.__jsenv__ = {
+  livereloadingCallbacks,
+  executionResultPromise,
+  executeFileUsingDynamicImport,
+  executeFileUsingSystemJs,
+}

package/src/internal/compiling/babel_plugin_import_assertions.js

@@ -1,100 +1,121 @@
-import { urlToRelativeUrl } from "@jsenv/filesystem"
-
-import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
-import { babelPluginTransformImportSpecifier } from "./babel_plugin_transform_import_specifier.js"
-
-export const babelPluginImportAssertions = (
-  babel,
-  { transformJson = true, transformCss = true },
-) => {
-  return {
-    ...babelPluginTransformImportSpecifier(babel, {
-      // During the build we throw when for import call expression where
-      // sepcifier or type is dynamic.
-      // Here there is no strong need to throw because keeping the source code intact
-      // will throw an error when browser will execute the code
-      transformImportSpecifier: ({ specifier, path }) => {
-        const importPath = path.parentPath
-        const importNode = importPath.node
-        let assertionsDescriptor
-        if (importNode.type === "CallExpression") {
-          const args = importNode.arguments
-          const secondArg = args[1]
-          if (!secondArg) {
-            return specifier
-          }
-
-          const { properties } = secondArg
-          const assertProperty = properties.find((property) => {
-            return property.key.name === "assert"
-          })
-          if (!assertProperty) {
-            return specifier
-          }
-
-          const assertProperties = assertProperty.value.properties
-          const typePropertyNode = assertProperties.find((property) => {
-            return property.key.name === "type"
-          })
-          if (!typePropertyNode) {
-            return specifier
-          }
-
-          const typePropertyValue = typePropertyNode.value
-          if (typePropertyValue.type !== "StringLiteral") {
-            return specifier
-          }
-
-          assertionsDescriptor = {
-            type: typePropertyValue.value,
-          }
-        } else {
-          assertionsDescriptor = getImportAssertionsDescriptor(
-            importPath.node.assertions,
-          )
-        }
-
-        const { type } = assertionsDescriptor
-        if (type === "json" && transformJson) {
-          return forceImportTypeOnSpecifier(specifier, "json")
-        }
-
-        if (type === "css" && transformCss) {
-          return forceImportTypeOnSpecifier(specifier, "css")
-        }
-
-        return specifier
-      },
-    }),
-
-    name: "transform-import-assertions",
-  }
-}
-
-const getImportAssertionsDescriptor = (importAssertions) => {
-  const importAssertionsDescriptor = {}
-  if (importAssertions) {
-    importAssertions.forEach((importAssertion) => {
-      importAssertionsDescriptor[importAssertion.key.name] =
-        importAssertion.value.value
-    })
-  }
-  return importAssertionsDescriptor
-}
-
-const forceImportTypeOnSpecifier = (specifier, importType) => {
-  const fakeOrigin = "http://jsenv.com"
-  const url = new URL(specifier, fakeOrigin)
-  const urlWithImportType = setUrlSearchParamsDescriptor(url, {
-    import_type: importType,
-  })
-  if (urlWithImportType.startsWith(fakeOrigin)) {
-    // specifier was relative
-    const specifierWithImportType = urlToRelativeUrl(
-      urlWithImportType,
-      fakeOrigin,
-    )
-    return `./${specifierWithImportType}`
-  }
-  return urlWithImportType
-}
+import { urlToRelativeUrl } from "@jsenv/filesystem"
+
+import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
+import { babelPluginImportVisitor } from "./babel_plugin_import_visitor.js"
+
+export const babelPluginImportAssertions = (
+  babel,
+  { transformJson = true, transformCss = true },
+) => {
+  return {
+    ...babelPluginImportVisitor(
+      babel,
+      // During the build we throw when for import call expression where
+      // sepcifier or type is dynamic.
+      // Here there is no strong need to throw because keeping the source code intact
+      // will throw an error when browser will execute the code
+      ({ importPath, specifierPath }) => {
+        const importNode = importPath.node
+        let assertionsDescriptor
+        if (importNode.type === "CallExpression") {
+          const args = importNode.arguments
+          const secondArg = args[1]
+          if (!secondArg) {
+            return
+          }
+
+          const { properties } = secondArg
+          const assertProperty = properties.find((property) => {
+            return property.key.name === "assert"
+          })
+          if (!assertProperty) {
+            return
+          }
+
+          const assertProperties = assertProperty.value.properties
+          const typePropertyNode = assertProperties.find((property) => {
+            return property.key.name === "type"
+          })
+          if (!typePropertyNode) {
+            return
+          }
+
+          const typePropertyValue = typePropertyNode.value
+          if (typePropertyValue.type !== "StringLiteral") {
+            return
+          }
+
+          assertionsDescriptor = {
+            type: typePropertyValue.value,
+          }
+        } else {
+          assertionsDescriptor = getImportAssertionsDescriptor(
+            importPath.node.assertions,
+          )
+        }
+
+        const { type } = assertionsDescriptor
+        if (type === "json" && transformJson) {
+          forceImportTypeOnSpecifier({
+            specifierPath,
+            babel,
+            importType: "json",
+          })
+          return
+        }
+
+        if (type === "css" && transformCss) {
+          forceImportTypeOnSpecifier({
+            specifierPath,
+            babel,
+            importType: "css",
+          })
+          return
+        }
+      },
+    ),
+    name: "transform-import-assertions",
+  }
+}
+
+const getImportAssertionsDescriptor = (importAssertions) => {
+  const importAssertionsDescriptor = {}
+  if (importAssertions) {
+    importAssertions.forEach((importAssertion) => {
+      importAssertionsDescriptor[importAssertion.key.name] =
+        importAssertion.value.value
+    })
+  }
+  return importAssertionsDescriptor
+}
+
+const forceImportTypeOnSpecifier = ({ specifierPath, babel, importType }) => {
+  const specifier = specifierPath.node.value
+  const fakeOrigin = "http://jsenv.com"
+  const url = new URL(specifier, fakeOrigin)
+  const urlWithImportType = setUrlSearchParamsDescriptor(url, {
+    import_type: importType,
+  })
+  if (urlWithImportType.startsWith(fakeOrigin)) {
+    // specifier was relative
+    const specifierWithImportType = urlToRelativeUrl(
+      urlWithImportType,
+      fakeOrigin,
+    )
+
+    replaceSpecifierUsingBabel(`./${specifierWithImportType}`, {
+      specifierPath,
+      babel,
+    })
+    return
+  }
+
+  replaceSpecifierUsingBabel(urlWithImportType, {
+    specifierPath,
+    babel,
+  })
+}
+
+const replaceSpecifierUsingBabel = (value, { specifierPath, babel }) => {
+  specifierPath.replaceWith(babel.types.stringLiteral(value))
+}

package/src/internal/compiling/babel_plugin_import_metadata.js

@@ -0,0 +1,22 @@
+import { babelPluginImportVisitor } from "./babel_plugin_import_visitor.js"
+
+export const babelPluginImportMetadata = (babel) => {
+  return {
+    ...babelPluginImportVisitor(
+      babel,
+      // During the build we throw when for import call expression where
+      // sepcifier or type is dynamic.
+      // Here there is no strong need to throw because keeping the source code intact
+      // will throw an error when browser will execute the code
+      ({ state, specifierPath }) => {
+        const { metadata } = state.file
+
+        metadata.dependencies = [
+          ...(metadata.dependencies ? metadata.dependencies : []),
+          specifierPath.node.value,
+        ]
+      },
+    ),
+    name: "import-metadata",
+  }
+}