banhaten 0.1.2 → 0.2.0

package/src/cli/vite-config.js

@@ -0,0 +1,478 @@
+// The scanner reports syntax problems without naming a dialect; this module is
+// the only place that knows the source is a Vite config, so it adds that word.
+function asViteConfigError(error) {
+  if (error instanceof Error && !/^unsupported Vite config: /.test(error.message)) {
+    error.message = `unsupported Vite config: ${error.message}`
+  }
+  return error
+}
+
+// Vite config editing. This module owns every assumption about what a Vite
+// config looks like; the scanner primitives it builds on know nothing about Vite.
+
+import {
+  appendArrayElement,
+  appendObjectProperty,
+  arrayHasCallExpression,
+  createBracketRange,
+  expectArrayLiteralValue,
+  expectObjectLiteralValue,
+  findExportDefaultExpressionStart,
+  findObjectProperty,
+  findTopLevelCommaOrEnd,
+  insertObjectProperty,
+  parseImportDeclarations,
+  prependImportLines,
+  readIdentifierAt,
+  readObjectPropertyNames,
+  readPropertyName,
+  readStringLiteral,
+  skipWhitespaceAndComments,
+  skipWhitespaceCommentsAndCommas
+} from "./source-scanner.js"
+
+function ensureNodeUrlImport(source) {
+  const imports = parseImportDeclarations(source)
+  const nodeUrlImports = imports.filter((entry) => entry.moduleSpecifier === "node:url")
+  const importedLocals = new Set(nodeUrlImports.flatMap((entry) => entry.namedLocals))
+  const missing = ["fileURLToPath", "URL"].filter((name) => !importedLocals.has(name))
+
+  if (missing.length === 0) return source
+
+  return prependImportLines(
+    source,
+    [`import { ${missing.join(", ")} } from "node:url"`]
+  )
+}
+
+function ensureTailwindViteImport(source, localName) {
+  const imports = parseImportDeclarations(source)
+  const tailwindImport = imports.find(
+    (entry) => entry.moduleSpecifier === "@tailwindcss/vite"
+  )
+
+  if (!tailwindImport) {
+    return prependImportLines(
+      source,
+      [`import ${localName} from "@tailwindcss/vite"`]
+    )
+  }
+
+  if (!tailwindImport.defaultLocal) {
+    throw new Error(
+      "unsupported Vite config: @tailwindcss/vite must be imported with a default binding."
+    )
+  }
+
+  return source
+}
+
+export function updateViteConfigSource(source, options) {
+  try {
+    return updateViteConfigSourceUnchecked(source, options)
+  } catch (error) {
+    throw asViteConfigError(error)
+  }
+}
+
+function updateViteConfigSourceUnchecked(source, { aliasRoot, sourceRoot }) {
+  validateViteConfigStructure(source)
+  const tailwindLocalName = getTailwindViteLocalName(source)
+  let next = aliasRoot
+    ? addViteResolveAlias(source, aliasRoot, sourceRoot)
+    : source
+  const addedFileUrlAlias = Boolean(aliasRoot) && next !== source
+  next = addVitePluginCall(next, `${tailwindLocalName}()`, tailwindLocalName)
+  next = ensureTailwindViteImport(next, tailwindLocalName)
+  if (addedFileUrlAlias) next = ensureNodeUrlImport(next)
+  return next
+}
+
+export function readViteAliasSourceRoot(source, options) {
+  try {
+    return readViteAliasSourceRootUnchecked(source, options)
+  } catch (error) {
+    throw asViteConfigError(error)
+  }
+}
+
+function readViteAliasSourceRootUnchecked(source, { aliasRoot }) {
+  validateViteConfigStructure(source)
+  const configObject = findViteConfigObject(source)
+  const resolveProperty = findObjectProperty(source, configObject, "resolve")
+  if (!resolveProperty) return null
+
+  const resolveObject = expectObjectLiteralValue(
+    source,
+    resolveProperty,
+    "unsupported Vite config: resolve must be an object literal."
+  )
+  const aliasProperty = findObjectProperty(source, resolveObject, "alias")
+  if (!aliasProperty) return null
+
+  const aliasObject = expectObjectLiteralValue(
+    source,
+    aliasProperty,
+    "unsupported Vite config: resolve.alias must be an object literal."
+  )
+  const rootProperty = findObjectProperty(source, aliasObject, aliasRoot)
+  if (!rootProperty) return null
+
+  const expression = source
+    .slice(rootProperty.valueStart, rootProperty.valueEnd)
+    .trim()
+  const staticRoot = readStaticAliasRoot(expression)
+  if (staticRoot !== null) {
+    assertStaticAliasBinding(source, staticRoot)
+    return staticRoot
+  }
+
+  throw new Error(
+    `unsupported Vite config: resolve.alias[${JSON.stringify(aliasRoot)}] must use a static string, ` +
+      "fileURLToPath(new URL(..., import.meta.url)), or path.resolve(__dirname, ...)."
+  )
+}
+
+export function readViteAliasKeys(source) {
+  try {
+    return readViteAliasKeysUnchecked(source)
+  } catch (error) {
+    throw asViteConfigError(error)
+  }
+}
+
+function readViteAliasKeysUnchecked(source) {
+  validateViteConfigStructure(source)
+  const configObject = findViteConfigObject(source)
+  const resolveProperty = findObjectProperty(source, configObject, "resolve")
+  if (!resolveProperty) return []
+
+  const resolveObject = expectObjectLiteralValue(
+    source,
+    resolveProperty,
+    "unsupported Vite config: resolve must be an object literal."
+  )
+  const aliasProperty = findObjectProperty(source, resolveObject, "alias")
+  if (!aliasProperty) return []
+
+  const aliasObject = expectObjectLiteralValue(
+    source,
+    aliasProperty,
+    "unsupported Vite config: resolve.alias must be an object literal."
+  )
+  return readObjectPropertyNames(source, aliasObject)
+}
+
+function readStaticAliasRoot(expression) {
+  const directLiteral = readStringLiteral(expression, 0)
+  if (
+    directLiteral &&
+    skipWhitespaceAndComments(expression, directLiteral.end) === expression.length
+  ) {
+    return { kind: "literal", value: directLiteral.value }
+  }
+
+  const patterns = [
+    {
+      kind: "file-url",
+      pattern: /^fileURLToPath\s*\(\s*new\s+URL\s*\(\s*(["'])(.*?)\1\s*,\s*import\.meta\.url\s*\)\s*\)$/s,
+    },
+    {
+      kind: "path-default",
+      pattern: /^path\.resolve\s*\(\s*(?:__dirname|import\.meta\.dirname)\s*,\s*(["'])(.*?)\1\s*\)$/s,
+    },
+    {
+      kind: "path-named",
+      pattern: /^resolve\s*\(\s*(?:__dirname|import\.meta\.dirname)\s*,\s*(["'])(.*?)\1\s*\)$/s,
+    },
+  ]
+
+  for (const candidate of patterns) {
+    const match = expression.match(candidate.pattern)
+    if (match) {
+      return {
+        kind: candidate.kind,
+        value: match[2].replace(/\\(.)/g, "$1"),
+      }
+    }
+  }
+
+  return null
+}
+
+function assertStaticAliasBinding(source, staticRoot) {
+  const imports = parseImportDeclarations(source)
+
+  if (staticRoot.kind === "file-url") {
+    const nodeUrlImport = imports.find(
+      (entry) =>
+        (entry.moduleSpecifier === "node:url" || entry.moduleSpecifier === "url") &&
+        entry.namedLocals.includes("fileURLToPath")
+    )
+    if (!nodeUrlImport) {
+      throw new Error(
+        "unsupported Vite config: fileURLToPath must be imported by name from node:url."
+      )
+    }
+  }
+
+  if (staticRoot.kind === "path-default") {
+    const nodePathImport = imports.find(
+      (entry) =>
+        (entry.moduleSpecifier === "node:path" || entry.moduleSpecifier === "path") &&
+        entry.defaultLocal === "path"
+    )
+    if (!nodePathImport) {
+      throw new Error(
+        "unsupported Vite config: path must be a default import from node:path."
+      )
+    }
+  }
+
+  if (staticRoot.kind === "path-named") {
+    const nodePathImport = imports.find(
+      (entry) =>
+        (entry.moduleSpecifier === "node:path" || entry.moduleSpecifier === "path") &&
+        entry.namedLocals.includes("resolve")
+    )
+    if (!nodePathImport) {
+      throw new Error(
+        "unsupported Vite config: resolve must be imported by name from node:path."
+      )
+    }
+  }
+}
+
+function validateViteConfigStructure(source) {
+  const configObject = findViteConfigObject(source)
+  assertStaticObjectStructure(source, configObject, "config")
+
+  const resolveProperty = findObjectProperty(source, configObject, "resolve")
+  if (!resolveProperty) return
+
+  const resolveObject = expectObjectLiteralValue(
+    source,
+    resolveProperty,
+    "unsupported Vite config: resolve must be an object literal."
+  )
+  assertStaticObjectStructure(source, resolveObject, "resolve")
+
+  const aliasProperty = findObjectProperty(source, resolveObject, "alias")
+  if (!aliasProperty) return
+
+  const aliasObject = expectObjectLiteralValue(
+    source,
+    aliasProperty,
+    "unsupported Vite config: resolve.alias must be an object literal."
+  )
+  assertStaticObjectStructure(source, aliasObject, "resolve.alias")
+}
+
+function assertStaticObjectStructure(source, objectRange, label) {
+  const bodyEnd = objectRange.end - 1
+  const seen = new Set()
+  let index = objectRange.start + 1
+
+  while (index < bodyEnd) {
+    index = skipWhitespaceCommentsAndCommas(source, index, bodyEnd)
+    if (index >= bodyEnd) return
+
+    const propertyStart = index
+    const propertyEnd = findTopLevelCommaOrEnd(
+      source,
+      propertyStart,
+      bodyEnd
+    )
+
+    if (source.startsWith("...", propertyStart)) {
+      throw new Error(
+        `unsupported Vite config: ${label} cannot contain spread properties.`
+      )
+    }
+    if (source[propertyStart] === "[") {
+      throw new Error(
+        `unsupported Vite config: ${label} cannot contain computed properties.`
+      )
+    }
+
+    const name = readPropertyName(source, propertyStart)
+    if (name) {
+      if (seen.has(name.name)) {
+        throw new Error(
+          `unsupported Vite config: ${label} contains duplicate property ${JSON.stringify(name.name)}.`
+        )
+      }
+      seen.add(name.name)
+    }
+
+    index = propertyEnd + 1
+  }
+}
+
+function getTailwindViteLocalName(source) {
+  const tailwindImport = parseImportDeclarations(source).find(
+    (entry) => entry.moduleSpecifier === "@tailwindcss/vite"
+  )
+
+  if (!tailwindImport) return "tailwindcss"
+  if (tailwindImport.defaultLocal) return tailwindImport.defaultLocal
+
+  throw new Error(
+    "unsupported Vite config: @tailwindcss/vite must be imported with a default binding."
+  )
+}
+
+function addViteResolveAlias(source, aliasRoot, sourceRoot) {
+  const configObject = findViteConfigObject(source)
+  const resolveProperty = findObjectProperty(source, configObject, "resolve")
+  const aliasEntry = `${JSON.stringify(aliasRoot)}: fileURLToPath(new URL(${JSON.stringify(
+    sourceRoot
+  )}, import.meta.url))`
+
+  if (!resolveProperty) {
+    return insertObjectProperty(
+      source,
+      configObject,
+      [
+        "resolve: {",
+        "  alias: {",
+        `    ${aliasEntry},`,
+        "  },",
+        "},",
+      ].join("\n")
+    )
+  }
+
+  const resolveObject = expectObjectLiteralValue(
+    source,
+    resolveProperty,
+    "unsupported Vite config: resolve must be an object literal."
+  )
+  const aliasProperty = findObjectProperty(source, resolveObject, "alias")
+
+  if (!aliasProperty) {
+    return insertObjectProperty(
+      source,
+      resolveObject,
+      [
+        "alias: {",
+        `  ${aliasEntry},`,
+        "},",
+      ].join("\n")
+    )
+  }
+
+  const aliasObject = expectObjectLiteralValue(
+    source,
+    aliasProperty,
+    "unsupported Vite config: resolve.alias must be an object literal."
+  )
+
+  if (findObjectProperty(source, aliasObject, aliasRoot)) {
+    return source
+  }
+
+  return appendObjectProperty(source, aliasObject, `${aliasEntry},`)
+}
+
+function addVitePluginCall(source, pluginCall, pluginLocalName) {
+  const configObject = findViteConfigObject(source)
+  const pluginsProperty = findObjectProperty(source, configObject, "plugins")
+
+  if (!pluginsProperty) {
+    return insertObjectProperty(source, configObject, `plugins: [${pluginCall}],`)
+  }
+
+  const pluginsArray = expectArrayLiteralValue(
+    source,
+    pluginsProperty,
+    "unsupported Vite config: plugins must be an array literal."
+  )
+
+  if (arrayHasCallExpression(source, pluginsArray, pluginLocalName)) {
+    return source
+  }
+
+  return appendArrayElement(source, pluginsArray, pluginCall)
+}
+
+function findViteConfigObject(source) {
+  const expressionStart = findExportDefaultExpressionStart(source)
+
+  if (expressionStart === -1) {
+    throw new Error(
+      "unsupported Vite config: expected `export default defineConfig({ ... })` or `export default { ... }`."
+    )
+  }
+
+  if (source[expressionStart] === "{") {
+    return createBracketRange(source, expressionStart, "{")
+  }
+
+  const callee = readIdentifierAt(source, expressionStart)
+  if (callee?.name !== "defineConfig") {
+    throw new Error(
+      "unsupported Vite config: default export must be `defineConfig({ ... })` or an object literal."
+    )
+  }
+
+  let index = skipWhitespaceAndComments(source, callee.end)
+  if (source[index] !== "(") {
+    throw new Error("unsupported Vite config: malformed defineConfig call.")
+  }
+
+  index = skipWhitespaceAndComments(source, index + 1)
+
+  // defineConfig({ ... })
+  if (source[index] === "{") {
+    return createBracketRange(source, index, "{")
+  }
+
+  // defineConfig((env) => ({ ... })) — the other documented Vite form, used
+  // whenever the config depends on `mode` or `command`. The config object is
+  // the arrow's returned expression, so resolve to that and edit it in place.
+  const arrowBody = findConfigArrowBodyStart(source, index)
+  if (arrowBody !== -1) {
+    return createBracketRange(source, arrowBody, "{")
+  }
+
+  throw new Error(
+    "unsupported Vite config: defineConfig must receive a config object literal " +
+      "or an arrow function returning one, e.g. `defineConfig(({ mode }) => ({ ... }))`."
+  )
+}
+
+// Given the index of defineConfig's first argument, return the index of the
+// object literal an arrow function returns, or -1 when the argument is not an
+// arrow whose body is a parenthesised object.
+function findConfigArrowBodyStart(source, argumentStart) {
+  let index = argumentStart
+
+  // An optional `async` before the parameter list.
+  const asyncKeyword = readIdentifierAt(source, index)
+  if (asyncKeyword?.name === "async") {
+    index = skipWhitespaceAndComments(source, asyncKeyword.end)
+  }
+
+  // Parameter list: either `(...)` or a single bare identifier.
+  if (source[index] === "(") {
+    const parameters = createBracketRange(source, index, "(")
+    index = skipWhitespaceAndComments(source, parameters.end + 1)
+  } else {
+    const parameter = readIdentifierAt(source, index)
+    if (!parameter) return -1
+    index = skipWhitespaceAndComments(source, parameter.end)
+  }
+
+  if (source.slice(index, index + 2) !== "=>") return -1
+  index = skipWhitespaceAndComments(source, index + 2)
+
+  // `=> ({ ... })`. A block body (`=> { return { ... } }`) is deliberately not
+  // followed: locating the returned object there means tracking control flow,
+  // and editing it in place would be guesswork. Those users get the explicit
+  // message above rather than a silently wrong edit.
+  if (source[index] !== "(") return -1
+  index = skipWhitespaceAndComments(source, index + 1)
+
+  return source[index] === "{" ? index : -1
+}