@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/internal/building/css/move_css_urls.js

@@ -1,44 +0,0 @@
-import { urlToRelativeUrl } from "@jsenv/filesystem"
-
-import { applyPostCss } from "./apply_post_css.js"
-import { postCssPluginUrlVisitor } from "./postcss_plugin_url_visitor.js"
-
-export const moveCssUrls = async ({
-  code,
-  from,
-  to,
-  map,
-  sourcemapMethod,
-} = {}) => {
-  const fromDirectoryUrl = new URL("./", from).href
-  const toDirectoryUrl = new URL("./", to).href
-  // same directory, nothing to do
-  if (fromDirectoryUrl === toDirectoryUrl) {
-    return { code, map }
-  }
-
-  const result = await applyPostCss({
-    code,
-    url: from,
-    map,
-    sourcemapMethod,
-    plugins: [
-      postCssPluginUrlVisitor({
-        urlVisitor: ({ specifier }) => {
-          if (specifier[0] === "#") {
-            return null
-          }
-          const url = new URL(specifier, fromDirectoryUrl).href
-          const relativeUrl = urlToRelativeUrl(url, toDirectoryUrl)
-          return relativeUrl
-        },
-      }),
-    ],
-  })
-  code = result.code
-  map = result.map
-  return {
-    code,
-    map,
-  }
-}

package/src/internal/building/css/parse_css_urls.js

@@ -1,38 +0,0 @@
-import { applyPostCss } from "./apply_post_css.js"
-import { postCssPluginUrlVisitor } from "./postcss_plugin_url_visitor.js"
-
-export const parseCssUrls = async ({ code, url = "file:///file.css" }) => {
-  const atImports = []
-  const urlDeclarations = []
-  await applyPostCss({
-    code,
-    url,
-    plugins: [
-      postCssPluginUrlVisitor({
-        urlVisitor: ({
-          type,
-          specifier,
-          atImportNode,
-          declarationNode,
-          urlNode,
-        }) => {
-          if (type === "import") {
-            atImports.push({
-              specifier,
-              urlNode,
-              urlDeclarationNode: atImportNode,
-            })
-          }
-          if (type === "asset") {
-            urlDeclarations.push({
-              specifier,
-              urlNode,
-              urlDeclarationNode: declarationNode,
-            })
-          }
-        },
-      }),
-    ],
-  })
-  return { atImports, urlDeclarations }
-}

package/src/internal/building/css/postcss_plugin_url_visitor.js

@@ -1,245 +0,0 @@
-/**
-
-https://github.com/postcss/postcss/blob/master/docs/writing-a-plugin.md
-https://github.com/postcss/postcss/blob/master/docs/guidelines/plugin.md
-https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md#31-dont-show-js-stack-for-csssyntaxerror
-
-In case css sourcemap contains no%20source
-This is because of https://github.com/postcss/postcss/blob/fd30d3df5abc0954a0ec642a3cdc644ab2aacf9c/lib/map-generator.js#L231
-and it indicates a node has been replaced without passing source
-hence sourcemap cannot point the original source location
-
-*/
-
-import { fileSystemPathToUrl, resolveUrl } from "@jsenv/filesystem"
-
-import { require } from "@jsenv/core/src/internal/require.js"
-
-export const postCssPluginUrlVisitor = ({ urlVisitor = () => null }) => {
-  const parseCssValue = require("postcss-value-parser")
-  const stringifyCssNodes = parseCssValue.stringify
-
-  return {
-    postcssPlugin: "url_visitor",
-    prepare: (result) => {
-      const { from } = result.opts
-      const fromUrl = fileSystemPathToUrl(from)
-      const mutations = []
-      return {
-        AtRule: {
-          import: (atImportNode, { AtRule }) => {
-            if (atImportNode.parent.type !== "root") {
-              atImportNode.warn(result, "`@import` should be top level")
-              return
-            }
-
-            if (atImportNode.nodes) {
-              atImportNode.warn(
-                result,
-                "`@import` was not terminated correctly",
-              )
-              return
-            }
-
-            const parsed = parseCssValue(atImportNode.params)
-            let [urlNode] = parsed.nodes
-
-            if (
-              !urlNode ||
-              (urlNode.type !== "string" && urlNode.type !== "function")
-            ) {
-              atImportNode.warn(
-                result,
-                `No URL in \`${atImportNode.toString()}\``,
-              )
-              return
-            }
-
-            let url = ""
-            if (urlNode.type === "string") {
-              url = urlNode.value
-            } else if (urlNode.type === "function") {
-              // Invalid function
-              if (!/^url$/i.test(urlNode.value)) {
-                atImportNode.warn(
-                  result,
-                  `Invalid \`url\` function in \`${atImportNode.toString()}\``,
-                )
-                return
-              }
-
-              const firstNode = urlNode.nodes[0]
-              if (firstNode && firstNode.type === "string") {
-                urlNode = firstNode
-                url = urlNode.value
-              } else {
-                urlNode = urlNode.nodes
-                url = stringifyCssNodes(urlNode.nodes)
-              }
-            }
-
-            url = url.trim()
-
-            if (url.length === 0) {
-              atImportNode.warn(
-                result,
-                `Empty URL in \`${atImportNode.toString()}\``,
-              )
-              return
-            }
-
-            const specifier = url
-            url = resolveUrl(specifier, fromUrl)
-
-            if (url === fromUrl) {
-              atImportNode.warn(
-                result,
-                `\`@import\` loop in \`${atImportNode.toString()}\``,
-              )
-              return
-            }
-
-            const urlReference = {
-              type: "import",
-              specifier,
-              url,
-              atImportNode,
-              urlNode,
-            }
-            const urlVisitorReturnValue = urlVisitor(urlReference)
-            if (
-              urlVisitorReturnValue &&
-              urlVisitorReturnValue !== urlNode.value
-            ) {
-              urlNode.value = urlVisitorReturnValue
-              const newParams = parsed.toString()
-              const newAtImportRule = new AtRule({
-                name: "import",
-                params: newParams,
-                source: atImportNode.source,
-              })
-              atImportNode.replaceWith(newAtImportRule)
-            }
-          },
-        },
-        Declaration: (declarationNode) => {
-          const parsed = parseCssValue(declarationNode.value)
-          const urlMutations = []
-
-          walkUrls(parsed, {
-            stringifyCssNodes,
-            visitor: ({ url, urlNode }) => {
-              // Empty URL
-              if (!urlNode || url.length === 0) {
-                declarationNode.warn(
-                  result,
-                  `Empty URL in \`${declarationNode.toString()}\``,
-                )
-                return
-              }
-
-              // Skip Data URI
-              if (isDataUrl(url)) {
-                return
-              }
-
-              const specifier = url
-              url = resolveUrl(specifier, fileSystemPathToUrl(from))
-
-              const urlReference = {
-                type: "asset",
-                specifier,
-                url,
-                declarationNode,
-                urlNode,
-              }
-
-              const urlVisitorReturnValue = urlVisitor(urlReference)
-              if (urlVisitorReturnValue) {
-                urlMutations.push(() => {
-                  urlNode.value = urlVisitorReturnValue
-                })
-              }
-            },
-          })
-
-          if (urlMutations.length) {
-            mutations.push(() => {
-              urlMutations.forEach((urlMutation) => {
-                urlMutation()
-              })
-              declarationNode.value = parsed.toString()
-            })
-          }
-        },
-        OnceExit: () => {
-          mutations.forEach((mutation) => {
-            mutation()
-          })
-        },
-      }
-    },
-  }
-}
-postCssPluginUrlVisitor.postcss = true
-
-const walkUrls = (parsed, { stringifyCssNodes, visitor }) => {
-  parsed.walk((node) => {
-    // https://github.com/andyjansson/postcss-functions
-    if (isUrlFunctionNode(node)) {
-      const { nodes } = node
-      const [urlNode] = nodes
-      const url =
-        urlNode && urlNode.type === "string"
-          ? urlNode.value
-          : stringifyCssNodes(nodes)
-      visitor({
-        url: url.trim(),
-        urlNode,
-      })
-      return
-    }
-
-    if (isImageSetFunctionNode(node)) {
-      Array.from(node.nodes).forEach((childNode) => {
-        if (childNode.type === "string") {
-          visitor({
-            url: childNode.value.trim(),
-            urlNode: childNode,
-          })
-          return
-        }
-
-        if (isUrlFunctionNode(node)) {
-          const { nodes } = childNode
-          const [urlNode] = nodes
-          const url =
-            urlNode && urlNode.type === "string"
-              ? urlNode.value
-              : stringifyCssNodes(nodes)
-          visitor({
-            url: url.trim(),
-            urlNode,
-          })
-          return
-        }
-      })
-    }
-  })
-}
-
-const isUrlFunctionNode = (node) => {
-  return node.type === "function" && /^url$/i.test(node.value)
-}
-
-const isImageSetFunctionNode = (node) => {
-  return (
-    node.type === "function" && /^(?:-webkit-)?image-set$/i.test(node.value)
-  )
-}
-
-const isDataUrl = (url) => {
-  return /data:[^\n\r;]+?(?:;charset=[^\n\r;]+?)?;base64,([\d+/A-Za-z]+={0,2})/.test(
-    url,
-  )
-}

package/src/internal/building/css/replace_css_urls.js

@@ -1,68 +0,0 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  urlToFileSystemPath,
-} from "@jsenv/filesystem"
-
-import { require } from "@jsenv/core/src/internal/require.js"
-
-import { applyPostCss } from "./apply_post_css.js"
-import { postCssPluginUrlVisitor } from "./postcss_plugin_url_visitor.js"
-
-export const replaceCssUrls = async ({
-  url,
-  code,
-  map,
-  urlVisitor,
-  cssConcatenation = false,
-  loadCssImport,
-  cssMinification = false,
-  cssMinificationOptions,
-} = {}) => {
-  const result = await applyPostCss({
-    code,
-    url,
-    plugins: [
-      postCssPluginUrlVisitor({ urlVisitor }),
-      ...(cssConcatenation
-        ? [await getCssConcatenationPlugin({ url, loadCssImport })]
-        : []),
-      ...(cssMinification
-        ? [await getCssMinificationPlugin(cssMinificationOptions)]
-        : []),
-    ],
-  })
-  code = result.code
-  map = result.map
-  return {
-    code,
-    map,
-  }
-}
-
-const getCssConcatenationPlugin = async ({ loadCssImport }) => {
-  const postcssImport = require("postcss-import")
-  return postcssImport({
-    resolve: (id, basedir) => {
-      const url = new URL(id, assertAndNormalizeDirectoryUrl(basedir)).href
-      return urlToFileSystemPath(url)
-    },
-    load: (id) => {
-      return loadCssImport(id)
-    },
-  })
-}
-
-const getCssMinificationPlugin = async (cssMinificationOptions = {}) => {
-  const cssnano = require("cssnano")
-  const cssnanoDefaultPreset = require("cssnano-preset-default")
-  return cssnano({
-    preset: cssnanoDefaultPreset({
-      ...cssMinificationOptions,
-      // just to show how you could configure dicard comment plugin from css nano
-      // https://github.com/cssnano/cssnano/tree/master/packages/cssnano-preset-default
-      // discardComments: {
-      //   remove: () => false,
-      // },
-    }),
-  })
-}

package/src/internal/building/global_format/es_to_system.js

@@ -1,34 +0,0 @@
-export const esToSystem = async ({ code, url, map }) => {
-  const { rollup } = await import("rollup")
-  const rollupBuild = await rollup({
-    input: url,
-    plugins: [
-      {
-        name: "es-to-system",
-        resolveId: (id) => {
-          if (id === url) {
-            return id
-          }
-          return { external: true }
-        },
-        load: (id) => {
-          if (id === url) {
-            return code
-          }
-          return null
-        },
-      },
-    ],
-  })
-  const { output } = await rollupBuild.generate({
-    format: "system",
-    sourcemap: true,
-  })
-  const firstChunk = output[0]
-  code = firstChunk.code
-  map = firstChunk.map
-  return {
-    code,
-    map,
-  }
-}

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

@@ -1,29 +0,0 @@
-export const collectNodesMutations = (nodes, params, ressource, candidates) => {
-  const mutations = []
-  nodes.forEach((node) => {
-    mutations.push(
-      ...collectNodeMutations(node, params, ressource, nodes, candidates),
-    )
-  })
-  return mutations
-}
-
-const collectNodeMutations = (node, params, ressource, nodes, candidates) => {
-  let firstValueReturned
-  candidates.find((candidate) => {
-    const returnValue = candidate(node, params, ressource, nodes)
-    if (returnValue === null || returnValue === undefined) {
-      return false
-    }
-    firstValueReturned = returnValue
-    return true
-  })
-
-  if (typeof firstValueReturned === "function") {
-    return [firstValueReturned]
-  }
-  if (Array.isArray(firstValueReturned)) {
-    return firstValueReturned
-  }
-  return []
-}

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

@@ -1,70 +0,0 @@
-import {
-  parseHtmlString,
-  visitHtmlAst,
-  getHtmlNodeAttributeByName,
-  getHtmlNodeTextNode,
-} from "@jsenv/core/src/internal/compile_server/html/html_ast.js"
-
-export const importMapsFromHtml = (htmlSource) => {
-  const importmaps = []
-  const htmlAst = parseHtmlString(htmlSource)
-  visitHtmlAst(htmlAst, (htmlNode) => {
-    if (htmlNode.nodeName !== "script") {
-      return
-    }
-    const typeAttribute = getHtmlNodeAttributeByName(htmlNode, "type")
-    if (!typeAttribute) {
-      return
-    }
-
-    const type = typeAttribute.value
-    if (type !== "importmap") {
-      return
-    }
-
-    const srcAttribute = getHtmlNodeAttributeByName(htmlNode, "src")
-    if (srcAttribute) {
-      importmaps.push({
-        type: "remote",
-        htmlNode,
-        src: srcAttribute.value,
-      })
-      return
-    }
-
-    const textNode = getHtmlNodeTextNode(htmlNode)
-    importmaps.push({
-      type: "inline",
-      htmlNode,
-      text: textNode.value,
-    })
-  })
-  return importmaps
-}
-
-export const preloadLinksFromHtml = (htmlSource) => {
-  const preloadLinks = []
-  const htmlAst = parseHtmlString(htmlSource)
-  visitHtmlAst(htmlAst, (htmlNode) => {
-    if (htmlNode.nodeName !== "link") {
-      return
-    }
-    const relAttribute = getHtmlNodeAttributeByName(htmlNode, "rel")
-    if (!relAttribute) {
-      return
-    }
-    const relAttributeValue = relAttribute.value
-    if (
-      relAttributeValue !== "preload" &&
-      relAttributeValue !== "modulepreload"
-    ) {
-      return
-    }
-
-    preloadLinks.push({
-      htmlNode,
-      rel: relAttributeValue,
-    })
-  })
-  return preloadLinks
-}