davaux 0.8.0

package/src/dev/insert.ts

@@ -0,0 +1,221 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+
+export type InsertResult =
+  | { inserted: true; file: string; warning?: string }
+  | { inserted: false; error: string }
+
+function leadingWs(line: string): string {
+  return line.match(/^(\s*)/)?.[1] ?? ''
+}
+
+function findInsertPoint(lines: string[]): { idx: number; indent: string } | null {
+  // Explicit marker takes priority
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes('@davaux-insert')) {
+      return { idx: i, indent: leadingWs(lines[i]) }
+    }
+  }
+
+  // Find `return (` line
+  let returnIdx = -1
+  for (let i = 0; i < lines.length; i++) {
+    if (/return\s*\(/.test(lines[i])) {
+      returnIdx = i
+      break
+    }
+  }
+  if (returnIdx === -1) return null
+
+  // Find the closing `)` of the return at the same or shallower indent
+  const returnIndentLen = leadingWs(lines[returnIdx]).length
+  let returnCloseIdx = -1
+  for (let i = returnIdx + 1; i < lines.length; i++) {
+    const t = lines[i].trim()
+    const indLen = leadingWs(lines[i]).length
+    if ((t === ')' || t === ');') && indLen <= returnIndentLen + 2) {
+      returnCloseIdx = i
+      break
+    }
+  }
+  if (returnCloseIdx === -1) return null
+
+  // Find the outermost JSX wrapper element
+  let wrapperIdx = -1
+  let wrapperTag = ''
+  let wrapperIndent = ''
+  for (let i = returnIdx + 1; i < returnCloseIdx; i++) {
+    const t = lines[i].trim()
+    if (!t) continue
+    // Fragment
+    if (t === '<>') {
+      wrapperIdx = i
+      wrapperTag = ''
+      wrapperIndent = leadingWs(lines[i])
+      break
+    }
+    // Single-line opening tag: <Tag> or <Tag attr="x">
+    const m = t.match(/^<([A-Za-z][A-Za-z0-9.]*)(?:\s[^>]*)?>$/)
+    if (m) {
+      wrapperIdx = i
+      wrapperTag = m[1]
+      wrapperIndent = leadingWs(lines[i])
+      break
+    }
+  }
+  if (wrapperIdx === -1) return null
+
+  // Find the closing tag at the same indent level
+  const closeTag = wrapperTag ? `</${wrapperTag}>` : '</>'
+  let closingIdx = -1
+  for (let i = wrapperIdx + 1; i < returnCloseIdx; i++) {
+    if (leadingWs(lines[i]) === wrapperIndent && lines[i].trim() === closeTag) {
+      closingIdx = i
+      break
+    }
+  }
+  if (closingIdx === -1) return null
+
+  const useTabs = wrapperIndent.includes('\t')
+  const childIndent = wrapperIndent + (useTabs ? '\t' : '  ')
+  return { idx: closingIdx, indent: childIndent }
+}
+
+function addMissingImports(lines: string[], imports: Record<string, string>): number {
+  let lastImportIdx = -1
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trimStart().startsWith('import ')) lastImportIdx = i
+  }
+  let added = 0
+  for (const [name, path] of Object.entries(imports)) {
+    const already = lines.some(
+      (l) =>
+        l.includes(`import ${name}`) ||
+        l.includes(`{ ${name} }`) ||
+        new RegExp(`\\b${name}\\b`).test(l.replace(/^import\s+/, '')),
+    )
+    if (!already) {
+      lines.splice(lastImportIdx + 1 + added, 0, `import ${name} from '${path}'`)
+      added++
+    }
+  }
+  return added
+}
+
+// Find the full span of the Nth element (opening through matching closing tag).
+// Mirrors findFullElementSpan in remove.ts — kept local to avoid a circular dep.
+function findElemSpan(lines: string[], tagName: string, instanceIndex: number): [number, number] | null {
+  // PascalCase components: anchor to start-of-line so inline prop occurrences are not counted.
+  // This keeps the index consistent with the OML tree traversal in countNameBefore.
+  const isPascal = /^[A-Z]/.test(tagName)
+  const openRe = isPascal
+    ? new RegExp(`^\\s*<${tagName}(\\s|/>|>|$)`)
+    : new RegExp(`<${tagName}(\\s|>|\\/)`)
+  let count = 0
+  for (let i = 0; i < lines.length; i++) {
+    if (openRe.test(lines[i])) {
+      if (count === instanceIndex) {
+        const tagPos = lines[i].search(openRe)
+        const openIndent = lines[i].match(/^(\s*)/)?.[1] ?? ''
+        const rest = lines[i].slice(tagPos)
+        if (/\/>/.test(rest) || new RegExp(`</${tagName}>`).test(rest)) return [i, i]
+        for (let j = i + 1; j < lines.length; j++) {
+          const t = lines[j].trim()
+          const ind = lines[j].match(/^(\s*)/)?.[1] ?? ''
+          if (t.startsWith(`</${tagName}>`) && ind.length <= openIndent.length) return [i, j]
+          if (t && ind.length < openIndent.length) break
+        }
+        return [i, i]
+      }
+      count++
+    }
+  }
+  return null
+}
+
+export function insertAfterElement(
+  filePath: string,
+  tagName: string,
+  instanceIndex: number,
+  newJsx: string,
+  componentImports: Record<string, string> = {},
+): InsertResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { inserted: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+  const span = findElemSpan(lines, tagName, instanceIndex)
+  if (!span) return { inserted: false, error: `No <${tagName}> found at index ${instanceIndex}` }
+
+  const importCount = addMissingImports(lines, componentImports)
+  const adjustedEnd = span[1] + importCount
+
+  const indent = leadingWs(lines[span[0] + importCount])
+  const formatted = newJsx
+    .split('\n')
+    .map((l) => (l ? indent + l : l))
+    .join('\n')
+
+  lines.splice(adjustedEnd + 1, 0, formatted)
+
+  try {
+    writeFileSync(filePath, lines.join('\n'), 'utf-8')
+  } catch {
+    return { inserted: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  return { inserted: true, file: filePath }
+}
+
+export function insertJsx(
+  filePath: string,
+  jsxSnippet: string,
+  componentImports: Record<string, string>,
+): InsertResult {
+  let source: string
+  try {
+    source = readFileSync(filePath, 'utf-8')
+  } catch {
+    return { inserted: false, error: `Cannot read file: ${filePath}` }
+  }
+
+  const lines = source.split('\n')
+  const point = findInsertPoint(lines)
+  if (!point) {
+    return {
+      inserted: false,
+      error:
+        'Cannot find insertion point. Add {/* @davaux-insert */} in your JSX where you want components to be inserted.',
+    }
+  }
+
+  const importCount = addMissingImports(lines, componentImports)
+  const insertIdx = point.idx + importCount
+
+  const formatted = jsxSnippet
+    .split('\n')
+    .map((l) => (l ? point.indent + l : l))
+    .join('\n')
+
+  lines.splice(insertIdx, 0, formatted)
+
+  try {
+    writeFileSync(filePath, lines.join('\n'), 'utf-8')
+  } catch {
+    return { inserted: false, error: `Cannot write file: ${filePath}` }
+  }
+
+  // Warn if an uppercase component was inserted without a matching import in the file
+  const componentName = jsxSnippet.match(/^<([A-Z][A-Za-z0-9.]*)/)?.[1]
+  const hasImport =
+    !componentName ||
+    lines.some((l) => l.trimStart().startsWith('import') && l.includes(componentName))
+  const warning = hasImport
+    ? undefined
+    : `No import found for ${componentName}. Add an import manually, or set the "imports" field in the blueprint JSON to automate it.`
+
+  return { inserted: true, file: filePath, warning }
+}