chore: wip

Author: chrisbbreuer

fixtures/output/variable.d.ts

@@ -12,55 +12,55 @@ export declare const someObject: {
   someArray: Array<1 | 2 | 3>;
   someNestedArray: Array<Array<1 | 2 | 3> | Array<4 | 5 | 6 | 7 | 8 | 9 | 10>>;
   someNestedArray2: Array<
-  Array<1 | 2 | 3>
-  Array<4 | 5 | 6 | 7 | 8 | 9 | 10>
-  'dummy value'
->;
+    Array<1 | 2 | 3> |
+    Array<4 | 5 | 6 | 7 | 8 | 9 | 10> |
+    'dummy value'
+    >;
   someNestedArray3: Array<
-  Array<1 | 2 | 3>
-  Array<4 | 5 | 6 | 7 | 8 | 9 | 10>
-  'dummy value'
-  Array<11 | 12 | 13>
->;
+    Array<1 | 2 | 3> |
+    Array<4 | 5 | 6 | 7 | 8 | 9 | 10> |
+    'dummy value' |
+    Array<11 | 12 | 13>
+    >;
   someOtherNestedArray: Array<
-  Array<'some text' | 2 | unknown | (() => void) | unknown>
-  Array<4 | 5 | 6 | 7 | 8 | 9 | 10>
->;
+    Array<'some text' | 2 | unknown | (() => void) | unknown> |
+    Array<4 | 5 | 6 | 7 | 8 | 9 | 10>
+    >;
   someComplexArray: Array<
-  Array<
-      {
-            key: 'value'
-          }
-    >
-  Array<
-      {
-            key2: 'value2'
-          }
-      'test'
-      1000
-    >
-  Array<'some string' | unknown | unknown>
->;
+    Array<
+    {
+    key: 'value'
+    }
+    > |
+    Array<
+    {
+    key2: 'value2'
+    } |
+    'test' |
+    1000
+    > |
+    Array<'some string' | unknown | unknown>
+    >;
   someObject: {
     key: 'value'
-  };
+    };
   someNestedObject: {
     key: {
-      nestedKey: 'value'
+    nestedKey: 'value'
     };
     otherKey: {
-      nestedKey: unknown;
-      nestedKey2: () => unknown
+    nestedKey: unknown;
+    nestedKey2: () => void
     }
-  };
+    };
   someNestedObjectArray: Array<
-  {
-      key: 'value'
-    }
-  {
-      key2: 'value2'
+    {
+    key: 'value'
+    } |
+    {
+    key2: 'value2'
     }
->;
+    >;
   someOtherObject: unknown;
   someInlineCall2: unknown;
   someInlineCall3: unknown
@@ -72,27 +72,27 @@ export declare const defaultHeaders: {
 declare const dtsConfig: DtsGenerationConfig;
 export declare const complexArrays: {
   matrix: Array<
-  Array<1 | 2 | Array<3 | 4 | Array<5 | 6>>>
-  Array<'a' | 'b' | Array<'c' | 'd'>>
-  Array<true | Array<false | Array<true>>>
->;
+    Array<1 | 2 | Array<3 | 4 | Array<5 | 6>>> |
+    Array<'a' | 'b' | Array<'c' | 'd'>> |
+    Array<true | Array<false | Array<true>>>
+    >;
   tuples: Array<readonly [1, 'string', true] | readonly ['literal', 42, false]>;
   mixedArrays: Array<
-  unknown
-  unknown
-  ((...args: any[]) => unknown)
-  ((...args: any[]) => unknown)
->
+    unknown |
+    unknown |
+    ((...args: any[]) => unknown) |
+    ((...args: any[]) => unknown)
+    >
 };
 export declare const complexObject: {
   handlers: {
-    onSuccess: (...args: any[]) => unknown;
-    onError: (error: Error & { code?: number }) => unknown
-  };
+    onSuccess: <T> (data: T) => Promise<void>;
+    onError: (error: Error & { code?: number }) => never
+    };
   utils: {
     formatters: {
-      date: (input: Date) => unknown;
-      currency: (amount: number, currency: string) => unknown
+    date: (input: Date) => string;
+    currency: (amount: number, currency: string) => string
+    }
     }
-  }
 };

src/extract.ts

@@ -624,19 +624,26 @@ function inferArrayType(value: string, state?: ProcessingState, indentLevel = 0)
   )
 
   if (needsMultiline) {
-    const formattedTypes = types.map((type) => {
-      // Indent nested types that have newlines
+    const formattedTypes = types.map((type, index) => {
+      const isLast = index === types.length - 1
+      // For types that contain newlines, maintain their internal formatting
       if (type.includes('\n')) {
-        return type.replace(/\n/g, `\n${elementIndent}`)
+        const lines = type.split('\n')
+        const formattedLines = lines.map((line, i) => {
+          if (i === 0)
+            return line
+          // Increment indentation for nested lines
+          const currentIndent = line.match(/^\s*/)[0]
+          const additionalIndent = '  '.repeat(indentLevel + 1)
+          return `${additionalIndent}${line.trimLeft()}`
+        }).join('\n')
+        return `${elementIndent}${formattedLines}${isLast ? '' : ' |'}`
       }
-      return type
+      // For single-line types
+      return `${elementIndent}${type}${isLast ? '' : ' |'}`
     })
 
-    return [
-      'Array<',
-      ...formattedTypes.map(type => `${elementIndent}${type}`),
-      `${baseIndent}>`,
-    ].join('\n')
+    return `Array<\n${formattedTypes.join('\n')}\n${baseIndent}>`
   }
 
   return `Array<${types.join(' | ')}>`
@@ -654,56 +661,28 @@ function inferComplexObjectType(value: string, state?: ProcessingState, indentLe
 
   const baseIndent = '  '.repeat(indentLevel)
   const propIndent = '  '.repeat(indentLevel + 1)
+  const innerIndent = '  '.repeat(indentLevel + 2)
 
   const props = processObjectProperties(content, state)
   if (!props.length)
     return '{}'
 
-  // Group methods and regular properties
-  const methods: Array<{ key: string, value: string }> = []
-  const regularProps: Array<{ key: string, value: string }> = []
+  const propertyStrings = props.map(({ key, value }) => {
+    const formattedKey = /^\w+$/.test(key) ? key : `'${key}'`
 
-  props.forEach((prop) => {
-    if (prop.key.includes('('))
-      methods.push(prop)
-    else
-      regularProps.push(prop)
-  })
-
-  const parts: string[] = []
-
-  if (methods.length > 0) {
-    const methodsStr = processObjectMethods(methods, state, indentLevel + 1)
-    if (methodsStr !== '{}') {
-      parts.push(methodsStr.slice(1, -1).trim()) // Remove outer braces
+    // Handle multiline values (like objects and arrays)
+    if (value.includes('\n')) {
+      const indentedValue = value
+        .split('\n')
+        .map((line, i) => i === 0 ? line : `${innerIndent}${line.trimLeft()}`)
+        .join('\n')
+      return `${propIndent}${formattedKey}: ${indentedValue}`
     }
-  }
-
-  if (regularProps.length > 0) {
-    const propsStr = regularProps.map(({ key, value }) => {
-      const formattedKey = /^\w+$/.test(key) ? key : `'${key}'`
-      let formattedValue = value
-
-      // Format nested objects with proper indentation
-      if (value.startsWith('{')) {
-        formattedValue = inferComplexObjectType(value, state, indentLevel + 1)
-      }
-      // Format array types with proper indentation
-      else if (value.startsWith('Array<')) {
-        // Extract the array content and re-indent it
-        const arrayContent = value.slice(6, -1)
-        formattedValue = `Array<${arrayContent}>`
-      }
-
-      return `${propIndent}${formattedKey}: ${formattedValue}`
-    }).join(';\n')
-    parts.push(propsStr)
-  }
 
-  if (parts.length === 0)
-    return '{}'
+    return `${propIndent}${formattedKey}: ${value}`
+  })
 
-  return `{\n${parts.join(';\n')}\n${baseIndent}}`
+  return `{\n${propertyStrings.join(';\n')}\n${baseIndent}}`
 }
 
 function inferConstArrayType(value: string, state?: ProcessingState): string {