@jsenv/ast 1.1.0

package/src/html/html_node_position.js

@@ -0,0 +1,122 @@
+import {
+  getHtmlNodeAttribute,
+  setHtmlNodeAttributes,
+} from "./html_node_attributes.js"
+
+export const storeHtmlNodePosition = (node) => {
+  const originalPositionAttributeName = `original-position`
+  const originalPosition = getHtmlNodeAttribute(
+    node,
+    originalPositionAttributeName,
+  )
+  if (originalPosition !== undefined) {
+    return true
+  }
+  const { sourceCodeLocation } = node
+  if (!sourceCodeLocation) {
+    return false
+  }
+  const { startLine, startCol, endLine, endCol } = sourceCodeLocation
+  setHtmlNodeAttributes(node, {
+    [originalPositionAttributeName]: `${startLine}:${startCol};${endLine}:${endCol}`,
+  })
+  return true
+}
+export const storeHtmlNodeAttributePosition = (node, attributeName) => {
+  const { sourceCodeLocation } = node
+  if (!sourceCodeLocation) {
+    return false
+  }
+  const attributeValue = getHtmlNodeAttribute(node, attributeName)
+  if (attributeValue === undefined) {
+    return false
+  }
+  const attributeLocation = sourceCodeLocation.attrs[attributeName]
+  if (!attributeLocation) {
+    return false
+  }
+  const originalPositionAttributeName = `original-${attributeName}-position`
+  const originalPosition = getHtmlNodeAttribute(
+    node,
+    originalPositionAttributeName,
+  )
+  if (originalPosition !== undefined) {
+    return true
+  }
+  const { startLine, startCol, endLine, endCol } = attributeLocation
+  setHtmlNodeAttributes(node, {
+    [originalPositionAttributeName]: `${startLine}:${startCol};${endLine}:${endCol}`,
+  })
+  return true
+}
+
+export const getHtmlNodePosition = (node, { preferOriginal = false } = {}) => {
+  const position = {}
+  const { sourceCodeLocation } = node
+  if (sourceCodeLocation) {
+    const { startLine, startCol, endLine, endCol } = sourceCodeLocation
+    Object.assign(position, {
+      line: startLine,
+      lineEnd: endLine,
+      column: startCol,
+      columnEnd: endCol,
+    })
+  }
+  const originalPosition = getHtmlNodeAttribute(node, "original-position")
+  if (originalPosition === undefined) {
+    return position
+  }
+  const [start, end] = originalPosition.split(";")
+  const [originalLine, originalColumn] = start.split(":")
+  const [originalLineEnd, originalColumnEnd] = end.split(":")
+  Object.assign(position, {
+    originalLine: parseInt(originalLine),
+    originalColumn: parseInt(originalColumn),
+    originalLineEnd: parseInt(originalLineEnd),
+    originalColumnEnd: parseInt(originalColumnEnd),
+  })
+  if (preferOriginal) {
+    position.line = position.originalLine
+    position.column = position.originalColumn
+    position.lineEnd = position.originalLineEnd
+    position.columnEnd = position.originalColumnEnd
+    position.isOriginal = true
+  }
+  return position
+}
+export const getHtmlNodeAttributePosition = (node, attributeName) => {
+  const position = {}
+  const { sourceCodeLocation } = node
+  if (sourceCodeLocation) {
+    const attributeLocation = sourceCodeLocation.attrs[attributeName]
+    if (attributeLocation) {
+      Object.assign(position, {
+        line: attributeLocation.startLine,
+        column: attributeLocation.startCol,
+      })
+    }
+  }
+  const originalPositionAttributeName =
+    attributeName === "generated-from-src"
+      ? "original-src-position"
+      : attributeName === "generated-from-href"
+      ? "original-href-position"
+      : `original-${attributeName}-position`
+  const originalPosition = getHtmlNodeAttribute(
+    node,
+    originalPositionAttributeName,
+  )
+  if (originalPosition === undefined) {
+    return position
+  }
+  const [start, end] = originalPosition.split(";")
+  const [originalLine, originalColumn] = start.split(":")
+  const [originalLineEnd, originalColumnEnd] = end.split(":")
+  Object.assign(position, {
+    originalLine: parseInt(originalLine),
+    originalColumn: parseInt(originalColumn),
+    originalLineEnd: parseInt(originalLineEnd),
+    originalColumnEnd: parseInt(originalColumnEnd),
+  })
+  return position
+}

package/src/html/html_node_text.js

@@ -0,0 +1,32 @@
+export const getHtmlNodeText = (htmlNode) => {
+  const textNode = getTextNode(htmlNode)
+  return textNode ? textNode.value : undefined
+}
+
+const getTextNode = (htmlNode) => {
+  const firstChild = htmlNode.childNodes[0]
+  const textNode =
+    firstChild && firstChild.nodeName === "#text" ? firstChild : null
+  return textNode
+}
+
+export const removeHtmlNodeText = (htmlNode) => {
+  const textNode = getTextNode(htmlNode)
+  if (textNode) {
+    htmlNode.childNodes = []
+  }
+}
+
+export const setHtmlNodeText = (htmlNode, textContent) => {
+  const textNode = getTextNode(htmlNode)
+  if (textNode) {
+    textNode.value = textContent
+  } else {
+    const newTextNode = {
+      nodeName: "#text",
+      value: textContent,
+      parentNode: htmlNode,
+    }
+    htmlNode.childNodes.splice(0, 0, newTextNode)
+  }
+}

package/src/html/html_parse.js

@@ -0,0 +1,89 @@
+import { parse, serialize, parseFragment } from "parse5"
+
+import {
+  getHtmlNodeAttribute,
+  setHtmlNodeAttributes,
+} from "./html_node_attributes.js"
+import {
+  storeHtmlNodePosition,
+  storeHtmlNodeAttributePosition,
+} from "./html_node_position.js"
+import { findHtmlChildNode, visitHtmlNodes } from "./html_search.js"
+import { getHtmlNodeText } from "./html_node_text.js"
+
+export const parseHtmlString = (
+  htmlString,
+  { storeOriginalPositions = true } = {},
+) => {
+  const htmlAst = parse(htmlString, { sourceCodeLocationInfo: true })
+  if (storeOriginalPositions) {
+    const htmlNode = findHtmlChildNode(
+      htmlAst,
+      (node) => node.nodeName === "html",
+    )
+    const stored = getHtmlNodeAttribute(htmlNode, "original-position-stored")
+    if (stored === undefined) {
+      visitHtmlNodes(htmlAst, {
+        "*": (node) => {
+          if (node.nodeName === "script" || node.nodeName === "style") {
+            const htmlNodeText = getHtmlNodeText(node)
+            if (htmlNodeText !== undefined) {
+              storeHtmlNodePosition(node)
+            }
+          }
+          storeHtmlNodeAttributePosition(node, "src")
+          storeHtmlNodeAttributePosition(node, "href")
+        },
+      })
+      setHtmlNodeAttributes(htmlNode, {
+        "original-position-stored": "",
+      })
+    }
+  }
+  return htmlAst
+}
+
+export const stringifyHtmlAst = (
+  htmlAst,
+  { removeOriginalPositionAttributes = false } = {},
+) => {
+  if (removeOriginalPositionAttributes) {
+    const htmlNode = findHtmlChildNode(
+      htmlAst,
+      (node) => node.nodeName === "html",
+    )
+    const storedAttribute = getHtmlNodeAttribute(
+      htmlNode,
+      "original-position-stored",
+    )
+    if (storedAttribute !== undefined) {
+      setHtmlNodeAttributes(htmlNode, {
+        "original-position-stored": undefined,
+      })
+      visitHtmlNodes(htmlAst, {
+        "*": (node) => {
+          setHtmlNodeAttributes(node, {
+            "original-position": undefined,
+            "original-src-position": undefined,
+            "original-href-position": undefined,
+            "injected-by": undefined,
+            "generated-by": undefined,
+            "generated-from-src": undefined,
+            "generated-from-href": undefined,
+          })
+        },
+      })
+    }
+  }
+  const htmlString = serialize(htmlAst)
+
+  return htmlString
+}
+
+export const parseSvgString = (svgString) => {
+  const svgAst = parseFragment(svgString, {
+    sourceCodeLocationInfo: true,
+  })
+  return svgAst
+}
+export const stringifySvgAst = stringifyHtmlAst

package/src/html/html_search.js

@@ -0,0 +1,64 @@
+import { getHtmlNodeAttribute } from "./html_node_attributes.js"
+
+export const visitHtmlNodes = (htmlAst, visitors) => {
+  const visitNode = (node) => {
+    const visitor = visitors[node.nodeName] || visitors["*"]
+    if (visitor) {
+      const callbackReturnValue = visitor(node)
+      if (callbackReturnValue === "stop") {
+        return
+      }
+    }
+    const { childNodes } = node
+    if (childNodes) {
+      let i = 0
+      while (i < childNodes.length) {
+        visitNode(childNodes[i++])
+      }
+    }
+  }
+  visitNode(htmlAst)
+}
+
+export const findHtmlNode = (htmlAst, predicate) => {
+  let nodeMatching = null
+  visitHtmlNodes(htmlAst, {
+    "*": (node) => {
+      if (predicate(node)) {
+        nodeMatching = node
+        return "stop"
+      }
+      return null
+    },
+  })
+  return nodeMatching
+}
+
+export const findHtmlChildNode = (htmlNode, predicate) => {
+  const { childNodes = [] } = htmlNode
+  return childNodes.find(predicate)
+}
+
+export const findHtmlNodes = (htmlAst, predicate) => {
+  const nodes = []
+  visitHtmlNodes(htmlAst, {
+    "*": (node) => {
+      if (predicate(node)) {
+        nodes.push(node)
+      }
+      return null
+    },
+  })
+  return nodes
+}
+
+export const findHtmlNodeByTagName = (htmlAst, tagName) => {
+  return findHtmlNode(htmlAst, (node) => node.nodeName === tagName)
+}
+
+export const findHtmlNodeById = (htmlAst, id) => {
+  return findHtmlNode(htmlAst, (node) => {
+    const idCandidate = getHtmlNodeAttribute(node, "id")
+    return idCandidate === id
+  })
+}

package/src/html/html_src_set.js

@@ -0,0 +1,18 @@
+export const parseSrcSet = (srcset) => {
+  const srcCandidates = []
+  srcset.split(",").forEach((set) => {
+    const [specifier, descriptor] = set.trim().split(" ")
+    srcCandidates.push({
+      specifier,
+      descriptor,
+    })
+  })
+  return srcCandidates
+}
+
+export const stringifySrcSet = (srcCandidates) => {
+  const srcset = srcCandidates
+    .map(({ specifier, descriptor }) => `${specifier} ${descriptor}`)
+    .join(", ")
+  return srcset
+}

package/src/js/apply_babel_plugins.js

@@ -0,0 +1,100 @@
+/*
+ * Useful when writin a babel plugin:
+ * - https://astexplorer.net/
+ * - https://bvaughn.github.io/babel-repl
+ */
+import { fileURLToPath } from "node:url"
+
+import { createJsParseError } from "./js_parse_error.js"
+
+export const applyBabelPlugins = async ({
+  babelPlugins,
+  urlInfo,
+  ast,
+  options = {},
+}) => {
+  const sourceType = {
+    js_module: "module",
+    js_classic: "classic",
+    [urlInfo.type]: undefined,
+  }[urlInfo.type]
+  const url = urlInfo.originalUrl
+  const generatedUrl = urlInfo.generatedUrl
+  const content = urlInfo.content
+
+  if (babelPlugins.length === 0) {
+    return { code: content }
+  }
+  const { transformAsync, transformFromAstAsync } = await import("@babel/core")
+  const sourceFileName = url.startsWith("file:")
+    ? fileURLToPath(url)
+    : undefined
+  options = {
+    ast: false,
+    // https://babeljs.io/docs/en/options#source-map-options
+    sourceMaps: true,
+    sourceFileName,
+    filename: generatedUrl
+      ? generatedUrl.startsWith("file:")
+        ? fileURLToPath(url)
+        : undefined
+      : sourceFileName,
+    configFile: false,
+    babelrc: false,
+    highlightCode: false,
+    // consider using startColumn and startLine for inline scripts?
+    // see https://github.com/babel/babel/blob/3ee9db7afe741f4d2f7933c519d8e7672fccb08d/packages/babel-parser/src/options.js#L36-L39
+    parserOpts: {
+      sourceType,
+      // allowAwaitOutsideFunction: true,
+      plugins: [
+        // "importMeta",
+        // "topLevelAwait",
+        "dynamicImport",
+        "importAssertions",
+        "jsx",
+        "classProperties",
+        "classPrivateProperties",
+        "classPrivateMethods",
+        ...(useTypeScriptExtension(url) ? ["typescript"] : []),
+        ...(options.parserPlugins || []),
+      ].filter(Boolean),
+    },
+    generatorOpts: {
+      compact: false,
+    },
+    plugins: babelPlugins,
+    ...options,
+  }
+  try {
+    if (ast) {
+      const result = await transformFromAstAsync(ast, content, options)
+      return result
+    }
+    const result = await transformAsync(content, options)
+    return result
+  } catch (error) {
+    if (error && error.code === "BABEL_PARSE_ERROR") {
+      throw createJsParseError({
+        message: error.message,
+        reasonCode: error.reasonCode,
+        content,
+        url,
+        line: error.loc.line,
+        column: error.loc.column,
+      })
+    }
+    throw error
+  }
+}
+
+const useTypeScriptExtension = (url) => {
+  const { pathname } = new URL(url)
+  return pathname.endsWith(".ts") || pathname.endsWith(".tsx")
+}
+
+// const pattern = [
+//   "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+//   "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))",
+// ].join("|")
+// const ansiRegex = new RegExp(pattern, "g")

package/src/js/babel_utils.js

@@ -0,0 +1,64 @@
+import { require } from "../require.js"
+
+// https://github.com/babel/babel/tree/master/packages/babel-helper-module-imports
+export const injectJsImport = ({
+  programPath,
+  namespace,
+  name,
+  from,
+  nameHint,
+  sideEffect,
+}) => {
+  const {
+    addNamespace,
+    addDefault,
+    addNamed,
+    addSideEffect,
+  } = require("@babel/helper-module-imports")
+
+  if (namespace) {
+    return addNamespace(programPath, from, {
+      nameHint,
+    })
+  }
+  if (name) {
+    return addNamed(programPath, name, from)
+  }
+  if (sideEffect) {
+    return addSideEffect(programPath, from)
+  }
+  return addDefault(programPath, from, {
+    nameHint,
+  })
+}
+
+const generateExpressionAst = (expression, options) => {
+  const { parseExpression } = require("@babel/parser")
+
+  const ast = parseExpression(expression, options)
+  return ast
+}
+
+export const generateValueAst = (value) => {
+  const valueAst = generateExpressionAst(
+    value === undefined
+      ? "undefined"
+      : value === null
+      ? "null"
+      : JSON.stringify(value),
+  )
+  return valueAst
+}
+
+export const injectAstAfterImport = (programPath, ast) => {
+  const bodyNodePaths = programPath.get("body")
+  const notAnImportIndex = bodyNodePaths.findIndex(
+    (bodyNodePath) => bodyNodePath.node.type !== "ImportDeclaration",
+  )
+  const notAnImportNodePath = bodyNodePaths[notAnImportIndex]
+  if (notAnImportNodePath) {
+    notAnImportNodePath.insertBefore(ast)
+  } else {
+    bodyNodePaths[0].insertBefore(ast)
+  }
+}

package/src/js/js_parse_error.js

@@ -0,0 +1,15 @@
+export const createJsParseError = ({
+  message,
+  reasonCode,
+  url,
+  line,
+  column,
+}) => {
+  const parseError = new Error(message)
+  parseError.reasonCode = reasonCode
+  parseError.code = "PARSE_ERROR"
+  parseError.url = url
+  parseError.line = line
+  parseError.column = column
+  return parseError
+}

package/src/js/js_static_analysis/helpers.js

@@ -0,0 +1,17 @@
+export const getTypePropertyNode = (node) => {
+  if (node.type !== "ObjectExpression") {
+    return null
+  }
+  const { properties } = node
+  return properties.find((property) => {
+    return (
+      property.type === "Property" &&
+      property.key.type === "Identifier" &&
+      property.key.name === "type"
+    )
+  })
+}
+
+export const isStringLiteralNode = (node) => {
+  return node.type === "Literal" && typeof node.value === "string"
+}

package/src/js/js_static_analysis/import_export.js

@@ -0,0 +1,135 @@
+import { isStringLiteralNode } from "./helpers.js"
+
+export const analyzeImportDeclaration = (node, { onUrl }) => {
+  const specifierNode = node.source
+  const assertionInfo = extractImportAssertionsInfo(node)
+  onUrl({
+    type: "js_import_export",
+    subtype: "import_static",
+    specifier: specifierNode.value,
+    specifierStart: specifierNode.start,
+    specifierEnd: specifierNode.end,
+    specifierLine: specifierNode.loc.start.line,
+    specifierColumn: specifierNode.loc.start.column,
+    expectedType: assertionInfo ? assertionInfo.assert.type : "js_module",
+    ...assertionInfo,
+  })
+}
+export const analyzeImportExpression = (node, { onUrl }) => {
+  const specifierNode = node.source
+  if (!isStringLiteralNode(specifierNode)) {
+    return
+  }
+  const assertionInfo = extractImportAssertionsInfo(node)
+
+  onUrl({
+    type: "js_import_export",
+    subtype: "import_dynamic",
+    specifier: specifierNode.value,
+    specifierStart: specifierNode.start,
+    specifierEnd: specifierNode.end,
+    specifierLine: specifierNode.loc.start.line,
+    specifierColumn: specifierNode.loc.start.column,
+    expectedType: assertionInfo ? assertionInfo.assert.type : "js_module",
+    ...assertionInfo,
+  })
+}
+export const analyzeExportNamedDeclaration = (node, { onUrl }) => {
+  const specifierNode = node.source
+  if (!specifierNode) {
+    // This export has no "source", so it's probably
+    // a local variable or function, e.g.
+    // export { varName }
+    // export const constName = ...
+    // export function funcName() {}
+    return
+  }
+  onUrl({
+    type: "js_import_export",
+    subtype: "export_named",
+    specifier: specifierNode.value,
+    specifierStart: specifierNode.start,
+    specifierEnd: specifierNode.end,
+    specifierLine: specifierNode.loc.start.line,
+    specifierColumn: specifierNode.loc.start.column,
+  })
+}
+export const analyzeExportAllDeclaration = (node, { onUrl }) => {
+  const specifierNode = node.source
+  onUrl({
+    type: "js_import_export",
+    subtype: "export_all",
+    specifier: specifierNode.value,
+    specifierStart: specifierNode.start,
+    specifierEnd: specifierNode.end,
+    specifierLine: specifierNode.loc.start.line,
+    specifierColumn: specifierNode.loc.start.column,
+  })
+}
+
+const extractImportAssertionsInfo = (node) => {
+  if (node.type === "ImportDeclaration") {
+    // static import
+    const { assertions } = node
+    if (!assertions) {
+      return null
+    }
+    if (assertions.length === 0) {
+      return null
+    }
+    const typeAssertionNode = assertions.find(
+      (assertion) => assertion.key.name === "type",
+    )
+    if (!typeAssertionNode) {
+      return null
+    }
+    const typeNode = typeAssertionNode.value
+    if (!isStringLiteralNode(typeNode)) {
+      return null
+    }
+    return {
+      assertNode: typeAssertionNode,
+      assert: {
+        type: typeNode.value,
+      },
+    }
+  }
+  // dynamic import
+  const args = node.arguments
+  if (!args) {
+    // acorn keeps node.arguments undefined for dynamic import without a second argument
+    return null
+  }
+  const firstArgNode = args[0]
+  if (!firstArgNode) {
+    return null
+  }
+  const { properties } = firstArgNode
+  const assertProperty = properties.find((property) => {
+    return property.key.name === "assert"
+  })
+  if (!assertProperty) {
+    return null
+  }
+  const assertValueNode = assertProperty.value
+  if (assertValueNode.type !== "ObjectExpression") {
+    return null
+  }
+  const assertValueProperties = assertValueNode.properties
+  const typePropertyNode = assertValueProperties.find((property) => {
+    return property.key.name === "type"
+  })
+  if (!typePropertyNode) {
+    return null
+  }
+  const typePropertyValue = typePropertyNode.value
+  if (!isStringLiteralNode(typePropertyValue)) {
+    return null
+  }
+  return {
+    assertNode: firstArgNode,
+    assert: {
+      type: typePropertyValue.value,
+    },
+  }
+}