@jsenv/core 27.0.0-alpha.4 → 27.0.0-alpha.40

package/src/plugins/inline/jsenv_plugin_js_inline_content.js

@@ -0,0 +1,296 @@
+import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+import { createMagicSource } from "@jsenv/utils/sourcemap/magic_source.js"
+import { JS_QUOTES } from "@jsenv/utils/string/js_quotes.js"
+import { applyBabelPlugins } from "@jsenv/utils/js_ast/apply_babel_plugins.js"
+import { generateInlineContentUrl } from "@jsenv/utils/urls/inline_content_url_generator.js"
+
+export const jsenvPluginJsInlineContent = ({ allowEscapeForVersioning }) => {
+  const parseAndTransformInlineContentCalls = async (urlInfo, context) => {
+    const inlineContentInfos = await parseJsInlineContentInfos({
+      js: urlInfo.content,
+      url: (urlInfo.data && urlInfo.data.rawUrl) || urlInfo.url,
+      isJsModule: urlInfo.type === "js_module",
+    })
+    if (inlineContentInfos.length === 0) {
+      return null
+    }
+    const magicSource = createMagicSource(urlInfo.content)
+    await inlineContentInfos.reduce(async (previous, inlineContentInfo) => {
+      await previous
+      const inlineUrl = generateInlineContentUrl({
+        url: urlInfo.url,
+        extension: CONTENT_TYPE.asFileExtension(inlineContentInfo.contentType),
+        line: inlineContentInfo.line,
+        column: inlineContentInfo.column,
+        lineEnd: inlineContentInfo.lineEnd,
+        columnEnd: inlineContentInfo.columnEnd,
+      })
+      let { quote } = inlineContentInfo
+      if (
+        quote === "`" &&
+        !context.isSupportedOnCurrentClients("template_literals")
+      ) {
+        // if quote is "`" and template literals are not supported
+        // we'll use a regular string (single or double quote)
+        // when rendering the string
+        quote = JS_QUOTES.pickBest(inlineContentInfo.content)
+      }
+      const [inlineReference, inlineUrlInfo] =
+        context.referenceUtils.foundInline({
+          type: "js_inline_content",
+          subtype: inlineContentInfo.type, // "new_blob_first_arg", "new_inline_content_first_arg", "json_parse_first_arg"
+          isOriginalPosition: urlInfo.content === urlInfo.originalContent,
+          line: inlineContentInfo.line,
+          column: inlineContentInfo.column,
+          specifier: inlineUrl,
+          contentType: inlineContentInfo.contentType,
+          content: inlineContentInfo.content,
+        })
+      inlineUrlInfo.jsQuote = quote
+      inlineReference.escape = (value) =>
+        JS_QUOTES.escapeSpecialChars(value.slice(1, -1), { quote })
+      await context.cook({
+        reference: inlineReference,
+        urlInfo: inlineUrlInfo,
+      })
+      magicSource.replace({
+        start: inlineContentInfo.start,
+        end: inlineContentInfo.end,
+        replacement: JS_QUOTES.escapeSpecialChars(inlineUrlInfo.content, {
+          quote,
+          allowEscapeForVersioning,
+        }),
+      })
+    }, Promise.resolve())
+    return magicSource.toContentAndSourcemap()
+  }
+
+  return {
+    name: "jsenv:js_inline_content",
+    appliesDuring: "*",
+    transformUrlContent: {
+      js_classic: parseAndTransformInlineContentCalls,
+      js_module: parseAndTransformInlineContentCalls,
+    },
+  }
+}
+
+const parseJsInlineContentInfos = async ({ js, url, isJsModule }) => {
+  if (
+    !js.includes("InlineContent") &&
+    !js.includes("new Blob(") &&
+    !js.includes("JSON.parse(")
+  ) {
+    return []
+  }
+  const { metadata } = await applyBabelPlugins({
+    babelPlugins: [babelPluginMetadataInlineContents],
+    urlInfo: {
+      url,
+      type: isJsModule ? "js_module" : "js_classic",
+      content: js,
+    },
+  })
+  return metadata.inlineContentInfos
+}
+
+const babelPluginMetadataInlineContents = () => {
+  return {
+    name: "metadata-inline-contents",
+    visitor: {
+      Program: (programPath, state) => {
+        const inlineContentInfos = []
+        const onInlineContentInfo = (inlineContentInfo) => {
+          inlineContentInfos.push(inlineContentInfo)
+        }
+        programPath.traverse({
+          NewExpression: (path) => {
+            if (isNewInlineContentCall(path)) {
+              analyzeNewInlineContentCall(path.node, {
+                onInlineContentInfo,
+              })
+              return
+            }
+            if (isNewBlobCall(path.node)) {
+              analyzeNewBlobCall(path.node, {
+                onInlineContentInfo,
+              })
+              return
+            }
+          },
+          CallExpression: (path) => {
+            const node = path.node
+            if (isJSONParseCall(node)) {
+              analyzeJsonParseCall(node, {
+                onInlineContentInfo,
+              })
+            }
+          },
+        })
+        state.file.metadata.inlineContentInfos = inlineContentInfos
+      },
+    },
+  }
+}
+
+const isNewInlineContentCall = (path) => {
+  const node = path.node
+  if (node.callee.type === "Identifier") {
+    // terser rename import to use a shorter name
+    const name = getOriginalName(path, node.callee.name)
+    return name === "InlineContent"
+  }
+  if (node.callee.id && node.callee.id.type === "Identifier") {
+    const name = getOriginalName(path, node.callee.id.name)
+    return name === "InlineContent"
+  }
+  return false
+}
+const analyzeNewInlineContentCall = (node, { onInlineContentInfo }) => {
+  analyzeArguments({
+    node,
+    onInlineContentInfo,
+    nodeHoldingContent: node.arguments[0],
+    type: "new_inline_content_first_arg",
+  })
+}
+
+const isNewBlobCall = (node) => {
+  return node.callee.type === "Identifier" && node.callee.name === "Blob"
+}
+const analyzeNewBlobCall = (node, { onInlineContentInfo }) => {
+  const firstArg = node.arguments[0]
+  if (firstArg.type !== "ArrayExpression") {
+    return
+  }
+  if (firstArg.elements.length !== 1) {
+    return
+  }
+  analyzeArguments({
+    node,
+    onInlineContentInfo,
+    nodeHoldingContent: firstArg.elements[0],
+    type: "new_blob_first_arg",
+  })
+}
+
+const analyzeArguments = ({
+  node,
+  onInlineContentInfo,
+  nodeHoldingContent,
+  type,
+}) => {
+  if (node.arguments.length !== 2) {
+    return
+  }
+  const [, secondArg] = node.arguments
+  const typePropertyNode = getTypePropertyNode(secondArg)
+  if (!typePropertyNode) {
+    return
+  }
+  const typePropertyValueNode = typePropertyNode.value
+  if (typePropertyValueNode.type !== "StringLiteral") {
+    return
+  }
+  const contentType = typePropertyValueNode.value
+  const contentDetails = extractContentDetails(nodeHoldingContent)
+  if (contentDetails) {
+    onInlineContentInfo({
+      node: nodeHoldingContent,
+      ...getNodePosition(nodeHoldingContent),
+      type,
+      contentType,
+      ...contentDetails,
+    })
+  }
+}
+const extractContentDetails = (node) => {
+  if (node.type === "StringLiteral") {
+    return {
+      nodeType: "StringLiteral",
+      quote: node.extra.raw[0],
+      content: node.value,
+    }
+  }
+  if (node.type === "TemplateLiteral") {
+    const quasis = node.quasis
+    if (quasis.length !== 1) {
+      return null
+    }
+    const templateElementNode = quasis[0]
+    return {
+      nodeType: "TemplateLiteral",
+      quote: "`",
+      content: templateElementNode.value.cooked,
+    }
+  }
+  return null
+}
+
+const isJSONParseCall = (node) => {
+  const callee = node.callee
+  return (
+    callee.type === "MemberExpression" &&
+    callee.object.type === "Identifier" &&
+    callee.object.name === "JSON" &&
+    callee.property.type === "Identifier" &&
+    callee.property.name === "parse"
+  )
+}
+const analyzeJsonParseCall = (node, { onInlineContentInfo }) => {
+  const firstArgNode = node.arguments[0]
+  const contentDetails = extractContentDetails(firstArgNode)
+  if (contentDetails) {
+    onInlineContentInfo({
+      node: firstArgNode,
+      ...getNodePosition(firstArgNode),
+      type: "json_parse_first_arg",
+      contentType: "application/json",
+      ...contentDetails,
+    })
+  }
+}
+
+const getNodePosition = (node) => {
+  return {
+    start: node.start,
+    end: node.end,
+    line: node.loc.start.line,
+    column: node.loc.start.column,
+    lineEnd: node.loc.end.line,
+    columnEnd: node.loc.end.column,
+  }
+}
+const getOriginalName = (path, name) => {
+  const binding = path.scope.getBinding(name)
+  if (!binding) {
+    return name
+  }
+  if (binding.path.type === "ImportSpecifier") {
+    const importedName = binding.path.node.imported.name
+    if (name === importedName) {
+      return name
+    }
+    return getOriginalName(path, importedName)
+  }
+  if (binding.path.type === "VariableDeclarator") {
+    if (binding.path.node.init.type === "Identifier") {
+      const previousName = binding.path.node.init.name
+      return getOriginalName(path, previousName)
+    }
+  }
+  return name
+}
+const getTypePropertyNode = (node) => {
+  if (node.type !== "ObjectExpression") {
+    return null
+  }
+  const { properties } = node
+  return properties.find((property) => {
+    return (
+      property.type === "ObjectProperty" &&
+      property.key.type === "Identifier" &&
+      property.key.name === "type"
+    )
+  })
+}

package/src/plugins/leading_slash/jsenv_plugin_leading_slash.js

@@ -0,0 +1,13 @@
+export const jsenvPluginLeadingSlash = () => {
+  return {
+    name: "jsenv:leading_slash",
+    appliesDuring: "*",
+    resolveUrl: (reference, context) => {
+      if (reference.specifier[0] !== "/") {
+        return null
+      }
+      return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
+        .href
+    },
+  }
+}

package/src/plugins/minification/css/minify_css.js

@@ -0,0 +1,9 @@
+import { minifyWithParcel } from "@jsenv/utils/css_ast/parcel_css.js"
+
+export const minifyCss = ({ cssUrlInfo, context }) => {
+  const { code, map } = minifyWithParcel(cssUrlInfo, context)
+  return {
+    content: String(code),
+    sourcemap: map,
+  }
+}

package/src/plugins/minification/html/minify_html.js

@@ -0,0 +1,15 @@
+import { createRequire } from "node:module"
+
+const require = createRequire(import.meta.url)
+
+// https://github.com/kangax/html-minifier#options-quick-reference
+export const minifyHtml = ({ htmlUrlInfo, options } = {}) => {
+  const { collapseWhitespace = true, removeComments = true } = options
+
+  const { minify } = require("html-minifier")
+  const htmlMinified = minify(htmlUrlInfo.content, {
+    collapseWhitespace,
+    removeComments,
+  })
+  return htmlMinified
+}

package/src/{build/plugins/minify_js/jsenv_plugin_minify_js.js → plugins/minification/js/minify_js.js}

@@ -1,28 +1,11 @@
 // https://github.com/terser-js/terser#minify-options
 
-export const jsenvPluginMinifyJs = () => {
-  const applyTerser = async (urlInfo) => {
-    return minifyJs({
-      url: urlInfo.url,
-      content: urlInfo.content,
-      sourcemap: urlInfo.sourcemap,
-      isJsModule: urlInfo.type === "js_module",
-    })
-  }
-
-  return {
-    name: "jsenv:minify_js",
-    appliesDuring: {
-      build: true,
-    },
-    optimize: {
-      js_classic: applyTerser,
-      js_module: applyTerser,
-    },
-  }
-}
+export const minifyJs = async ({ jsUrlInfo, options }) => {
+  const url = jsUrlInfo.url
+  const content = jsUrlInfo.content
+  const sourcemap = jsUrlInfo.sourcemap
+  const isJsModule = jsUrlInfo.type === "js_module"
 
-const minifyJs = async ({ url, content, sourcemap, isJsModule }) => {
   const { minify } = await import("terser")
   const terserResult = await minify(
     {
@@ -38,6 +21,7 @@ const minifyJs = async ({ url, content, sourcemap, isJsModule }) => {
       // We need to preserve "new InlineContent()" calls to be able to recognize them
       // after minification in order to version urls inside inline content text
       keep_fnames: /InlineContent/,
+      ...options,
     },
   )
   return {

package/src/plugins/minification/jsenv_plugin_minification.js

@@ -0,0 +1,78 @@
+import { minifyHtml } from "./html/minify_html.js"
+import { minifyCss } from "./css/minify_css.js"
+import { minifyJs } from "./js/minify_js.js"
+import { minifyJson } from "./json/minify_json.js"
+
+export const jsenvPluginMinification = (minification) => {
+  if (typeof minification === "boolean") {
+    minification = {
+      html: minification,
+      css: minification,
+      js_classic: minification,
+      js_module: minification,
+      json: minification,
+      svg: minification,
+    }
+  } else if (typeof minification !== "object") {
+    throw new Error(
+      `minification must be a boolean or an object, got ${minification}`,
+    )
+  }
+  Object.keys(minification).forEach((key) => {
+    if (minification[key] === true) minification[key] = {}
+  })
+  const htmlOptimizer = minification.html
+    ? (urlInfo, context) =>
+        minifyHtml({
+          htmlUrlInfo: urlInfo,
+          context,
+          options: minification.html,
+        })
+    : null
+  const jsonOptimizer = minification.json
+    ? (urlInfo, context) =>
+        minifyJson({
+          jsonUrlInfo: urlInfo,
+          context,
+          options: minification.json,
+        })
+    : null
+
+  return {
+    name: "jsenv:minification",
+    appliesDuring: {
+      build: true,
+    },
+    optimizeUrlContent: {
+      html: htmlOptimizer,
+      svg: htmlOptimizer,
+      css: minification.css
+        ? (urlInfo, context) =>
+            minifyCss({
+              cssUrlInfo: urlInfo,
+              context,
+              options: minification.css,
+            })
+        : null,
+      js_classic: minification.js_classic
+        ? (urlInfo, context) =>
+            minifyJs({
+              jsUrlInfo: urlInfo,
+              context,
+              options: minification.js_classic,
+            })
+        : null,
+      js_module: minification.js_module
+        ? (urlInfo, context) =>
+            minifyJs({
+              jsUrlInfo: urlInfo,
+              context,
+              options: minification.js_module,
+            })
+        : null,
+      json: jsonOptimizer,
+      importmap: jsonOptimizer,
+      webmanifest: jsonOptimizer,
+    },
+  }
+}

package/src/plugins/minification/json/minify_json.js

@@ -0,0 +1,8 @@
+export const minifyJson = ({ jsonUrlInfo }) => {
+  const { content } = jsonUrlInfo
+  if (content.startsWith("{\n")) {
+    const jsonWithoutWhitespaces = JSON.stringify(JSON.parse(content))
+    return jsonWithoutWhitespaces
+  }
+  return null
+}

package/src/plugins/node_esm_resolution/jsenv_plugin_node_esm_resolution.js

@@ -0,0 +1,146 @@
+/*
+ * - should I restore eventual search params lost during node esm resolution
+ * - what about symlinks?
+ *   It feels like I should apply symlink (when we don't want to preserve them)
+ *   once a file:/// url is found, regardless
+ *   if that comes from node resolution or anything else (not even magic resolution)
+ *   it should likely be an other plugin happening after the others
+ */
+
+import { registerFileLifecycle } from "@jsenv/filesystem"
+
+import {
+  applyNodeEsmResolution,
+  defaultLookupPackageScope,
+  defaultReadPackageJson,
+} from "@jsenv/node-esm-resolution"
+
+export const jsenvPluginNodeEsmResolution = ({
+  rootDirectoryUrl,
+  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
+  packageConditions = ["browser", "import"],
+  filesInvalidatingCache = ["package.json", "package-lock.json"],
+}) => {
+  const packageScopesCache = new Map()
+  const lookupPackageScope = (url) => {
+    const fromCache = packageScopesCache.get(url)
+    if (fromCache) {
+      return fromCache
+    }
+    const packageScope = defaultLookupPackageScope(url)
+    packageScopesCache.set(url, packageScope)
+    return packageScope
+  }
+  const packageJsonsCache = new Map()
+  const readPackageJson = (url) => {
+    const fromCache = packageJsonsCache.get(url)
+    if (fromCache) {
+      return fromCache
+    }
+    const packageJson = defaultReadPackageJson(url)
+    packageJsonsCache.set(url, packageJson)
+    return packageJson
+  }
+
+  const unregisters = []
+  filesInvalidatingCache.forEach((file) => {
+    const unregister = registerFileLifecycle(new URL(file, rootDirectoryUrl), {
+      added: () => {
+        packageScopesCache.clear()
+        packageJsonsCache.clear()
+      },
+      updated: () => {
+        packageScopesCache.clear()
+        packageJsonsCache.clear()
+      },
+      removed: () => {
+        packageScopesCache.clear()
+        packageJsonsCache.clear()
+      },
+      keepProcessAlive: false,
+    })
+    unregisters.push(unregister)
+  })
+
+  return [
+    jsenvPluginNodeEsmResolver({
+      packageConditions,
+      lookupPackageScope,
+      readPackageJson,
+    }),
+    jsenvPluginNodeModulesVersionInUrls({
+      lookupPackageScope,
+      readPackageJson,
+    }),
+  ]
+}
+
+const jsenvPluginNodeEsmResolver = ({
+  packageConditions,
+  lookupPackageScope,
+  readPackageJson,
+}) => {
+  return {
+    name: "jsenv:node_esm_resolve",
+    appliesDuring: "*",
+    resolveUrl: {
+      js_import_export: (reference) => {
+        const { parentUrl, specifier } = reference
+        const { url } = applyNodeEsmResolution({
+          conditions: packageConditions,
+          parentUrl,
+          specifier,
+          lookupPackageScope,
+          readPackageJson,
+        })
+        return url
+      },
+    },
+    fetchUrlContent: (urlInfo) => {
+      if (urlInfo.url.startsWith("file:///@ignore/")) {
+        return {
+          content: "export default {}",
+        }
+      }
+      return null
+    },
+  }
+}
+
+const jsenvPluginNodeModulesVersionInUrls = ({
+  lookupPackageScope,
+  readPackageJson,
+}) => {
+  return {
+    name: "jsenv:node_modules_version_in_urls",
+    appliesDuring: {
+      dev: true,
+      test: true,
+    },
+    transformUrlSearchParams: (reference, context) => {
+      if (!reference.url.startsWith("file:")) {
+        return null
+      }
+      // without this check a file inside a project without package.json
+      // could be considered as a node module if there is a ancestor package.json
+      // but we want to version only node modules
+      if (!reference.url.includes("/node_modules/")) {
+        return null
+      }
+      if (reference.searchParams.has("v")) {
+        return null
+      }
+      const packageUrl = lookupPackageScope(reference.url)
+      if (!packageUrl) {
+        return null
+      }
+      if (packageUrl === context.rootDirectoryUrl) {
+        return null
+      }
+      const packageVersion = readPackageJson(packageUrl).version
+      return {
+        v: packageVersion,
+      }
+    },
+  }
+}