banhaten 0.1.3 → 0.2.0

package/src/cli/source-scanner.js

@@ -0,0 +1,686 @@
+// Target-agnostic scanner primitives shared by the JSONC and Vite config
+// editors. Nothing here names a product: messages describe the syntax problem
+// only, and each caller prefixes the file and config dialect it was reading.
+// Keeping that split is what stops a malformed tsconfig from being reported as
+// a broken Vite config.
+
+export function findExportDefaultExpressionStart(source) {
+  let index = 0
+
+  while (index < source.length) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (!matchIdentifier(source, index, "export")) {
+      index += 1
+      continue
+    }
+
+    const defaultStart = skipWhitespaceAndComments(source, index + "export".length)
+    if (!matchIdentifier(source, defaultStart, "default")) {
+      index += "export".length
+      continue
+    }
+
+    return skipWhitespaceAndComments(source, defaultStart + "default".length)
+  }
+
+  return -1
+}
+
+export function createBracketRange(source, start, open) {
+  const close = open === "{" ? "}" : open === "[" ? "]" : ")"
+  const end = findMatchingBracket(source, start, open, close)
+  return { start, end: end + 1 }
+}
+
+export function expectObjectLiteralValue(source, property, message) {
+  const valueStart = skipWhitespaceAndComments(source, property.valueStart)
+  if (source[valueStart] !== "{") throw new Error(message)
+  return createBracketRange(source, valueStart, "{")
+}
+
+export function expectArrayLiteralValue(source, property, message) {
+  const valueStart = skipWhitespaceAndComments(source, property.valueStart)
+  if (source[valueStart] !== "[") throw new Error(message)
+  return createBracketRange(source, valueStart, "[")
+}
+
+export function findObjectProperty(source, objectRange, propertyName) {
+  const bodyEnd = objectRange.end - 1
+  let index = objectRange.start + 1
+
+  while (index < bodyEnd) {
+    index = skipWhitespaceCommentsAndCommas(source, index, bodyEnd)
+    if (index >= bodyEnd) return null
+
+    const propertyStart = index
+    const name = readPropertyName(source, index)
+    const propertyEnd = findTopLevelCommaOrEnd(source, propertyStart, bodyEnd)
+
+    if (!name) {
+      index = propertyEnd + 1
+      continue
+    }
+
+    index = skipWhitespaceAndComments(source, name.end)
+    if (source[index] !== ":") {
+      if (name.name === propertyName) {
+        throw new Error(
+          `${propertyName} must be a normal object property.`
+        )
+      }
+      index = propertyEnd + 1
+      continue
+    }
+
+    if (name.name === propertyName) {
+      return {
+        name: name.name,
+        start: propertyStart,
+        end: propertyEnd,
+        valueStart: skipWhitespaceAndComments(source, index + 1),
+        valueEnd: propertyEnd,
+      }
+    }
+
+    index = propertyEnd + 1
+  }
+
+  return null
+}
+
+export function readObjectPropertyNames(source, objectRange) {
+  const bodyEnd = objectRange.end - 1
+  const names = []
+  let index = objectRange.start + 1
+
+  while (index < bodyEnd) {
+    index = skipWhitespaceCommentsAndCommas(source, index, bodyEnd)
+    if (index >= bodyEnd) break
+
+    const propertyEnd = findTopLevelCommaOrEnd(source, index, bodyEnd)
+    const name = readPropertyName(source, index)
+    if (name) names.push(name.name)
+    index = propertyEnd + 1
+  }
+
+  return names
+}
+
+export function readPropertyName(source, index) {
+  if (source[index] === "\"" || source[index] === "'") {
+    const literal = readStringLiteral(source, index)
+    return literal ? { name: literal.value, end: literal.end } : null
+  }
+
+  return readIdentifierAt(source, index)
+}
+
+export function insertObjectProperty(source, objectRange, propertyText) {
+  const insertAt = objectRange.start + 1
+  const bodyEnd = objectRange.end - 1
+  const body = source.slice(insertAt, bodyEnd)
+  const hasContent = body.trim().length > 0
+  const propertyIndent = detectObjectChildIndent(source, objectRange)
+  const closeIndent = getLineIndent(source, bodyEnd)
+  const indentedProperty = indentMultiline(propertyText, propertyIndent)
+
+  if (!hasContent) {
+    return `${source.slice(0, insertAt)}\n${indentedProperty}\n${closeIndent}${source.slice(insertAt)}`
+  }
+
+  const needsTrailingNewline = source[insertAt] !== "\n" && source[insertAt] !== "\r"
+  const insertion = `\n${indentedProperty}${needsTrailingNewline ? "\n" : ""}`
+  return `${source.slice(0, insertAt)}${insertion}${source.slice(insertAt)}`
+}
+
+export function appendObjectProperty(source, objectRange, propertyText) {
+  const bodyStart = objectRange.start + 1
+  const bodyEnd = objectRange.end - 1
+  const body = source.slice(bodyStart, bodyEnd)
+
+  if (body.trim().length === 0) {
+    return insertObjectProperty(source, objectRange, propertyText)
+  }
+
+  const contentEnd = trimEndIndex(source, bodyStart, bodyEnd)
+  const hasNewline = bodyIncludesNewline(source, bodyStart, bodyEnd)
+  const hasTrailingComma = previousCodeChar(source, contentEnd) === ","
+  const propertyIndent = detectObjectChildIndent(source, objectRange)
+  const indentedProperty = indentMultiline(propertyText, propertyIndent)
+
+  if (!hasNewline) {
+    const separator = hasTrailingComma ? " " : ", "
+    return `${source.slice(0, contentEnd)}${separator}${propertyText}${source.slice(contentEnd)}`
+  }
+
+  const separator = hasTrailingComma ? "\n" : ",\n"
+  return `${source.slice(0, contentEnd)}${separator}${indentedProperty}${source.slice(contentEnd)}`
+}
+
+function detectObjectChildIndent(source, objectRange) {
+  const bodyEnd = objectRange.end - 1
+  let index = objectRange.start + 1
+
+  while (index < bodyEnd) {
+    if (source[index] === "\n") {
+      const next = skipHorizontalWhitespace(source, index + 1)
+      if (next < bodyEnd && source[next] !== "\n" && source[next] !== "\r") {
+        return source.slice(index + 1, next)
+      }
+    }
+    index += 1
+  }
+
+  return `${getLineIndent(source, objectRange.start)}  `
+}
+
+export function appendArrayElement(source, arrayRange, elementText) {
+  const bodyStart = arrayRange.start + 1
+  const bodyEnd = arrayRange.end - 1
+  const body = source.slice(bodyStart, bodyEnd)
+
+  if (body.trim().length === 0) {
+    return `${source.slice(0, bodyStart)}${elementText}${source.slice(bodyStart)}`
+  }
+
+  const contentEnd = trimEndIndex(source, bodyStart, bodyEnd)
+  const hasNewline = bodyIncludesNewline(source, bodyStart, bodyEnd)
+  const hasTrailingComma = previousCodeChar(source, contentEnd) === ","
+
+  if (!hasNewline) {
+    const separator = hasTrailingComma ? " " : ", "
+    return `${source.slice(0, contentEnd)}${separator}${elementText}${source.slice(contentEnd)}`
+  }
+
+  const closeIndent = getLineIndent(source, bodyEnd)
+  const elementIndent = `${closeIndent}  `
+  const separator = hasTrailingComma ? "\n" : ",\n"
+  return `${source.slice(0, contentEnd)}${separator}${elementIndent}${elementText},${source.slice(contentEnd)}`
+}
+
+export function arrayHasCallExpression(source, arrayRange, localName) {
+  const bodyEnd = arrayRange.end - 1
+  let index = arrayRange.start + 1
+
+  while (index < bodyEnd) {
+    index = skipWhitespaceCommentsAndCommas(source, index, bodyEnd)
+    if (index >= bodyEnd) return false
+
+    const elementEnd = findTopLevelCommaOrEnd(source, index, bodyEnd)
+    if (startsWithCallExpression(source, index, elementEnd, localName)) {
+      return true
+    }
+    index = elementEnd + 1
+  }
+
+  return false
+}
+
+function startsWithCallExpression(source, start, end, localName) {
+  const index = skipWhitespaceAndComments(source, start)
+  if (!matchIdentifier(source, index, localName)) return false
+
+  const callStart = skipWhitespaceAndComments(source, index + localName.length)
+  if (source[callStart] !== "(") return false
+
+  const callEnd = createBracketRange(source, callStart, "(").end
+  const next = skipWhitespaceAndComments(source, callEnd)
+  return next <= end
+}
+
+export function parseImportDeclarations(source) {
+  const declarations = []
+  let index = 0
+
+  while (index < source.length) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (!matchIdentifier(source, index, "import")) {
+      index += 1
+      continue
+    }
+
+    const clauseStart = skipWhitespaceAndComments(source, index + "import".length)
+    if (source[clauseStart] === ".") {
+      index = clauseStart + 1
+      continue
+    }
+    if (source[clauseStart] === "(") {
+      index = clauseStart + 1
+      continue
+    }
+
+    const end = findImportDeclarationEnd(source, index)
+    const declaration = source.slice(index, end)
+    const moduleSpecifier = getImportModuleSpecifier(declaration)
+
+    if (moduleSpecifier) {
+      declarations.push({
+        start: index,
+        end,
+        moduleSpecifier,
+        defaultLocal: getDefaultImportLocal(declaration),
+        namedLocals: getNamedImportLocals(declaration),
+      })
+    }
+
+    index = end
+  }
+
+  return declarations
+}
+
+function findImportDeclarationEnd(source, start) {
+  const stack = []
+  let sawModuleSpecifier = false
+  let index = start
+
+  while (index < source.length) {
+    const skipped = skipComment(source, index)
+    if (skipped !== index) {
+      index = skipped
+      continue
+    }
+
+    if (source[index] === "\"" || source[index] === "'") {
+      const literal = readStringLiteral(source, index)
+      if (!literal) return source.length
+      sawModuleSpecifier = true
+      index = literal.end
+      continue
+    }
+
+    if (isOpeningBracket(source[index])) {
+      stack.push(expectedClosingBracket(source[index]))
+      index += 1
+      continue
+    }
+
+    if (isClosingBracket(source[index])) {
+      if (stack.at(-1) === source[index]) stack.pop()
+      index += 1
+      continue
+    }
+
+    if (stack.length === 0 && source[index] === ";") return index + 1
+    if (
+      stack.length === 0 &&
+      sawModuleSpecifier &&
+      (source[index] === "\n" || source[index] === "\r")
+    ) {
+      return index + 1
+    }
+
+    index += 1
+  }
+
+  return source.length
+}
+
+function getImportModuleSpecifier(declaration) {
+  let moduleSpecifier = null
+  let index = 0
+
+  while (index < declaration.length) {
+    const skipped = skipComment(declaration, index)
+    if (skipped !== index) {
+      index = skipped
+      continue
+    }
+
+    if (declaration[index] === "\"" || declaration[index] === "'") {
+      const literal = readStringLiteral(declaration, index)
+      if (!literal) break
+      moduleSpecifier = literal.value
+      index = literal.end
+      continue
+    }
+
+    index += 1
+  }
+
+  return moduleSpecifier
+}
+
+function getDefaultImportLocal(declaration) {
+  let index = skipWhitespaceAndComments(declaration, "import".length)
+
+  if (matchIdentifier(declaration, index, "type")) {
+    index = skipWhitespaceAndComments(declaration, index + "type".length)
+  }
+
+  if (declaration[index] === "\"" || declaration[index] === "{" || declaration[index] === "*") {
+    return null
+  }
+
+  const local = readIdentifierAt(declaration, index)
+  return local?.name ?? null
+}
+
+function getNamedImportLocals(declaration) {
+  const open = declaration.indexOf("{")
+  if (open === -1) return []
+
+  const close = findMatchingBracket(declaration, open, "{", "}")
+  const namedImportBody = declaration.slice(open + 1, close)
+  const locals = []
+
+  for (const specifier of splitTopLevelList(namedImportBody)) {
+    const trimmed = specifier.trim()
+    if (!trimmed) continue
+
+    const withoutType = trimmed.startsWith("type ")
+      ? trimmed.slice("type ".length).trim()
+      : trimmed
+    const asIndex = withoutType.toLowerCase().lastIndexOf(" as ")
+    const localName = asIndex === -1
+      ? withoutType
+      : withoutType.slice(asIndex + " as ".length).trim()
+    const local = readIdentifierAt(localName, 0)
+
+    if (local) locals.push(local.name)
+  }
+
+  return locals
+}
+
+function splitTopLevelList(source) {
+  const items = []
+  let start = 0
+  let index = 0
+
+  while (index < source.length) {
+    const skipped = skipIgnoredSyntax(source, index)
+    if (skipped !== index) {
+      index = skipped
+      continue
+    }
+
+    if (source[index] === ",") {
+      items.push(source.slice(start, index))
+      start = index + 1
+    }
+    index += 1
+  }
+
+  items.push(source.slice(start))
+  return items
+}
+
+export function prependImportLines(source, lines) {
+  if (lines.length === 0) return source
+
+  let insertAt = 0
+  if (source.startsWith("#!")) {
+    const lineEnd = source.indexOf("\n")
+    insertAt = lineEnd === -1 ? source.length : lineEnd + 1
+  }
+
+  const prefix = `${lines.join("\n")}\n`
+  return `${source.slice(0, insertAt)}${prefix}${source.slice(insertAt)}`
+}
+
+export function findTopLevelCommaOrEnd(source, start, end) {
+  const stack = []
+  let index = start
+
+  while (index < end) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (isOpeningBracket(source[index])) {
+      stack.push(expectedClosingBracket(source[index]))
+      index += 1
+      continue
+    }
+
+    if (isClosingBracket(source[index])) {
+      if (stack.at(-1) === source[index]) stack.pop()
+      index += 1
+      continue
+    }
+
+    if (stack.length === 0 && source[index] === ",") return index
+    index += 1
+  }
+
+  return end
+}
+
+export function findMatchingBracket(source, start, open, close) {
+  if (source[start] !== open) {
+    throw new Error("malformed JavaScript object.")
+  }
+
+  const stack = []
+  let index = start
+
+  while (index < source.length) {
+    const next = skipIgnoredSyntax(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (isOpeningBracket(source[index])) {
+      stack.push(expectedClosingBracket(source[index]))
+      index += 1
+      continue
+    }
+
+    if (isClosingBracket(source[index])) {
+      const expected = stack.pop()
+      if (expected !== source[index]) {
+        throw new Error("malformed JavaScript brackets.")
+      }
+      if (stack.length === 0) return index
+      index += 1
+      continue
+    }
+
+    index += 1
+  }
+
+  throw new Error(`missing closing ${close}.`)
+}
+
+function skipIgnoredSyntax(source, index) {
+  const commentEnd = skipComment(source, index)
+  if (commentEnd !== index) return commentEnd
+
+  if (source[index] === "\"" || source[index] === "'" || source[index] === "`") {
+    return skipQuotedText(source, index)
+  }
+
+  return index
+}
+
+function skipComment(source, index) {
+  if (source[index] !== "/") return index
+
+  if (source[index + 1] === "/") {
+    const lineEnd = source.indexOf("\n", index + 2)
+    return lineEnd === -1 ? source.length : lineEnd + 1
+  }
+
+  if (source[index + 1] === "*") {
+    const blockEnd = source.indexOf("*/", index + 2)
+    return blockEnd === -1 ? source.length : blockEnd + 2
+  }
+
+  return index
+}
+
+function skipQuotedText(source, index) {
+  const quote = source[index]
+  index += 1
+
+  while (index < source.length) {
+    if (source[index] === "\\") {
+      index += 2
+      continue
+    }
+
+    if (source[index] === quote) return index + 1
+    index += 1
+  }
+
+  return source.length
+}
+
+export function readStringLiteral(source, index) {
+  const quote = source[index]
+  if (quote !== "\"" && quote !== "'") return null
+
+  let value = ""
+  index += 1
+
+  while (index < source.length) {
+    if (source[index] === "\\") {
+      value += source[index + 1] ?? ""
+      index += 2
+      continue
+    }
+
+    if (source[index] === quote) {
+      return { value, end: index + 1 }
+    }
+
+    value += source[index]
+    index += 1
+  }
+
+  return null
+}
+
+export function readIdentifierAt(source, index) {
+  if (!isIdentifierStart(source[index])) return null
+
+  let end = index + 1
+  while (end < source.length && isIdentifierPart(source[end])) {
+    end += 1
+  }
+
+  return { name: source.slice(index, end), end }
+}
+
+export function matchIdentifier(source, index, name) {
+  if (source.slice(index, index + name.length) !== name) return false
+
+  const before = source[index - 1]
+  const after = source[index + name.length]
+  return !isIdentifierPart(before) && !isIdentifierPart(after)
+}
+
+function isIdentifierStart(char) {
+  return Boolean(char && /[A-Za-z_$]/.test(char))
+}
+
+function isIdentifierPart(char) {
+  return Boolean(char && /[A-Za-z0-9_$]/.test(char))
+}
+
+function isOpeningBracket(char) {
+  return char === "{" || char === "[" || char === "("
+}
+
+function isClosingBracket(char) {
+  return char === "}" || char === "]" || char === ")"
+}
+
+function expectedClosingBracket(char) {
+  if (char === "{") return "}"
+  if (char === "[") return "]"
+  return ")"
+}
+
+export function skipWhitespaceAndComments(source, index) {
+  while (index < source.length) {
+    const next = skipComment(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (!isWhitespace(source[index])) return index
+    index += 1
+  }
+
+  return index
+}
+
+export function skipWhitespaceCommentsAndCommas(source, index, end) {
+  while (index < end) {
+    const next = skipWhitespaceAndComments(source, index)
+    if (next !== index) {
+      index = next
+      continue
+    }
+
+    if (source[index] !== ",") return index
+    index += 1
+  }
+
+  return index
+}
+
+function skipHorizontalWhitespace(source, index) {
+  while (source[index] === " " || source[index] === "\t") {
+    index += 1
+  }
+  return index
+}
+
+export function isWhitespace(char) {
+  return char === " " || char === "\t" || char === "\n" || char === "\r"
+}
+
+function indentMultiline(text, indent) {
+  return text
+    .split("\n")
+    .map((line) => `${indent}${line}`)
+    .join("\n")
+}
+
+function getLineIndent(source, index) {
+  let lineStart = index
+  while (lineStart > 0 && source[lineStart - 1] !== "\n") {
+    lineStart -= 1
+  }
+
+  return source.slice(lineStart, skipHorizontalWhitespace(source, lineStart))
+}
+
+function trimEndIndex(source, start, end) {
+  while (end > start && isWhitespace(source[end - 1])) {
+    end -= 1
+  }
+  return end
+}
+
+function previousCodeChar(source, index) {
+  index -= 1
+  while (index >= 0 && isWhitespace(source[index])) {
+    index -= 1
+  }
+  return source[index]
+}
+
+function bodyIncludesNewline(source, start, end) {
+  for (let index = start; index < end; index += 1) {
+    if (source[index] === "\n" || source[index] === "\r") return true
+  }
+  return false
+}