davaux 0.8.0 → 0.8.1

package/src/dev/insert.ts

@@ -1,221 +0,0 @@
-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 }
-}