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[]]