@jsenv/core 27.0.0-alpha.8 → 27.0.0-alpha.80

package/src/omega/core_plugins/inline/jsenv_plugin_new_inline_content.js

@@ -1,207 +0,0 @@
-/*
- * Needs to be updated so that it sill works in the following cases:
- * - templates literals transformed to regular stuff by babel
- * - tagged name renamed by rollup
- * - the template named is minified by terser
- * In the cases above I must remain capable to recoginize the template literal
- * to be able to update the urls inside (and even version the urls)
- * because url versioning happens after minification it can be challenging
- *
- * TODO: use "keep_classnames" https://github.com/terser/terser#compress-options
- * so that new InlineContent can be recognized after minification
- */
-
-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 jsenvPluginNewInlineContent = ({ allowEscapeForVersioning }) => {
-  return {
-    name: "jsenv:new_inline_content",
-    appliesDuring: "*",
-    transform: {
-      js_module: async (
-        { url, generatedUrl, content, originalContent },
-        { referenceUtils, cook, isSupportedOnRuntime },
-      ) => {
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [babelPluginMetadataInlineContentCalls],
-          url,
-          generatedUrl,
-          content,
-        })
-        const { inlineContentCalls } = metadata
-        if (inlineContentCalls.length === 0) {
-          return null
-        }
-        const magicSource = createMagicSource(content)
-        await inlineContentCalls.reduce(async (previous, inlineContentCall) => {
-          await previous
-          const inlineUrl = generateInlineContentUrl({
-            url,
-            extension: {
-              "application/json": ".json",
-              "text/css": ".css",
-              "text/plain": ".txt",
-              "application/octet-stream": "",
-            }[inlineContentCall.contentType],
-            line: inlineContentCall.line,
-            column: inlineContentCall.column,
-            lineEnd: inlineContentCall.lineEnd,
-            columnEnd: inlineContentCall.columnEnd,
-          })
-          let { quote } = inlineContentCall
-          if (quote === "`" && !isSupportedOnRuntime("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(inlineContentCall.content)
-          }
-          const [inlineReference, inlineUrlInfo] = referenceUtils.foundInline({
-            type: "js_inline_content",
-            isOriginal: content === originalContent,
-            line: inlineContentCall.line,
-            column: inlineContentCall.column,
-            specifier: inlineUrl,
-            contentType: inlineContentCall.contentType,
-            content: inlineContentCall.content,
-          })
-          inlineUrlInfo.jsQuote = quote
-          inlineReference.escape = (value) =>
-            JS_QUOTES.escapeSpecialChars(value.slice(1, -1), { quote })
-          await cook({
-            reference: inlineReference,
-            urlInfo: inlineUrlInfo,
-          })
-          magicSource.replace({
-            start: inlineContentCall.start,
-            end: inlineContentCall.end,
-            replacement: JS_QUOTES.escapeSpecialChars(inlineUrlInfo.content, {
-              quote,
-              allowEscapeForVersioning,
-            }),
-          })
-        }, Promise.resolve())
-        return magicSource.toContentAndSourcemap()
-      },
-    },
-  }
-}
-
-const babelPluginMetadataInlineContentCalls = () => {
-  return {
-    name: "metadata-inline-content-calls",
-    visitor: {
-      Program: (programPath, state) => {
-        const inlineContentCalls = []
-        programPath.traverse({
-          NewExpression: (path) => {
-            const newInlineContentCall = parseAsNewInlineContentCall(path)
-            if (newInlineContentCall) {
-              inlineContentCalls.push(newInlineContentCall)
-            }
-          },
-        })
-        state.file.metadata.inlineContentCalls = inlineContentCalls
-      },
-    },
-  }
-}
-
-const parseAsNewInlineContentCall = (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)
-    if (name !== "InlineContent") {
-      return null
-    }
-  } else if (node.callee.id) {
-    // terser might combine new InlineContent('') declaration and usage
-    if (node.callee.id.type !== "Identifier") {
-      return null
-    }
-    const name = getOriginalName(path, node.callee.id.name)
-    if (name !== "InlineContent") {
-      return null
-    }
-  }
-  if (node.arguments.length !== 2) {
-    return null
-  }
-  const [firstArg, secondArg] = node.arguments
-  if (secondArg.type !== "ObjectExpression") {
-    return null
-  }
-  const typePropertyNode = secondArg.properties.find((property) => {
-    return (
-      property.key.type === "Identifier" &&
-      property.key.name === "type" &&
-      property.type === "ObjectProperty" &&
-      property.value.type === "StringLiteral"
-    )
-  })
-  if (!typePropertyNode) {
-    return null
-  }
-  const type = typePropertyNode.value.value
-  if (firstArg.type === "StringLiteral") {
-    const position = getNodePosition(firstArg)
-    return {
-      nodeType: "StringLiteral",
-      quote: firstArg.extra.raw[0],
-      contentType: type,
-      content: firstArg.value,
-      ...position,
-    }
-  }
-  if (firstArg.type === "TemplateLiteral") {
-    const quasis = firstArg.quasis
-    if (quasis.length !== 1) {
-      return null
-    }
-    const templateElementNode = quasis[0]
-    const position = getNodePosition(firstArg)
-    return {
-      nodeType: "TemplateLiteral",
-      quote: "`",
-      contentType: type,
-      content: templateElementNode.value.cooked,
-      ...position,
-    }
-  }
-  return null
-}
-
-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
-}

package/src/omega/core_plugins/leading_slash/jsenv_plugin_leading_slash.js

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

package/src/omega/core_plugins/node_esm_resolution/jsenv_plugin_node_esm_resolution.js

@@ -1,77 +0,0 @@
-/*
- * - 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 {
-  applyNodeEsmResolution,
-  lookupPackageScope,
-  readPackageJson,
-} from "@jsenv/node-esm-resolution"
-
-export const jsenvPluginNodeEsmResolution = ({
-  // https://nodejs.org/api/esm.html#resolver-algorithm-specification
-  packageConditions = ["browser", "import"],
-} = {}) => {
-  const nodeEsmResolution = {
-    name: "jsenv:node_esm_resolve",
-    appliesDuring: "*",
-    resolve: {
-      js_import_export: ({ parentUrl, specifier }) => {
-        const { url } = applyNodeEsmResolution({
-          conditions: packageConditions,
-          parentUrl,
-          specifier,
-        })
-        return url
-      },
-    },
-    load: ({ url }) => {
-      if (url.startsWith("file:///@ignore/")) {
-        return {
-          content: "export default {}",
-        }
-      }
-      return null
-    },
-  }
-
-  const packageVersionInUrl = {
-    name: "jsenv:package_url_version",
-    appliesDuring: {
-      dev: true,
-      test: true,
-    },
-    transformReferencedUrl: ({ url }, { rootDirectoryUrl }) => {
-      if (!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 (!url.includes("/node_modules/")) {
-        return null
-      }
-      const urlObject = new URL(url)
-      if (urlObject.searchParams.has("v")) {
-        return null
-      }
-      const packageUrl = lookupPackageScope(url)
-      if (!packageUrl) {
-        return null
-      }
-      if (packageUrl === rootDirectoryUrl) {
-        return null
-      }
-      const packageVersion = readPackageJson(packageUrl).version
-      urlObject.searchParams.set("v", packageVersion)
-      return urlObject.href
-    },
-  }
-
-  return [nodeEsmResolution, packageVersionInUrl]
-}

package/src/omega/core_plugins/url_version/jsenv_plugin_url_version.js

@@ -1,50 +0,0 @@
-export const jsenvPluginUrlVersion = ({
-  longTermCache = false, // will become true once things get more stable
-} = {}) => {
-  return {
-    name: "jsenv:url_version",
-    appliesDuring: "*", // maybe only during dev?
-    normalize: ({ url }) => {
-      // "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(url)
-      urlObject.searchParams.delete("v")
-      return urlObject.href
-    },
-    transformReferencedUrl: ({ url, data }) => {
-      if (!data.version) {
-        return null
-      }
-      const urlObject = new URL(url)
-      if (urlObject.searchParams.has("v")) {
-        return null
-      }
-      urlObject.searchParams.set("v", data.version)
-      return urlObject.href
-    },
-    augmentResponse: ({ url }) => {
-      if (!longTermCache) {
-        return null
-      }
-      const urlObject = new URL(url)
-      if (!urlObject.searchParams.has("v")) {
-        return null
-      }
-      if (urlObject.searchParams.has("hmr")) {
-        return null
-      }
-      // When url is versioned put it in browser cache for 30 days
-      return {
-        headers: {
-          "cache-control": `private,max-age=${SECONDS_IN_30_DAYS},immutable`,
-        },
-      }
-    },
-  }
-}
-
-const SECONDS_IN_30_DAYS = 60 * 60 * 24 * 30

package/src/omega/core_plugins.js

@@ -1,39 +0,0 @@
-import { jsenvPluginLeadingSlash } from "./core_plugins/leading_slash/jsenv_plugin_leading_slash.js"
-import { jsenvPluginImportmap } from "./core_plugins/importmap/jsenv_plugin_importmap.js"
-import { jsenvPluginUrlResolution } from "./core_plugins/url_resolution/jsenv_plugin_url_resolution.js"
-import { jsenvPluginNodeEsmResolution } from "./core_plugins/node_esm_resolution/jsenv_plugin_node_esm_resolution.js"
-import { jsenvPluginUrlVersion } from "./core_plugins/url_version/jsenv_plugin_url_version.js"
-import { jsenvPluginFileUrls } from "./core_plugins/file_urls/jsenv_plugin_file_urls.js"
-import { jsenvPluginFileSystemMagic } from "./core_plugins/filesystem_magic/jsenv_plugin_filesystem_magic.js"
-import { jsenvPluginInline } from "./core_plugins/inline/jsenv_plugin_inline.js"
-import { jsenvPluginHtmlSupervisor } from "./core_plugins/html_supervisor/jsenv_plugin_html_supervisor.js"
-import { jsenvPluginCommonJsGlobals } from "./core_plugins/commonjs_globals/jsenv_plugin_commonjs_globals.js"
-import { jsenvPluginImportAssertions } from "./core_plugins/import_assertions/jsenv_plugin_import_assertions.js"
-import { jsenvPluginImportMetaScenarios } from "./core_plugins/import_meta_scenarios/jsenv_plugin_import_meta_scenarios.js"
-import { jsenvPluginBabel } from "./core_plugins/babel/jsenv_plugin_babel.js"
-
-export const getCorePlugins = ({
-  htmlSupervisor,
-  nodeEsmResolution,
-  fileSystemMagicResolution,
-  babel,
-} = {}) => {
-  const asFewAsPossible = false // useful during dev
-  return [
-    ...(asFewAsPossible ? [] : [jsenvPluginImportAssertions()]),
-    ...(asFewAsPossible ? [] : [jsenvPluginHtmlSupervisor(htmlSupervisor)]), // before inline as it turns inline <script> into <script src>
-    ...(asFewAsPossible ? [] : [jsenvPluginInline()]), // before "file urls" to resolve and load inline urls
-    jsenvPluginImportmap(), // before node esm to handle bare specifiers before node esm
-    jsenvPluginFileUrls(),
-    jsenvPluginLeadingSlash(),
-    jsenvPluginNodeEsmResolution(nodeEsmResolution), // before url resolution to handle "js_import_export" resolution
-    jsenvPluginUrlResolution(),
-    ...(asFewAsPossible
-      ? []
-      : [jsenvPluginFileSystemMagic(fileSystemMagicResolution)]),
-    jsenvPluginUrlVersion(),
-    ...(asFewAsPossible ? [] : [jsenvPluginCommonJsGlobals()]),
-    ...(asFewAsPossible ? [] : [jsenvPluginImportMetaScenarios()]),
-    jsenvPluginBabel(babel),
-  ]
-}

package/src/omega/runtime_support/default_runtime_support.js

@@ -1,13 +0,0 @@
-// correspond to dynamic import
-export const defaultRuntimeSupport = {
-  // android: "8",
-  chrome: "63",
-  edge: "79",
-  electron: "8.1",
-  firefox: "67",
-  ios: "11",
-  opera: "50",
-  safari: "11.3",
-  node: "13.2",
-  samsung: "8.0",
-}

package/src/omega/url_graph/url_graph_sort.js

@@ -1,29 +0,0 @@
-export const sortUrlGraphByDependencies = (urlGraph) => {
-  const { urlInfos } = urlGraph
-
-  const visited = []
-  const sorted = []
-  const circular = []
-  const visit = (url) => {
-    const isSorted = sorted.includes(url)
-    if (isSorted) {
-      return
-    }
-    const isVisited = visited.includes(url)
-    if (isVisited) {
-      circular.push(url)
-      sorted.push(url)
-    } else {
-      visited.push(url)
-      urlInfos[url].dependencies.forEach((dependencyUrl) => {
-        visit(dependencyUrl, url)
-      })
-      sorted.push(url)
-    }
-  }
-  Object.keys(urlInfos).forEach((url) => {
-    visit(url)
-  })
-  sorted.circular = circular
-  return sorted
-}

package/src/omega/url_mentions/css_url_mentions.js

@@ -1,63 +0,0 @@
-/*
- * https://github.com/parcel-bundler/parcel/blob/v2/packages/transformers/css/src/CSSTransformer.js
- */
-
-import { applyPostCss } from "@jsenv/utils/css_ast/apply_post_css.js"
-import { postCssPluginUrlVisitor } from "@jsenv/utils/css_ast/postcss_plugin_url_visitor.js"
-import { replaceCssUrls } from "@jsenv/utils/css_ast/replace_css_urls.js"
-
-export const parseCssUrlMentions = async ({ url, content }) => {
-  const cssUrlMentions = []
-  await applyPostCss({
-    sourcemaps: false,
-    plugins: [
-      postCssPluginUrlVisitor({
-        urlVisitor: ({ type, url, specifier, urlNode }) => {
-          cssUrlMentions.push({
-            type: `css_${type}`,
-            specifier,
-            start: urlNode.sourceIndex,
-            end: urlNode.sourceEndIndex,
-            url,
-          })
-        },
-      }),
-    ],
-    url,
-    content,
-  })
-  return {
-    urlMentions: cssUrlMentions,
-    replaceUrls: async (getReplacement) => {
-      // we can't use magic source because urlMention.start/end do not match the url specifier
-      // const magicSource = createMagicSource({ url, content })
-      // cssUrlMentions.forEach((urlMention) => {
-      //   magicSource.replace({
-      //     start: urlMention.start,
-      //     end: urlMention.end,
-      //     replacement: JSON.stringify(transformUrlMention(urlMention)),
-      //   })
-      // })
-      // return magicSource.toContentAndSourcemap()
-      const result = await replaceCssUrls({
-        url,
-        content,
-        urlVisitor: ({ url, replace }) => {
-          const cssUrlMention = cssUrlMentions.find(
-            (urlMention) => urlMention.url === url,
-          )
-          if (cssUrlMention) {
-            const replacement = getReplacement(cssUrlMention)
-            if (replacement) {
-              replace(replacement)
-            }
-          }
-        },
-      })
-      return {
-        content: result.content,
-        sourcemap: result.map,
-      }
-    },
-  }
-}

package/src/omega/url_mentions/html_url_mentions.js

@@ -1,185 +0,0 @@
-import {
-  parseHtmlString,
-  stringifyHtmlAst,
-  getHtmlNodeAttributeByName,
-  htmlNodePosition,
-  visitHtmlAst,
-} from "@jsenv/utils/html_ast/html_ast.js"
-import { htmlAttributeSrcSet } from "@jsenv/utils/html_ast/html_attribute_src_set.js"
-
-export const parseHtmlUrlMentions = ({ url, content, scenario }) => {
-  const htmlAst = parseHtmlString(content, {
-    storeOriginalPositions: scenario !== "build",
-  })
-  const htmlUrlMentions = collectHtmlUrlMentions({ url, htmlAst })
-  return {
-    urlMentions: htmlUrlMentions,
-    replaceUrls: (getReplacement) => {
-      htmlUrlMentions.forEach((urlMention) => {
-        const replacement = getReplacement(urlMention)
-        if (replacement) {
-          urlMention.attribute.value = replacement
-        }
-      })
-      return {
-        content: stringifyHtmlAst(htmlAst),
-      }
-    },
-  }
-}
-
-const collectHtmlUrlMentions = ({ url, htmlAst }) => {
-  const htmlUrlMentions = []
-  const addDependency = ({ type, node, attribute, specifier }) => {
-    const injected = Boolean(getHtmlNodeAttributeByName(node, "injected-by"))
-    const srcGeneratedFromInlineContent = Boolean(
-      getHtmlNodeAttributeByName(node, "src-generated-from-inline-content"),
-    )
-    let position
-    if (srcGeneratedFromInlineContent) {
-      // when generated from inline content,
-      // line, column is not "src" nor "content-src" but "original-position"
-      position = htmlNodePosition.readNodePosition(node)
-    } else {
-      position = htmlNodePosition.readAttributePosition(node, attribute.name)
-    }
-    const { line, column, originalLine, originalColumn } = position
-    htmlUrlMentions.push({
-      type,
-      htmlNode: node,
-      attribute,
-      injected,
-      srcGeneratedFromInlineContent,
-      specifier,
-      line,
-      column,
-      originalLine,
-      originalColumn,
-    })
-  }
-  const onNode = (node) => {
-    if (node.nodeName === "link") {
-      visitAttributeAsUrlSpecifier({
-        type: "link_href",
-        node,
-        attributeName: "href",
-      })
-      return
-    }
-    // if (node.nodeName === "style") {
-    //   // styles.push(node)
-    //   return
-    // }
-    if (node.nodeName === "script") {
-      visitAttributeAsUrlSpecifier({
-        type: "script_src",
-        node,
-        attributeName: "src",
-      })
-      return
-    }
-    if (node.nodeName === "a") {
-      visitAttributeAsUrlSpecifier({
-        type: "a_href",
-        node,
-        attributeName: "href",
-      })
-    }
-    if (node.nodeName === "iframe") {
-      visitAttributeAsUrlSpecifier({
-        type: "iframe_src",
-        node,
-        attributeName: "src",
-      })
-    }
-    if (node.nodeName === "img") {
-      visitAttributeAsUrlSpecifier({
-        type: "img_src",
-        node,
-        attributeName: "src",
-      })
-      visitSrcset({
-        type: "img_srcset",
-        node,
-      })
-      return
-    }
-    if (node.nodeName === "source") {
-      visitAttributeAsUrlSpecifier({
-        type: "source_src",
-        node,
-        attributeName: "src",
-      })
-      visitSrcset({
-        type: "source_srcset",
-        node,
-      })
-      return
-    }
-    // svg <image> tag
-    if (node.nodeName === "image") {
-      visitAttributeAsUrlSpecifier({
-        type: "image_href",
-        node,
-        attributeName: "href",
-      })
-      return
-    }
-    if (node.nodeName === "use") {
-      visitAttributeAsUrlSpecifier({
-        type: "use_href",
-        node,
-        attributeName: "href",
-      })
-      return
-    }
-  }
-  const visitAttributeAsUrlSpecifier = ({ type, node, attributeName }) => {
-    const attribute = getHtmlNodeAttributeByName(node, attributeName)
-    const value = attribute ? attribute.value : undefined
-    if (value) {
-      const inlinedBy = getHtmlNodeAttributeByName(node, "inlined-by")
-      if (inlinedBy) {
-        // during build the importmap is inlined
-        // and shoud not be considered as a dependency anymore
-        return
-      }
-      addDependency({
-        type,
-        node,
-        attribute,
-        specifier:
-          attributeName === "content-src" ? new URL(value, url).href : value,
-      })
-    } else if (attributeName === "src") {
-      visitAttributeAsUrlSpecifier({
-        type,
-        node,
-        attributeName: "content-src",
-      })
-    } else if (attributeName === "href") {
-      visitAttributeAsUrlSpecifier({
-        type,
-        node,
-        attributeName: "content-href",
-      })
-    }
-  }
-  const visitSrcset = ({ type, node }) => {
-    const srcsetAttribute = getHtmlNodeAttributeByName(node, "srcset")
-    const srcset = srcsetAttribute ? srcsetAttribute.value : undefined
-    if (srcset) {
-      const srcCandidates = htmlAttributeSrcSet.parse(srcset)
-      srcCandidates.forEach((srcCandidate) => {
-        addDependency({
-          type,
-          node,
-          attribute: srcsetAttribute,
-          specifier: srcCandidate.specifier,
-        })
-      })
-    }
-  }
-  visitHtmlAst(htmlAst, onNode)
-  return htmlUrlMentions
-}