@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/building/html/minify_html.js

@@ -1,7 +0,0 @@
-import { require } from "@jsenv/core/src/internal/require.js"
-
-export const minifyHtml = (htmlString, options) => {
-  const { minify } = require("html-minifier")
-  const htmlMinified = minify(htmlString, options)
-  return htmlMinified
-}

package/src/internal/building/import_assertions/css_module.js

@@ -1,43 +0,0 @@
-import { resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
-
-import { escapeTemplateStringSpecialCharacters } from "@jsenv/core/src/internal/template_string_escape.js"
-import {
-  getCssSourceMappingUrl,
-  setCssSourceMappingUrl,
-} from "@jsenv/core/src/internal/sourcemap_utils.js"
-import { moveCssUrls } from "@jsenv/core/src/internal/building/css/move_css_urls.js"
-
-export const convertCssTextToJavascriptModule = async ({
-  cssUrl,
-  jsUrl,
-  code,
-  map,
-}) => {
-  const directoryUrl = resolveUrl("./", cssUrl)
-  const jsDirectoryUrl = resolveUrl("./", jsUrl)
-  if (directoryUrl !== jsDirectoryUrl) {
-    const moveUrlResult = await moveCssUrls({
-      from: cssUrl,
-      to: jsUrl,
-      code,
-      map,
-    })
-    code = moveUrlResult.code
-    map = moveUrlResult.map
-    const sourcemapUrlSpecifier = getCssSourceMappingUrl(code)
-    const sourcemapUrlForCss = resolveUrl(sourcemapUrlSpecifier, cssUrl)
-    const sourcemapUrlForJs = urlToRelativeUrl(sourcemapUrlForCss, jsUrl)
-    code = setCssSourceMappingUrl(code, sourcemapUrlForJs)
-  }
-
-  const cssTextEscaped = escapeTemplateStringSpecialCharacters(code)
-
-  return {
-    code: `
-const stylesheet = new CSSStyleSheet()
-
-stylesheet.replaceSync(\`${cssTextEscaped}\`)
-
-export default stylesheet`,
-  }
-}

package/src/internal/building/import_references.js

@@ -1,80 +0,0 @@
-export const visitImportReferences = async ({
-  ast,
-  onReferenceWithImportMetaUrlPattern,
-  onReferenceWithImportAssertion,
-}) => {
-  const { asyncWalk } = await import("estree-walker")
-  await asyncWalk(ast, {
-    enter: async (node, parent) => {
-      if (isNewUrlImportMetaUrl(node)) {
-        await onReferenceWithImportMetaUrlPattern({
-          importNode: node,
-        })
-        return
-      }
-
-      if (node.type === "ImportDeclaration") {
-        const { assertions = [] } = node
-        if (assertions.length === 0) {
-          return
-        }
-        const assertionsDescriptor = getImportAssertionsDescriptor(assertions)
-        await onReferenceWithImportAssertion({
-          importNode: node,
-          assertions: assertionsDescriptor,
-        })
-        return
-      }
-
-      if (
-        node.type === "ObjectExpression" &&
-        parent.type === "ImportExpression"
-      ) {
-        const { properties } = node
-        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
-        }
-
-        await onReferenceWithImportAssertion({
-          importNode: parent,
-          typePropertyNode,
-        })
-        return
-      }
-    },
-  })
-}
-
-const isNewUrlImportMetaUrl = (node) => {
-  return (
-    node.type === "NewExpression" &&
-    node.callee.type === "Identifier" &&
-    node.callee.name === "URL" &&
-    node.arguments.length === 2 &&
-    node.arguments[0].type === "Literal" &&
-    typeof node.arguments[0].value === "string" &&
-    node.arguments[1].type === "MemberExpression" &&
-    node.arguments[1].object.type === "MetaProperty" &&
-    node.arguments[1].property.type === "Identifier" &&
-    node.arguments[1].property.name === "url"
-  )
-}
-
-const getImportAssertionsDescriptor = (importAssertions) => {
-  const assertionAttributes = {}
-  importAssertions.forEach((importAssertion) => {
-    assertionAttributes[importAssertion.key.name] = importAssertion.value.value
-  })
-  return assertionAttributes
-}

package/src/internal/building/importmap/jsenv_parse_importmap.js

@@ -1,28 +0,0 @@
-export const parseImportmapRessource = (
-  importmapRessource,
-  notifiers,
-  { minify, importMapToInject },
-) => {
-  const importmapString = String(importmapRessource.bufferBeforeBuild)
-
-  return () => {
-    if (importMapToInject) {
-      const jsonText = minify
-        ? valueToCompactJsonString(importMapToInject)
-        : valueToReadableJsonString(importMapToInject)
-      importmapRessource.buildEnd(jsonText)
-      return
-    }
-
-    const jsonText = minify
-      ? valueToCompactJsonString(JSON.parse(importmapString))
-      : importmapString
-    importmapRessource.buildEnd(jsonText)
-  }
-}
-
-// removes eventual whitespace in json
-const valueToCompactJsonString = (json) => JSON.stringify(json)
-
-// prefer a readable json when minification is disabled
-const valueToReadableJsonString = (json) => JSON.stringify(json, null, "  ")

package/src/internal/building/js/babel_plugin_inline_worker_imports.js

@@ -1,96 +0,0 @@
-import {
-  resolveUrl,
-  fileSystemPathToUrl,
-  urlToFileSystemPath,
-} from "@jsenv/filesystem"
-
-export const babelPluginInlineWorkerImports = (
-  babel,
-  { readImportedScript },
-) => {
-  const { types } = babel
-
-  return {
-    name: "transform-inline-worker-imports",
-
-    visitor: {
-      CallExpression: (path, opts) => {
-        const calleePath = path.get("callee")
-
-        const replaceImportScriptsWithFileContents = () => {
-          const filename = opts.filename
-          const fileUrl = fileSystemPathToUrl(filename)
-
-          let previousArgType = ""
-          const importedUrls = path.get("arguments").map((arg, index) => {
-            if (!types.isStringLiteral(arg)) {
-              if (previousArgType && previousArgType !== "dynamic") {
-                throw new Error(
-                  `importScript mixed arguments: arg number ${index} is dynamic while previous arg was ${previousArgType}`,
-                )
-              }
-              previousArgType = "dynamic"
-              return arg
-            }
-            const importedUrl = resolveUrl(arg.node.value, fileUrl)
-            if (!importedUrl.startsWith("file://")) {
-              if (previousArgType && previousArgType !== "remote") {
-                throw new Error(
-                  `importScript mixed arguments: arg number ${index} targets a remote url while previous arg was ${previousArgType}`,
-                )
-              }
-              previousArgType = "remote"
-              return arg
-            }
-            previousArgType = "local"
-            return importedUrl
-          })
-
-          if (previousArgType === "local") {
-            const nodes = importedUrls.reduce((previous, importedUrl) => {
-              const importedScriptCode = readImportedScript(importedUrl)
-              const { ast } = babel.transformSync(importedScriptCode, {
-                filename: urlToFileSystemPath(importedUrl),
-                configFile: false,
-                babelrc: false, // trust only these options, do not read any babelrc config file
-                ast: true,
-                sourceMaps: true,
-                // sourceFileName: scriptPath,
-                plugins: [
-                  [
-                    babelPluginInlineWorkerImports,
-                    {
-                      readImportedScript,
-                    },
-                  ],
-                ],
-              })
-              return [...previous, ...ast.program.body]
-            }, [])
-
-            calleePath.parentPath.replaceWithMultiple(nodes)
-          }
-        }
-
-        if (types.isIdentifier(calleePath.node, { name: "importScripts" })) {
-          replaceImportScriptsWithFileContents()
-          return
-        }
-
-        if (types.isMemberExpression(calleePath.node)) {
-          const calleeObject = calleePath.get("object")
-          const isSelf = types.isIdentifier(calleeObject.node, { name: "self" })
-          if (isSelf) {
-            const propertyPath = calleePath.get("property")
-            if (
-              types.isIdentifier(propertyPath.node, { name: "importScripts" })
-            ) {
-              replaceImportScriptsWithFileContents()
-              return
-            }
-          }
-        }
-      },
-    },
-  }
-}

package/src/internal/building/js/jsenv_parse_js.js

@@ -1,122 +0,0 @@
-import { urlToFilename, resolveUrl, urlToRelativeUrl } from "@jsenv/filesystem"
-
-import {
-  generateSourcemapUrl,
-  getJavaScriptSourceMappingUrl,
-  setJavaScriptSourceMappingUrl,
-} from "@jsenv/core/src/internal/sourcemap_utils.js"
-
-import { transformWorker } from "./transform_worker.js"
-
-export const parseJsRessource = async (
-  jsRessource,
-  { notifyReferenceFound },
-  { asProjectUrl, asOriginalUrl, minify, minifyJs },
-) => {
-  const jsUrl = jsRessource.url
-  const jsString = String(jsRessource.bufferBeforeBuild)
-  const jsSourcemapUrl = getJavaScriptSourceMappingUrl(jsString)
-
-  let sourcemapReference
-  if (jsSourcemapUrl) {
-    sourcemapReference = notifyReferenceFound({
-      referenceLabel: "js sourcemapping comment",
-      contentTypeExpected: ["application/json", "application/octet-stream"],
-      ressourceSpecifier: jsSourcemapUrl,
-      // we don't really know the line or column
-      // but let's asusme it the last line and first column
-      referenceLine: jsString.split(/\r?\n/).length,
-      // ${"//#"} is to avoid a parser thinking there is a sourceMappingUrl for this file
-      referenceColumn: `${"//#"} sourceMappingURL=`.length + 1,
-      isSourcemap: true,
-    })
-  } else {
-    sourcemapReference = notifyReferenceFound({
-      referenceLabel: "js sourcemapping comment",
-      contentType: "application/octet-stream",
-      ressourceSpecifier: urlToRelativeUrl(generateSourcemapUrl(jsUrl), jsUrl),
-      isPlaceholder: true,
-      isSourcemap: true,
-    })
-  }
-
-  return async ({ buildDirectoryUrl }) => {
-    const sourcemapRessource = sourcemapReference.ressource
-    let code
-    let map
-    if (!sourcemapRessource.isPlaceholder) {
-      map = JSON.parse(String(sourcemapRessource.bufferBeforeBuild))
-    }
-
-    // in case this js asset is a worker, we transform it so that
-    // importScripts() calls are inlined
-    // We could also parse each importScripts call and decide to inline
-    // or not. For now inlining/concatenation is forced
-    if (jsRessource.isWorker || jsRessource.isServiceWorker) {
-      const transformResult = await transformWorker({
-        url: asOriginalUrl(jsUrl),
-        code: String(jsRessource.bufferBeforeBuild),
-        map,
-      })
-      code = transformResult.code
-      map = transformResult.map
-    } else {
-      code = jsString
-    }
-
-    const jsCompiledUrl = jsRessource.url
-    const jsOriginalUrl = asOriginalUrl(jsCompiledUrl)
-
-    if (minify) {
-      const result = await minifyJs({
-        url: map ? asProjectUrl(jsCompiledUrl) : jsOriginalUrl,
-        code,
-        map,
-        toplevel: false,
-      })
-      code = result.code
-      map = result.map
-    }
-    jsRessource.buildEnd(code)
-    if (!map) {
-      return
-    }
-    // In theory code should never be modified once buildEnd() is called
-    // because buildRelativeUrl might be versioned based on file content
-    // There is an exception for sourcemap because we want to update sourcemap.file
-    // to the cached filename of the js file.
-    // To achieve that we set/update the sourceMapping url comment in compiled js file.
-    // This is totally fine to do that because sourcemap and js file lives togethers
-    // so this comment changes nothing regarding cache invalidation and is not important
-    // to decide buildRelativeUrl for this js file.
-    const jsBuildUrl = resolveUrl(
-      jsRessource.buildRelativeUrl,
-      buildDirectoryUrl,
-    )
-    const sourcemapPrecomputedBuildUrl = generateSourcemapUrl(jsBuildUrl)
-    map.file = urlToFilename(jsBuildUrl)
-    if (map.sources) {
-      map.sources = map.sources.map((source) => {
-        const sourceUrl = resolveUrl(source, jsUrl)
-        const sourceOriginalUrl = asOriginalUrl(sourceUrl) || sourceUrl
-        const sourceUrlRelativeToSourceMap = urlToRelativeUrl(
-          sourceOriginalUrl,
-          sourcemapPrecomputedBuildUrl,
-        )
-        return sourceUrlRelativeToSourceMap
-      })
-    }
-    const mapAsText = JSON.stringify(map, null, "  ")
-    sourcemapRessource.buildEnd(mapAsText)
-    const sourcemapBuildUrl = resolveUrl(
-      sourcemapRessource.buildRelativeUrl,
-      buildDirectoryUrl,
-    )
-    const sourcemapUrlForJs = urlToRelativeUrl(sourcemapBuildUrl, jsBuildUrl)
-    const codeWithSourcemapComment = setJavaScriptSourceMappingUrl(
-      code,
-      sourcemapUrlForJs,
-    )
-    jsRessource.bufferAfterBuild = codeWithSourcemapComment
-  }
-}

package/src/internal/building/js/minify_js.js

@@ -1,33 +0,0 @@
-export const minifyJs = async ({
-  url,
-  code,
-  map,
-  sourcemapIncludeSources = true,
-  ...rest
-}) => {
-  // https://github.com/terser-js/terser#minify-options
-  const { minify } = await import("terser")
-
-  const terserResult = await minify(
-    {
-      [url]: code,
-    },
-    {
-      sourceMap: {
-        ...(map ? { content: JSON.stringify(map) } : {}),
-        asObject: true,
-        includeSources: sourcemapIncludeSources,
-      },
-      ...rest,
-    },
-  )
-
-  code = terserResult.code
-  map = terserResult.map
-
-  if (!map.sourcesContent) {
-    map.sourcesContent = [code]
-  }
-
-  return { code, map }
-}

package/src/internal/building/js/transform_worker.js

@@ -1,55 +0,0 @@
-// we could inline a worker by doing
-// var blob = new Blob(code, { type: 'text/javascript' })
-// window.URL.createObjectURL(blob)
-
-import { readFileSync } from "node:fs"
-import { urlToFileSystemPath } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { babelPluginInlineWorkerImports } from "./babel_plugin_inline_worker_imports.js"
-
-export const transformWorker = async ({ url, code, map }) => {
-  const { transformSync } = await import("@babel/core")
-
-  const transformResult = transformSync(code, {
-    filename: urlToFileSystemPath(url),
-    configFile: false,
-    babelrc: false, // trust only these options, do not read any babelrc config file
-    ast: false,
-    inputSourceMap: map,
-    sourceMaps: true,
-    // sourceFileName: scriptPath,
-    plugins: [
-      [
-        babelPluginInlineWorkerImports,
-        {
-          readImportedScript: readWorkerFile,
-        },
-      ],
-    ],
-  })
-  code = transformResult.code
-  map = transformResult.map
-  return { code, map }
-}
-
-export const readWorkerFile = (url, importerUrl) => {
-  const filePath = urlToFileSystemPath(url)
-  try {
-    const code = String(readFileSync(filePath))
-    return code
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      if (importerUrl) {
-        throw new Error(
-          createDetailedMessage(`no file found for an import in a worker.`, {
-            ["worker url"]: importerUrl,
-            ["imported url"]: url,
-          }),
-        )
-      }
-      throw new Error(`no worker file at ${url}`)
-    }
-    throw e
-  }
-}

package/src/internal/building/json/jsenv_parse_json.js

@@ -1,11 +0,0 @@
-export const parseJsonRessource = (jsonRessource, notifiers, { minify }) => {
-  const jsonString = String(jsonRessource.bufferBeforeBuild)
-  return () => {
-    if (minify) {
-      // this is to remove eventual whitespaces
-      jsonRessource.buildEnd(JSON.stringify(JSON.parse(jsonString)))
-      return
-    }
-    jsonRessource.buildEnd(jsonString)
-  }
-}

package/src/internal/building/parse_ressource.js

@@ -1,207 +0,0 @@
-import { readFile, urlToRelativeUrl } from "@jsenv/filesystem"
-
-import {
-  jsenvSystemJsFileInfo,
-  jsenvResolveImportUrlHelper,
-} from "@jsenv/core/src/jsenv_file_urls.js"
-import {
-  parseHtmlString,
-  findHtmlNode,
-  htmlNodeIsScriptModule,
-  getHtmlNodeAttributeByName,
-  getHtmlNodeTextNode,
-  manipulateHtmlAst,
-  findFirstImportMapNode,
-} from "@jsenv/core/src/internal/compile_server/html/html_ast.js"
-
-import { parseHtmlRessource } from "./html/jsenv_parse_html.js"
-import { parseImportmapRessource } from "./importmap/jsenv_parse_importmap.js"
-import { parseSvgRessource } from "./svg/jsenv_parse_svg.js"
-import { parseCssRessource } from "./css/jsenv_parse_css.js"
-import { parseJsRessource } from "./js/jsenv_parse_js.js"
-import { parseJsonRessource } from "./json/jsenv_parse_json.js"
-import { parseWebmanifestRessource } from "./webmanifest/jsenv_parse_webmanifest.js"
-
-export const parseRessource = async (
-  ressource,
-  notifiers,
-  {
-    projectDirectoryUrl,
-    jsenvRemoteDirectory,
-    format,
-    systemJsUrl,
-    asProjectUrl,
-    asOriginalUrl,
-    asOriginalServerUrl,
-    ressourceHintNeverUsedCallback,
-    useImportMapToMaximizeCacheReuse,
-    createImportMapForFilesUsedInJs,
-    minify,
-    minifyJs,
-    minifyHtml,
-    minifyCssOptions,
-    cssConcatenation,
-  },
-) => {
-  const { contentType } = ressource
-  if (!contentType) {
-    return null
-  }
-
-  if (contentType === "text/html") {
-    return parseHtmlRessource(ressource, notifiers, {
-      minify,
-      minifyHtml,
-      htmlStringToHtmlAst: async (htmlString) => {
-        const htmlAst = parseHtmlString(htmlString)
-
-        const { hasModuleScript, hasInlineModuleScript } =
-          getHtmlModuleScriptInfo(htmlAst)
-
-        if (hasModuleScript && format === "systemjs") {
-          // force presence of systemjs script if html contains a module script
-          // use our own version of systemjs by default
-          if (typeof systemJsUrl === "undefined") {
-            systemJsUrl = `/${urlToRelativeUrl(
-              jsenvSystemJsFileInfo.url,
-              projectDirectoryUrl,
-            )}`
-          }
-
-          manipulateHtmlAst(htmlAst, {
-            scriptInjections: [
-              {
-                id: "jsenv_inject_systemjs",
-                src: systemJsUrl,
-                ...(hasInlineModuleScript
-                  ? { "data-jsenv-force-inline": true }
-                  : {}),
-              },
-            ],
-          })
-        }
-
-        if (useImportMapToMaximizeCacheReuse) {
-          if (hasModuleScript && format === "esmodule") {
-            // inject an inline script helper to resolve url
-            manipulateHtmlAst(htmlAst, {
-              scriptInjections: [
-                {
-                  id: "jsenv_import_url_resolution_helper",
-                  text: await readFile(jsenvResolveImportUrlHelper.url),
-                },
-              ],
-            })
-          }
-
-          if (!findFirstImportMapNode(htmlAst)) {
-            // force the presence of a fake+inline+empty importmap script
-            // if html contains no importmap and we useImportMapToMaximizeCacheReuse
-            // this inline importmap will be transformed later to have top level remapping
-            // required to target hashed js urls
-            manipulateHtmlAst(htmlAst, {
-              scriptInjections: [
-                {
-                  type: "importmap",
-                  id: "jsenv_inject_importmap",
-                  text: "{}",
-                },
-              ],
-            })
-          }
-        }
-
-        return htmlAst
-      },
-      ressourceHintNeverUsedCallback: (info) => {
-        ressourceHintNeverUsedCallback({
-          ...info,
-          htmlSource: String(ressource.bufferBeforeBuild),
-          htmlUrl: asOriginalUrl(ressource.url),
-          htmlAttributeName: "href",
-        })
-      },
-    })
-  }
-
-  if (contentType === "text/css") {
-    return parseCssRessource(ressource, notifiers, {
-      jsenvRemoteDirectory,
-      asProjectUrl,
-      asOriginalUrl,
-      asOriginalServerUrl,
-      minify,
-      minifyCssOptions,
-      cssConcatenation,
-    })
-  }
-
-  if (contentType === "application/importmap+json") {
-    return parseImportmapRessource(ressource, notifiers, {
-      minify,
-      importMapToInject: useImportMapToMaximizeCacheReuse
-        ? createImportMapForFilesUsedInJs()
-        : undefined,
-    })
-  }
-
-  if (
-    contentType === "application/manifest+json" ||
-    ressource.references[0].contentTypeExpected === "application/manifest+json"
-  ) {
-    return parseWebmanifestRessource(ressource, notifiers, { minify })
-  }
-
-  if (
-    contentType === "application/javascript" ||
-    contentType === "text/javascript"
-  ) {
-    return parseJsRessource(ressource, notifiers, {
-      projectDirectoryUrl,
-      jsenvRemoteDirectory,
-      asProjectUrl,
-      asOriginalUrl,
-      asOriginalServerUrl,
-      minify,
-      minifyJs,
-    })
-  }
-
-  if (contentType === "image/svg+xml") {
-    return parseSvgRessource(ressource, notifiers, {
-      minify,
-      minifyHtml,
-    })
-  }
-
-  if (contentType === "application/json" || contentType.endsWith("+json")) {
-    return parseJsonRessource(ressource, notifiers, { minify })
-  }
-
-  return null
-}
-
-const getHtmlModuleScriptInfo = (htmlAst) => {
-  let hasModuleScript = false
-  let hasInlineModuleScript = false
-  findHtmlNode(htmlAst, (htmlNode) => {
-    const isScriptModule = htmlNodeIsScriptModule(htmlNode)
-    if (!isScriptModule) {
-      return false
-    }
-
-    hasModuleScript = true
-
-    const isInline =
-      getHtmlNodeAttributeByName(htmlNode, "data-jsenv-force-inline") ||
-      (!getHtmlNodeAttributeByName(htmlNode, "src") &&
-        getHtmlNodeTextNode(htmlNode))
-    if (!isInline) {
-      return false
-    }
-    hasInlineModuleScript = true
-    return true
-  })
-
-  return { hasModuleScript, hasInlineModuleScript }
-}