@jsenv/core 27.0.0-alpha.9 → 27.0.0-alpha.92

package/src/plugins/url_analysis/html/html_urls.js

@@ -0,0 +1,257 @@
+import {
+  parseHtmlString,
+  visitHtmlNodes,
+  getHtmlNodeAttribute,
+  getHtmlNodePosition,
+  setHtmlNodeAttributes,
+  getHtmlNodeAttributePosition,
+  parseSrcSet,
+  stringifyHtmlAst,
+} from "@jsenv/ast"
+
+export const parseAndTransformHtmlUrls = async (urlInfo, context) => {
+  const url = urlInfo.originalUrl
+  const content = urlInfo.content
+  const { scenario, referenceUtils } = context
+  const htmlAst = parseHtmlString(content, {
+    storeOriginalPositions: scenario !== "build",
+  })
+  const actions = []
+  visitHtmlUrls({
+    url,
+    htmlAst,
+    onUrl: ({
+      type,
+      subtype,
+      expectedType,
+      line,
+      column,
+      originalLine,
+      originalColumn,
+      node,
+      attributeName,
+      specifier,
+    }) => {
+      const { crossorigin, integrity } = readFetchMetas(node)
+
+      const isRessourceHint = [
+        "preconnect",
+        "dns-prefetch",
+        "prefetch",
+        "preload",
+        "modulepreload",
+      ].includes(subtype)
+      const [reference] = referenceUtils.found({
+        type,
+        expectedType,
+        originalLine,
+        originalColumn,
+        specifier,
+        specifierLine: line,
+        specifierColumn: column,
+        isRessourceHint,
+        crossorigin,
+        integrity,
+      })
+      actions.push(async () => {
+        setHtmlNodeAttributes(node, {
+          [attributeName]: await referenceUtils.readGeneratedSpecifier(
+            reference,
+          ),
+        })
+      })
+    },
+  })
+  if (actions.length === 0) {
+    return null
+  }
+  await Promise.all(actions.map((action) => action()))
+  return {
+    content: stringifyHtmlAst(htmlAst),
+  }
+}
+
+const crossOriginCompatibleTagNames = ["script", "link", "img", "source"]
+const integrityCompatibleTagNames = ["script", "link", "img", "source"]
+const readFetchMetas = (node) => {
+  const meta = {}
+  if (crossOriginCompatibleTagNames.includes(node.nodeName)) {
+    const crossorigin = getHtmlNodeAttribute(node, "crossorigin") !== undefined
+    meta.crossorigin = crossorigin
+  }
+  if (integrityCompatibleTagNames.includes(node.nodeName)) {
+    const integrity = getHtmlNodeAttribute(node, "integrity")
+    meta.integrity = integrity
+  }
+  return meta
+}
+
+const visitHtmlUrls = ({ url, htmlAst, onUrl }) => {
+  const addDependency = ({
+    type,
+    subtype,
+    expectedType,
+    node,
+    attributeName,
+    specifier,
+  }) => {
+    const generatedFromInlineContent =
+      getHtmlNodeAttribute(node, "generated-from-inline-content") !== undefined
+    let position
+    if (generatedFromInlineContent) {
+      // when generated from inline content,
+      // line, column is not "src" nor "generated-from-src" but "original-position"
+      position = getHtmlNodePosition(node)
+    } else {
+      position = getHtmlNodeAttributePosition(node, attributeName)
+    }
+    const {
+      line,
+      column,
+      // originalLine, originalColumn
+    } = position
+    onUrl({
+      type,
+      subtype,
+      expectedType,
+      line,
+      column,
+      // originalLine, originalColumn
+      specifier,
+      node,
+      attributeName,
+    })
+  }
+  const visitAttributeAsUrlSpecifier = ({ node, attributeName, ...rest }) => {
+    const value = getHtmlNodeAttribute(node, attributeName)
+    if (value) {
+      const generatedBy = getHtmlNodeAttribute(node, "generated-by")
+      if (generatedBy !== undefined) {
+        // during build the importmap is inlined
+        // and shoud not be considered as a dependency anymore
+        return
+      }
+      addDependency({
+        ...rest,
+        node,
+        attributeName,
+        specifier:
+          attributeName === "generated-from-src" ||
+          attributeName === "generated-from-href"
+            ? new URL(value, url).href
+            : value,
+      })
+    } else if (attributeName === "src") {
+      visitAttributeAsUrlSpecifier({
+        ...rest,
+        node,
+        attributeName: "generated-from-src",
+      })
+    } else if (attributeName === "href") {
+      visitAttributeAsUrlSpecifier({
+        ...rest,
+        node,
+        attributeName: "generated-from-href",
+      })
+    }
+  }
+  const visitSrcset = ({ type, node }) => {
+    const srcset = getHtmlNodeAttribute(node, "srcset")
+    if (srcset) {
+      const srcCandidates = parseSrcSet(srcset)
+      srcCandidates.forEach((srcCandidate) => {
+        addDependency({
+          type,
+          node,
+          attributeName: "srcset",
+          specifier: srcCandidate.specifier,
+        })
+      })
+    }
+  }
+  visitHtmlNodes(htmlAst, {
+    link: (node) => {
+      const rel = getHtmlNodeAttribute(node, "rel")
+      const type = getHtmlNodeAttribute(node, "type")
+      visitAttributeAsUrlSpecifier({
+        type: "link_href",
+        subtype: rel,
+        node,
+        attributeName: "href",
+        expectedContentType: type,
+        expectedType: {
+          manifest: "webmanifest",
+          modulepreload: "js_module",
+          stylesheet: "css",
+        }[rel],
+      })
+    },
+    // style: () => {},
+    script: (node) => {
+      const type = getHtmlNodeAttribute(node, "type")
+      const expectedType = {
+        "undefined": "js_classic",
+        "text/javascript": "js_classic",
+        "module": "js_module",
+        "importmap": "importmap",
+      }[type]
+      visitAttributeAsUrlSpecifier({
+        type: "script_src",
+        expectedType,
+        node,
+        attributeName: "src",
+      })
+    },
+    a: (node) => {
+      visitAttributeAsUrlSpecifier({
+        type: "a_href",
+        node,
+        attributeName: "href",
+      })
+    },
+    iframe: (node) => {
+      visitAttributeAsUrlSpecifier({
+        type: "iframe_src",
+        node,
+        attributeName: "src",
+      })
+    },
+    img: (node) => {
+      visitAttributeAsUrlSpecifier({
+        type: "img_src",
+        node,
+        attributeName: "src",
+      })
+      visitSrcset({
+        type: "img_srcset",
+        node,
+      })
+    },
+    souce: (node) => {
+      visitAttributeAsUrlSpecifier({
+        type: "source_src",
+        node,
+        attributeName: "src",
+      })
+      visitSrcset({
+        type: "source_srcset",
+        node,
+      })
+    },
+    // svg <image> tag
+    image: (node) => {
+      visitAttributeAsUrlSpecifier({
+        type: "image_href",
+        node,
+        attributeName: "href",
+      })
+    },
+    use: (node) => {
+      visitAttributeAsUrlSpecifier({
+        type: "use_href",
+        node,
+        attributeName: "href",
+      })
+    },
+  })
+}

package/src/plugins/url_analysis/js/js_urls.js

@@ -0,0 +1,69 @@
+import { createMagicSource } from "@jsenv/sourcemap"
+import { parseJsUrls } from "@jsenv/ast"
+
+import { isWebWorkerUrlInfo } from "@jsenv/core/src/omega/web_workers.js"
+
+export const parseAndTransformJsUrls = async (urlInfo, context) => {
+  const jsMentions = await parseJsUrls({
+    js: urlInfo.content,
+    url: urlInfo.originalUrl,
+    isJsModule: urlInfo.type === "js_module",
+    isWebWorker: isWebWorkerUrlInfo(urlInfo),
+  })
+  const { rootDirectoryUrl, referenceUtils } = context
+  const actions = []
+  const magicSource = createMagicSource(urlInfo.content)
+  urlInfo.data.usesImport = false
+  urlInfo.data.usesExport = false
+  urlInfo.data.usesImportAssertion = false
+  jsMentions.forEach((jsMention) => {
+    if (jsMention.assert) {
+      urlInfo.data.usesImportAssertion = true
+    }
+    if (
+      jsMention.subtype === "import_static" ||
+      jsMention.subtype === "import_dynamic"
+    ) {
+      urlInfo.data.usesImport = true
+    }
+    if (jsMention.subtype === "export") {
+      urlInfo.data.usesExport = true
+    }
+    const [reference] = referenceUtils.found({
+      type: jsMention.type,
+      subtype: jsMention.subtype,
+      expectedType: jsMention.expectedType,
+      expectedSubtype: jsMention.expectedSubtype || urlInfo.subtype,
+      specifier: jsMention.specifier,
+      specifierStart: jsMention.specifierStart,
+      specifierEnd: jsMention.specifierEnd,
+      specifierLine: jsMention.specifierLine,
+      specifierColumn: jsMention.specifierColumn,
+      data: jsMention.data,
+      baseUrl: {
+        "StringLiteral": jsMention.baseUrl,
+        "window.origin": rootDirectoryUrl,
+        "import.meta.url": urlInfo.url,
+        "context.meta.url": urlInfo.url,
+        "document.currentScript.src": urlInfo.url,
+      }[jsMention.baseUrlType],
+      assert: jsMention.assert,
+      assertNode: jsMention.assertNode,
+      typePropertyNode: jsMention.typePropertyNode,
+    })
+    actions.push(async () => {
+      const replacement = await referenceUtils.readGeneratedSpecifier(reference)
+      magicSource.replace({
+        start: jsMention.specifierStart,
+        end: jsMention.specifierEnd,
+        replacement,
+      })
+      if (reference.mutation) {
+        reference.mutation(magicSource)
+      }
+    })
+  })
+  await Promise.all(actions.map((action) => action()))
+  const { content, sourcemap } = magicSource.toContentAndSourcemap()
+  return { content, sourcemap }
+}

package/src/plugins/url_analysis/jsenv_plugin_url_analysis.js

@@ -0,0 +1,110 @@
+import { URL_META } from "@jsenv/url-meta"
+import { urlToRelativeUrl } from "@jsenv/urls"
+
+import { parseAndTransformHtmlUrls } from "./html/html_urls.js"
+import { parseAndTransformCssUrls } from "./css/css_urls.js"
+import { parseAndTransformJsUrls } from "./js/js_urls.js"
+import { parseAndTransformWebmanifestUrls } from "./webmanifest/webmanifest_urls.js"
+
+export const jsenvPluginUrlAnalysis = ({
+  rootDirectoryUrl,
+  include,
+  supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
+}) => {
+  let getIncludeInfo = () => undefined
+  if (include) {
+    const associations = URL_META.resolveAssociations(
+      { include },
+      rootDirectoryUrl,
+    )
+    getIncludeInfo = (url) => {
+      const { include } = URL_META.applyAssociations({ url, associations })
+      return include
+    }
+  }
+
+  return {
+    name: "jsenv:url_analysis",
+    appliesDuring: "*",
+    redirectUrl: (reference) => {
+      if (reference.shouldHandle !== undefined) {
+        return
+      }
+      if (
+        reference.specifier[0] === "#" &&
+        // For Html, css and in general "#" refer to a ressource in the page
+        // so that urls must be kept intact
+        // However for js import specifiers they have a different meaning and we want
+        // to resolve them (https://nodejs.org/api/packages.html#imports for instance)
+        reference.type !== "js_import_export"
+      ) {
+        reference.shouldHandle = false
+        return
+      }
+      const includeInfo = getIncludeInfo(reference.url)
+      if (includeInfo === true) {
+        reference.shouldHandle = true
+        return
+      }
+      if (includeInfo === false) {
+        reference.shouldHandle = false
+        return
+      }
+      const { protocol } = new URL(reference.url)
+      const protocolIsSupported = supportedProtocols.some(
+        (supportedProtocol) => protocol === supportedProtocol,
+      )
+      if (protocolIsSupported) {
+        reference.shouldHandle = true
+        return
+      }
+    },
+    transformUrlContent: {
+      html: parseAndTransformHtmlUrls,
+      css: parseAndTransformCssUrls,
+      js_classic: parseAndTransformJsUrls,
+      js_module: parseAndTransformJsUrls,
+      webmanifest: parseAndTransformWebmanifestUrls,
+      directory: (urlInfo, context) => {
+        const originalDirectoryReference = findOriginalDirectoryReference(
+          urlInfo,
+          context,
+        )
+        const directoryRelativeUrl = urlToRelativeUrl(
+          urlInfo.url,
+          context.rootDirectoryUrl,
+        )
+        JSON.parse(urlInfo.content).forEach((directoryEntryName) => {
+          context.referenceUtils.found({
+            type: "filesystem",
+            subtype: "directory_entry",
+            specifier: directoryEntryName,
+            trace: `"${directoryRelativeUrl}${directoryEntryName}" entry in directory referenced by ${originalDirectoryReference.trace}`,
+          })
+        })
+      },
+    },
+  }
+}
+
+const findOriginalDirectoryReference = (urlInfo, context) => {
+  const findNonFileSystemAncestor = (urlInfo) => {
+    for (const dependentUrl of urlInfo.dependents) {
+      const dependentUrlInfo = context.urlGraph.getUrlInfo(dependentUrl)
+      if (dependentUrlInfo.type !== "directory") {
+        return [dependentUrlInfo, urlInfo]
+      }
+      const found = findNonFileSystemAncestor(dependentUrlInfo)
+      if (found) {
+        return found
+      }
+    }
+    return []
+  }
+  const [ancestor, child] = findNonFileSystemAncestor(urlInfo)
+  if (!ancestor) {
+    return null
+  }
+  const ref = ancestor.references.find((ref) => ref.url === child.url)
+  return ref
+}

package/src/plugins/url_analysis/webmanifest/webmanifest_urls.js

@@ -0,0 +1,20 @@
+export const parseAndTransformWebmanifestUrls = async (urlInfo, context) => {
+  const content = urlInfo.content
+  const manifest = JSON.parse(content)
+  const actions = []
+  const { icons = [] } = manifest
+  icons.forEach((icon) => {
+    const [reference] = context.referenceUtils.found({
+      type: "webmanifest_icon_src",
+      specifier: icon.src,
+    })
+    actions.push(async () => {
+      icon.src = await context.referenceUtils.readGeneratedSpecifier(reference)
+    })
+  })
+  if (actions.length === 0) {
+    return null
+  }
+  await Promise.all(actions.map((action) => action()))
+  return JSON.stringify(manifest, null, "  ")
+}

package/src/{omega/core_plugins → plugins}/url_resolution/jsenv_plugin_url_resolution.js

@@ -1,13 +1,15 @@
 export const jsenvPluginUrlResolution = () => {
-  const urlResolver = ({ parentUrl, specifier }) => {
-    return new URL(specifier, parentUrl).href
+  const urlResolver = (reference) => {
+    return new URL(
+      reference.specifier,
+      reference.baseUrl || reference.parentUrl,
+    ).href
   }
   return {
     name: "jsenv:url_resolution",
     appliesDuring: "*",
-    resolve: {
+    resolveUrl: {
       "entry_point": urlResolver,
-      "js_import_export": urlResolver,
       "link_href": urlResolver,
       "script_src": urlResolver,
       "a_href": urlResolver,
@@ -21,8 +23,10 @@ export const jsenvPluginUrlResolution = () => {
       "css_@import": urlResolver,
       "css_url": urlResolver,
       "sourcemap_comment": urlResolver,
-      "js_import_meta_url_pattern": urlResolver,
+      "js_import_export": urlResolver,
+      "js_url_specifier": urlResolver,
       "js_inline_content": urlResolver,
+      "webmanifest_icon_src": urlResolver,
     },
   }
 }

package/src/plugins/url_version/jsenv_plugin_url_version.js

@@ -0,0 +1,28 @@
+export const jsenvPluginUrlVersion = () => {
+  return {
+    name: "jsenv:url_version",
+    appliesDuring: "*",
+    redirectUrl: (reference) => {
+      // "v" search param goal is to enable long-term cache
+      // for server response headers
+      // it is also used by hmr to bypass browser cache
+      // this goal is achieved when we reach this part of the code
+      // We get rid of this params so that urlGraph and other parts of the code
+      // recognize the url (it is not considered as a different url)
+      const urlObject = new URL(reference.url)
+      urlObject.searchParams.delete("v")
+      return urlObject.href
+    },
+    transformUrlSearchParams: (reference) => {
+      if (!reference.data.version) {
+        return null
+      }
+      if (reference.searchParams.has("v")) {
+        return null
+      }
+      return {
+        v: reference.data.version,
+      }
+    },
+  }
+}

package/src/require_from_jsenv.js

@@ -0,0 +1,3 @@
+import { createRequire } from "node:module"
+
+export const requireFromJsenv = createRequire(import.meta.url)

package/src/test/coverage/babel_plugin_instrument.js

@@ -0,0 +1,82 @@
+import { URL_META } from "@jsenv/url-meta"
+import { fileSystemPathToUrl } from "@jsenv/urls"
+
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+
+// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
+
+export const babelPluginInstrument = (
+  api,
+  {
+    rootDirectoryUrl,
+    useInlineSourceMaps = false,
+    coverageConfig = { "./**/*": true },
+  },
+) => {
+  const { programVisitor } = requireFromJsenv("istanbul-lib-instrument")
+
+  const { types } = api
+
+  const associations = URL_META.resolveAssociations(
+    { cover: coverageConfig },
+    rootDirectoryUrl,
+  )
+  const shouldInstrument = (url) => {
+    return URL_META.applyAssociations({ url, associations }).cover
+  }
+
+  return {
+    name: "transform-instrument",
+    visitor: {
+      Program: {
+        enter(path) {
+          const { file } = this
+          const { opts } = file
+          if (!opts.sourceFileName) {
+            console.warn(
+              `cannot instrument file when "sourceFileName" option is not set`,
+            )
+            return
+          }
+          const fileUrl = fileSystemPathToUrl(opts.sourceFileName)
+          if (!shouldInstrument(fileUrl)) {
+            return
+          }
+
+          this.__dv__ = null
+
+          let inputSourceMap
+
+          if (useInlineSourceMaps) {
+            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
+            inputSourceMap =
+              opts.inputSourceMap || file.inputMap
+                ? file.inputMap.sourcemap
+                : null
+          } else {
+            inputSourceMap = opts.inputSourceMap
+          }
+
+          this.__dv__ = programVisitor(
+            types,
+            opts.filenameRelative || opts.filename,
+            {
+              coverageVariable: "__coverage__",
+              inputSourceMap,
+            },
+          )
+          this.__dv__.enter(path)
+        },
+
+        exit(path) {
+          if (!this.__dv__) {
+            return
+          }
+          const object = this.__dv__.exit(path)
+          // object got two properties: fileCoverage and sourceMappingURL
+          this.file.metadata.coverage = object.fileCoverage
+        },
+      },
+    },
+  }
+}

package/src/test/coverage/coverage_reporter_html_directory.js

@@ -0,0 +1,36 @@
+import { readFileSync } from "node:fs"
+import { resolveUrl, urlToFileSystemPath } from "@jsenv/urls"
+
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
+
+export const generateCoverageHtmlDirectory = async (
+  coverage,
+  {
+    rootDirectoryUrl,
+    coverageHtmlDirectoryRelativeUrl,
+    coverageSkipEmpty,
+    coverageSkipFull,
+  },
+) => {
+  const libReport = requireFromJsenv("istanbul-lib-report")
+  const reports = requireFromJsenv("istanbul-reports")
+
+  const context = libReport.createContext({
+    dir: urlToFileSystemPath(rootDirectoryUrl),
+    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+    sourceFinder: (path) => {
+      return readFileSync(
+        urlToFileSystemPath(resolveUrl(path, rootDirectoryUrl)),
+        "utf8",
+      )
+    },
+  })
+
+  const report = reports.create("html", {
+    skipEmpty: coverageSkipEmpty,
+    skipFull: coverageSkipFull,
+    subdir: coverageHtmlDirectoryRelativeUrl,
+  })
+  report.execute(context)
+}

package/src/test/coverage/coverage_reporter_json_file.js

@@ -0,0 +1,22 @@
+import { writeFile } from "@jsenv/filesystem"
+import { urlToFileSystemPath } from "@jsenv/urls"
+import { byteAsFileSize } from "@jsenv/log"
+
+export const generateCoverageJsonFile = async ({
+  coverage,
+  coverageJsonFileUrl,
+  coverageJsonFileLog,
+  logger,
+}) => {
+  const coverageAsText = JSON.stringify(coverage, null, "  ")
+
+  if (coverageJsonFileLog) {
+    logger.info(
+      `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
+        Buffer.byteLength(coverageAsText),
+      )})`,
+    )
+  }
+
+  await writeFile(coverageJsonFileUrl, coverageAsText)
+}

package/src/test/coverage/coverage_reporter_text_log.js

@@ -0,0 +1,19 @@
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
+
+export const generateCoverageTextLog = (
+  coverage,
+  { coverageSkipEmpty, coverageSkipFull },
+) => {
+  const libReport = requireFromJsenv("istanbul-lib-report")
+  const reports = requireFromJsenv("istanbul-reports")
+
+  const context = libReport.createContext({
+    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+  })
+  const report = reports.create("text", {
+    skipEmpty: coverageSkipEmpty,
+    skipFull: coverageSkipFull,
+  })
+  report.execute(context)
+}