chore: wip

Author: chrisbbreuer

src/extract.ts

@@ -531,90 +531,6 @@ function createImportTrackingState(): ImportTrackingState {
   }
 }
 
-function indentMultilineType(type: string, baseIndent: string, isLast: boolean): string {
-  debugLog(undefined, 'indent-multiline', `Processing multiline type with baseIndent="${baseIndent}", isLast=${isLast}`)
-  debugLog(undefined, 'indent-input', `Input type:\n${type}`)
-
-  const lines = type.split('\n')
-  debugLog(undefined, 'indent-lines', `Split into ${lines.length} lines`)
-
-  if (lines.length === 1) {
-    const result = `${baseIndent}${type}${isLast ? '' : ' |'}`
-    debugLog(undefined, 'indent-single', `Single line result: ${result}`)
-    return result
-  }
-
-  // Initialize bracket stack with additional context
-  interface BracketInfo {
-    char: string
-    indent: string
-    isArray: boolean // Track if this is an Array type bracket
-  }
-  const bracketStack: BracketInfo[] = []
-  debugLog(undefined, 'indent-stack', 'Initializing bracket stack')
-
-  const formattedLines = lines.map((line, i) => {
-    const trimmed = line.trim()
-    if (!trimmed) {
-      debugLog(undefined, 'indent-empty', `Empty line at index ${i}`)
-      return ''
-    }
-
-    // Track Array type specifically
-    const isArrayStart = trimmed.startsWith('Array<')
-    const openBrackets = (trimmed.match(/[{<[]/g) || [])
-    const closeBrackets = (trimmed.match(/[}\]>]/g) || [])
-
-    debugLog(undefined, 'indent-brackets', `Line ${i}: opens=${openBrackets.length}, closes=${closeBrackets.length}, isArray=${isArrayStart}, content="${trimmed}"`)
-
-    let currentIndent = baseIndent
-    if (i > 0 || closeBrackets.length > 0) {
-      if (closeBrackets.length > 0 && bracketStack.length > 0) {
-        const lastBracket = bracketStack[bracketStack.length - 1]
-        // For Array closing bracket, use base indent
-        if (lastBracket.isArray) {
-          currentIndent = baseIndent
-          debugLog(undefined, 'indent-close-array', `Using base indent for Array closing: "${currentIndent}"`)
-        }
-        else {
-          currentIndent = lastBracket.indent
-          debugLog(undefined, 'indent-close', `Using stack indent for closing: "${currentIndent}"`)
-        }
-        bracketStack.pop()
-      }
-      else {
-        currentIndent = baseIndent + '  '.repeat(bracketStack.length)
-        debugLog(undefined, 'indent-content', `Using content indent at depth ${bracketStack.length}: "${currentIndent}"`)
-      }
-    }
-
-    // Handle opening brackets with Array context
-    if (openBrackets.length > 0) {
-      openBrackets.forEach((bracket) => {
-        const isArrayBracket = trimmed.startsWith('Array') && bracket === '<'
-        bracketStack.push({
-          char: bracket,
-          indent: currentIndent,
-          isArray: isArrayBracket,
-        })
-        debugLog(undefined, 'indent-open', `Pushed bracket "${bracket}" with indent "${currentIndent}", isArray=${isArrayBracket}`)
-      })
-    }
-
-    const formattedLine = `${currentIndent}${trimmed}`
-    debugLog(undefined, 'indent-line', `Formatted line ${i}: "${formattedLine}"`)
-
-    if (!isLast && i === lines.length - 1 && !formattedLine.endsWith(' |')) {
-      return `${formattedLine} |`
-    }
-    return formattedLine
-  }).filter(Boolean)
-
-  const result = formattedLines.join('\n')
-  debugLog(undefined, 'indent-result', `Final multiline result:\n${result}`)
-  return result
-}
-
 function inferValueType(value: string): string {
   value = value.trim()
 
@@ -655,8 +571,8 @@ function inferArrayType(value: string, state?: ProcessingState, indentLevel = 0)
   }
 
   const baseIndent = '  '.repeat(indentLevel)
-  const elementIndent = '  '.repeat(indentLevel + 1)
-  debugLog(state, 'infer-array-indent', `Base indent="${baseIndent}", Element indent="${elementIndent}"`)
+  const contentIndent = '  '.repeat(indentLevel + 1)
+  debugLog(state, 'infer-array-indent', `Base indent="${baseIndent}", Content indent="${contentIndent}"`)
 
   const elements = splitArrayElements(content, state)
   debugLog(state, 'array-split', `Elements after split: ${JSON.stringify(elements)}`)
@@ -705,43 +621,39 @@ function inferArrayType(value: string, state?: ProcessingState, indentLevel = 0)
   const needsMultiline = types.some(type =>
     type.includes('\n') || type.includes('{') || type.length > 40 || types.join(' | ').length > 60,
   )
-  debugLog(state, 'multiline-check', `Needs multiline: ${needsMultiline}, Reason: ${
-    types.find(type => type.includes('\n'))
-      ? 'contains newline'
-      : types.find(type => type.includes('{'))
-        ? 'contains object'
-        : types.find(type => type.length > 40)
-          ? 'type too long'
-          : types.join(' | ').length > 60 ? 'combined types too long' : 'none'
-  }`)
+  debugLog(state, 'multiline-check', `Needs multiline: ${needsMultiline}`)
 
   if (needsMultiline) {
     debugLog(state, 'multiline-start', `Starting multiline formatting with ${types.length} types`)
 
-    // Construct parts separately for better control
+    // Format types with proper indentation
     const formattedTypes = types.map((type, index) => {
       const isLast = index === types.length - 1
-      debugLog(state, 'type-formatting', `Formatting type ${index}, isLast: ${isLast}`)
-      const formatted = indentMultilineType(type, elementIndent, isLast)
-      debugLog(state, 'type-formatted', `Type ${index} formatted result:\n${formatted}`)
-      return formatted
+      const lines = type.split('\n')
+
+      if (lines.length === 1) {
+        return `${contentIndent}${type}${isLast ? '' : ' |'}`
+      }
+
+      // For multiline types, maintain their internal structure
+      return lines.map((line, i) => {
+        const trimmed = line.trim()
+        if (!trimmed)
+          return ''
+        // Indent content one more level than current
+        return i === 0 ? `${contentIndent}${trimmed}` : `${contentIndent}  ${trimmed}`
+      }).filter(Boolean).join('\n') + (isLast ? '' : ' |')
     })
 
-    // Build multiline array with controlled indentation
-    const typeContent = formattedTypes.join('\n')
-    const result = [
+    // Simple structure: opener, content, closer all aligned
+    return [
       `${baseIndent}Array<`,
-      typeContent,
+      formattedTypes.join('\n'),
       `${baseIndent}>`,
     ].join('\n')
-
-    debugLog(state, 'multiline-result', `Final multiline result:\n${result}`)
-    return result
   }
 
-  const singleLineResult = `Array<${types.join(' | ')}>`
-  debugLog(state, 'single-line-array', `Single-line array type: ${singleLineResult}`)
-  return singleLineResult
+  return `Array<${types.join(' | ')}>`
 }
 
 /**