chore: wip

Author: chrisbbreuer

src/processor.ts

@@ -1240,8 +1240,12 @@ function inferFunctionType(value: string, inUnion: boolean = false): string {
       const innerFuncType = inferFunctionType(body, false)
       returnType = innerFuncType
     } else {
-      // Expression body - try to infer
-      returnType = inferNarrowType(body, false)
+      // Expression body - try to infer, but be conservative in union contexts
+      if (inUnion) {
+        returnType = 'unknown'
+      } else {
+        returnType = inferNarrowType(body, false)
+      }
     }
 
     const funcType = `${generics}${params} => ${returnType}`

test/dts.test.ts

@@ -6,8 +6,8 @@ import { generate } from '../src/generator'
 
 describe('dts-generation', () => {
   const testDir = join(__dirname, 'fixtures')
-  const inputDir = join(testDir, 'input', 'example')
-  const outputDir = join(testDir, 'output', 'example')
+  const inputDir = join(testDir, 'input')
+  const outputDir = join(testDir, 'output')
   const generatedDir = join(testDir, 'generated')
 
   // List of all example files to test
@@ -25,11 +25,27 @@ describe('dts-generation', () => {
     '0011'
   ]
 
+  // List of all fixture files to test (excluding checker.ts which is too large)
+  const fixtures = [
+    'class',
+    'edge-cases',
+    'enum',
+    'exports',
+    'function',
+    'function-types',
+    'imports',
+    'interface',
+    'module',
+    'namespace',
+    'type',
+    'variable'
+  ]
+
   // Generate a test for each example file
   examples.forEach((example) => {
     it(`should properly generate types for example ${example}`, async () => {
       const config: DtsGenerationOption = {
-        entrypoints: [join(inputDir, `${example}.ts`)],
+        entrypoints: [join(inputDir, 'example', `${example}.ts`)],
         outdir: generatedDir,
         clean: false,
         tsconfigPath: join(__dirname, '..', 'tsconfig.json'),
@@ -38,7 +54,7 @@ describe('dts-generation', () => {
 
       await generate(config)
 
-      const outputPath = join(outputDir, `${example}.d.ts`)
+      const outputPath = join(outputDir, 'example', `${example}.d.ts`)
       const generatedPath = join(generatedDir, `${example}.d.ts`)
 
       const expectedContent = await Bun.file(outputPath).text()
@@ -48,6 +64,29 @@ describe('dts-generation', () => {
     })
   })
 
+  // Generate a test for each fixture file
+  fixtures.forEach((fixture) => {
+    it(`should properly generate types for fixture ${fixture}`, async () => {
+      const config: DtsGenerationOption = {
+        entrypoints: [join(inputDir, `${fixture}.ts`)],
+        outdir: generatedDir,
+        clean: false,
+        tsconfigPath: join(__dirname, '..', 'tsconfig.json'),
+        outputStructure: 'flat',
+      }
+
+      await generate(config)
+
+      const outputPath = join(outputDir, `${fixture}.d.ts`)
+      const generatedPath = join(generatedDir, `${fixture}.d.ts`)
+
+      const expectedContent = await Bun.file(outputPath).text()
+      const generatedContent = await Bun.file(generatedPath).text()
+
+      expect(generatedContent).toBe(expectedContent)
+    })
+  })
+
   afterEach(async () => {
     // Clean up generated files
     try {

test/fixtures/output/exports.d.ts

@@ -1,17 +1,13 @@
 import type { BunPlugin } from 'bun';
-import type { SomeOtherType } from '@stacksjs/types';
 import { dtsConfig } from './config';
-import { generate, something as dts } from './generate';
-
-export type { SomeOtherType }
-export type { BunRegisterPlugin } from 'bun'
-
-export { generate, dtsConfig, type BunPlugin }
-export { config } from './config'
-
-export * from './extract'
-export * from './generate'
-export * from './types'
-export * from './utils'
-
+import { generate } from './generate';
+import type { SomeOtherType } from '@stacksjs/types';
+export type { SomeOtherType };
+export type { BunRegisterPlugin } from 'bun';
+export { generate, dtsConfig, type BunPlugin };
+export { config } from './config';
+export * from './extract';
+export * from './generate';
+export * from './types';
+export * from './utils';
 export default dts;

test/fixtures/output/function.d.ts

@@ -1,6 +1,5 @@
 import type { BunPlugin } from 'bun';
 import type { DtsGenerationOption } from '@stacksjs/dtsx';
-
 export declare function fetchUsers(): Promise<ResponseData>;
 export declare function getProduct(id: number): Promise<ApiResponse<Product>>;
 export declare function authenticate(user: string, password: string): Promise<AuthResponse>;

test/fixtures/output/imports.d.ts

@@ -1,18 +1,27 @@
-import forge, { pki, tls } from 'node-forge';
 import { basename, delimiter, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep, toNamespacedPath } from 'node:path';
 import { generate } from '@stacksjs/dtsx';
-import { something as dts } from './generate';
-
+import forge, { pki, tls } from 'node-forge';
 export declare function actionsPath(path?: string): string;
 export declare function corePath(path?: string): string;
 export declare function frameworkPath(path?: string, options?: { relative?: boolean, cwd?: string }): string;
 export declare function storagePath(path?: string): string;
-export declare function projectPath(filePath = '', options?: { relative: boolean }): string;
+export declare function projectPath(filePath?: any, options?: { relative: boolean }): string;
 export declare function userActionsPath(path?: string, options?: { relative: true }): string;
 export declare function builtUserActionsPath(path?: string, options?: { relative: boolean }): string;
 export declare function homeDir(path?: string): string;
-export declare type LibraryType = 'vue-components' | 'web-components' | 'functions'
 export declare function libraryEntryPath(type: LibraryType): string;
 export declare function examplesPath(type?: 'vue-components' | 'web-components'): string;
-
-export { basename, forge, generate, pki, tls, delimiter, dirname, dts, extname, isAbsolute, join, normalize, relative, resolve, sep, toNamespacedPath }
+export declare const path: Path;
+export declare interface Path {
+  actionsPath: (path?: string) => string
+  userActionsPath: (path?: string) => string
+  builtUserActionsPath: (path?: string, option?: { relative: boolean }) => string
+  examplesPath: (type?: 'vue-components' | 'web-components') => string
+  libraryEntryPath: (type: LibraryType) => string
+  homeDir: (path?: string) => string
+  parse: (path: string) => ParsedPath
+  sep: () => '/' | '\\'
+}
+export type LibraryType = 'vue-components' | 'web-components' | 'functions'
+export { basename, forge, generate, pki, tls, delimiter, dirname, dts, extname, isAbsolute, join, normalize, relative, resolve, sep, toNamespacedPath };
+export default forge;

test/fixtures/output/interface.d.ts

@@ -21,23 +21,14 @@ export declare interface AuthResponse {
   token: string
   expiresIn: number
 }
-declare interface Options<T> {
-  name: string
-  cwd?: string
-  defaultConfig: T
-}
 export declare interface ComplexGeneric<T extends Record<string, unknown>, K extends keyof T> {
   data: T
   key: K
   value: T[K]
   transform: (input: T[K]) => string
   nested: Array<Partial<T>>
 }
-export declare interface DefaultGeneric<
-  T = string,
-  K extends keyof any = string,
-  V extends Record<K, T> = Record<K, T>
-> {
+export declare interface DefaultGeneric<T = string, K extends keyof any = string, V extends Record<K, T> = Record<K, T>> {
   key: K
   value: T
   record: V

test/fixtures/output/module.d.ts

@@ -1,12 +1,11 @@
 declare module '@stacksjs/some-module' {
   interface DtsGenerationConfig {
-    customPlugins?: Array<{
+  customPlugins?: Array<{
       name: string
       transform: (code: string) => string
     }>
-  }
-
+}
   interface DtsGenerationResult {
-    customPluginResults?: Record<string, string>
-  }
+  customPluginResults?: Record<string, string>
+}
 }

test/fixtures/output/type.d.ts

@@ -1,64 +1,50 @@
 import type { DtsGenerationOption } from '@stacksjs/dtsx';
-
-export type { DtsGenerationOption }
-export declare type AuthStatus = 'authenticated' | 'unauthenticated'
-
-export type ComplexUnionIntersection =
-  | (User & { role: 'admin' })
+export type { DtsGenerationOption };
+export type AuthStatus = 'authenticated' | 'unauthenticated'
+export type ComplexUnionIntersection = | (User & { role: 'admin' })
   | (Product & { category: string })
   & {
     metadata: Record<string, unknown>
   }
-
-
 export type ReadonlyDeep<T> = {
   readonly [P in keyof T]: T[P] extends object ? ReadonlyDeep<T[P]> : T[P]
 }
-
 export type ConditionalResponse<T> = T extends Array<infer U>
   ? ApiResponse<U[]>
   : T extends object
     ? ApiResponse<T>
     : ApiResponse<string>
-
 export type EventType = 'click' | 'focus' | 'blur'
 export type ElementType = 'button' | 'input' | 'form'
 export type EventHandler = `on${Capitalize<EventType>}${Capitalize<ElementType>}`
-
 export type RecursiveObject = {
   id: string
   children?: RecursiveObject[]
   parent?: RecursiveObject
   metadata: Record<string, unknown>
 }
-
 export type UserId = string & { readonly __brand: unique symbol }
 export type ProductId = number & {
   readonly __brand: unique symbol
 }
-
 export type DeepPartial<T> = T extends object ? {
   [P in keyof T]?: DeepPartial<T[P]>
 } : T
-
 export type DeepRequired<T> = T extends object ? {
   [P in keyof T]-?: DeepRequired<T[P]>
 } : T
-
 export type PolymorphicComponent<P = {}> = {
   <C extends React.ElementType>(
     props: { as?: C } & Omit<React.ComponentPropsWithRef<C>, keyof P> & P
   ): React.ReactElement | null
 }
-
 export type DynamicRecord<K extends PropertyKey> = {
   [P in K]: P extends number
     ? Array<unknown>
     : P extends string
       ? Record<string, unknown>
       : never
 }
-
 export type RecordMerge<T, U> = IsEmptyType<U> extends true
   ? T
   : [T, U] extends [any[], any[]]