@stacksjs/dtsx 0.9.9 → 0.9.10

package/dist/parser.d.ts

@@ -1,38 +1,33 @@
 /**
- * Remove leading comments from a declaration
+ * @deprecated Use TypeScript AST-based extraction instead
  */
-/* eslint-disable regexp/no-super-linear-backtracking */
 export declare function removeLeadingComments(text: string): string;
 /**
- * Extract leading comments from source code before a position
+ * @deprecated Use extractJSDocComments from extractor/helpers instead
  */
 export declare function extractLeadingComments(source: string, position: number): string[];
 /**
- * Extract trailing comments from a line
+ * @deprecated Not commonly used - use inline logic instead
  */
 export declare function extractTrailingComment(line: string): string | null;
 /**
- * Format comments for output
- */
-export declare function formatComments(comments: string[]): string[];
-/**
- * Extract balanced content between symbols (e.g., <>, (), {})
+ * @deprecated Use findMatchingBracket from processor/type-inference instead
  */
 export declare function extractBalancedSymbols(text: string, openSymbol: string, closeSymbol: string): { content: string, rest: string } | null;
 /**
- * Parse a function declaration
+ * @deprecated Use TypeScript AST-based extraction instead
  */
 export declare function parseFunctionDeclaration(text: string): FunctionSignature | null;
 /**
- * Check if a line is an export statement
+ * @deprecated Use hasExportModifier from extractor/helpers instead
  */
 export declare function isExportStatement(line: string): boolean;
 /**
- * Check if a line is a type-only export
+ * @deprecated Not commonly used
  */
 export declare function isTypeOnlyExport(line: string): boolean;
 /**
- * Extract variable name and type from declaration
+ * @deprecated Use TypeScript AST-based extraction instead
  */
 export declare function parseVariableDeclaration(text: string): {
   name: string
@@ -41,7 +36,7 @@ export declare function parseVariableDeclaration(text: string): {
   value?: string
 } | null;
 /**
- * Extract function signature parts
+ * @deprecated Interface kept for backward compatibility
  */
 export declare interface FunctionSignature {
   name: string
@@ -49,4 +44,18 @@ export declare interface FunctionSignature {
   parameters: string
   returnType: string
   modifiers: string[]
-}
+}
+/**
+ * Parser utilities - DEPRECATED
+ *
+ * This module contains legacy string-based parsing utilities.
+ * Most functionality has been superseded by TypeScript AST-based extraction
+ * in the extractor module.
+ *
+ * @deprecated Use extractor module for AST-based extraction and
+ * processor/type-inference for type inference utilities.
+ */
+export { extractJSDocComments as extractLeadingCommentsFromNode, getNodeText } from './extractor/helpers';
+export { formatComments } from './processor/comments';
+// Re-export commonly used utilities from their new locations
+export { findMatchingBracket } from './processor/type-inference';

package/dist/plugins/bun.d.ts

@@ -0,0 +1,58 @@
+import type { DtsGenerationConfig, GenerationStats } from '../types';
+/**
+ * Create a Bun build plugin for dtsx
+ *
+ * @example
+ * ```ts
+ * // build.ts
+ * import { dts } from '@stacksjs/dtsx/plugins/bun'
+ *
+ * await Bun.build({
+ *   entrypoints: ['./src/index.ts'],
+ *   outdir: './dist',
+ *   plugins: [
+ *     dts({
+ *       root: './src',
+ *       outdir: './dist',
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare function dts(options?: BunPluginOptions): BunPlugin;
+/**
+ * Alias for dts
+ */
+export declare const bunDts: typeof dts;
+/**
+ * Bun plugin options
+ */
+export declare interface BunPluginOptions extends Partial<DtsGenerationConfig> {
+  preBuild?: boolean
+  postBuild?: boolean
+  onGenerated?: (stats: GenerationStats) => void
+  onError?: (error: Error) => void
+}
+/**
+ * Bun plugin interface
+ */
+declare interface BunPlugin {
+  name: string
+  setup: (build: BunBuild) => void | Promise<void>
+}
+/**
+ * Bun build interface (minimal type)
+ */
+declare interface BunBuild {
+  onStart: (callback: () => void | Promise<void>) => void
+  onLoad: (options: { filter: RegExp }, callback: (args: { path: string }) => unknown) => void
+  config: {
+    entrypoints: string[]
+    outdir?: string
+    root?: string
+  }
+}
+/**
+ * Default export
+ */
+export default dts;

package/dist/plugins/esbuild.d.ts

@@ -0,0 +1,63 @@
+import type { DtsGenerationConfig, GenerationStats } from '../types';
+/**
+ * Create an esbuild plugin for dtsx
+ *
+ * @example
+ * ```ts
+ * // build.ts
+ * import { dtsx } from '@stacksjs/dtsx/plugins/esbuild'
+ * import * as esbuild from 'esbuild'
+ *
+ * await esbuild.build({
+ *   entryPoints: ['./src/index.ts'],
+ *   outdir: './dist',
+ *   plugins: [
+ *     dtsx({
+ *       root: './src',
+ *       outdir: './dist',
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare function dtsx(options?: EsbuildPluginOptions): EsbuildPlugin;
+/**
+ * Alias for dtsx
+ */
+export declare const esbuildDts: typeof dtsx;
+/**
+ * Alias matching common naming convention
+ */
+export declare const dts: typeof dtsx;
+/**
+ * esbuild plugin options
+ */
+export declare interface EsbuildPluginOptions extends Partial<DtsGenerationConfig> {
+  onStart?: boolean
+  onEnd?: boolean
+  onGenerated?: (stats: GenerationStats) => void
+  onError?: (error: Error) => void
+}
+/**
+ * esbuild plugin interface
+ */
+declare interface EsbuildPlugin {
+  name: string
+  setup: (build: EsbuildBuild) => void | Promise<void>
+}
+/**
+ * esbuild build interface (minimal type)
+ */
+declare interface EsbuildBuild {
+  onStart: (callback: () => { errors?: Array<{ text: string }> } | Promise<{ errors?: Array<{ text: string }> } | void> | void) => void
+  onEnd: (callback: (result: { errors: unknown[] }) => void | Promise<void>) => void
+  initialOptions: {
+    entryPoints?: string[] | Record<string, string>
+    outdir?: string
+    outfile?: string
+  }
+}
+/**
+ * Default export
+ */
+export default dtsx;

package/dist/plugins/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build tool plugins for dtsx
+ * Re-exports all available build tool integrations
+ */
+// Vite
+export { dts as viteDts, dts as vite, type VitePluginOptions } from './vite';
+// Bun
+export { dts as bunDts, dts as bun, type BunPluginOptions } from './bun';
+// esbuild
+export { dtsx as esbuildDts, dtsx as esbuild, dts as esbuildPlugin, type EsbuildPluginOptions } from './esbuild';
+// tsup
+export { dtsxPlugin as tsupDts, dtsxPlugin as tsup, dts as tsupPlugin, type TsupPluginOptions } from './tsup';
+// webpack
+export { DtsxWebpackPlugin, dtsxWebpack as webpackDts, dts as webpackPlugin, type WebpackPluginOptions } from './webpack';

package/dist/plugins/tsup.d.ts

@@ -0,0 +1,53 @@
+import type { DtsGenerationConfig, GenerationStats } from '../types';
+/**
+ * Create a tsup plugin for dtsx
+ *
+ * @example
+ * ```ts
+ * // tsup.config.ts
+ * import { dtsxPlugin } from '@stacksjs/dtsx/plugins/tsup'
+ * import { defineConfig } from 'tsup'
+ *
+ * export default defineConfig({
+ *   entry: ['./src/index.ts'],
+ *   outDir: './dist',
+ *   plugins: [
+ *     dtsxPlugin({
+ *       root: './src',
+ *       outdir: './dist',
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare function dtsxPlugin(options?: TsupPluginOptions): TsupPlugin;
+/**
+ * Alias for dtsxPlugin
+ */
+export declare const tsupDts: typeof dtsxPlugin;
+/**
+ * Alias matching common naming convention
+ */
+export declare const dts: typeof dtsxPlugin;
+/**
+ * tsup plugin options
+ */
+export declare interface TsupPluginOptions extends Partial<DtsGenerationConfig> {
+  onBuildStart?: boolean
+  onBuildEnd?: boolean
+  onGenerated?: (stats: GenerationStats) => void
+  onError?: (error: Error) => void
+}
+/**
+ * tsup plugin interface
+ */
+declare interface TsupPlugin {
+  name: string
+  buildStart?: () => void | Promise<void>
+  buildEnd?: (ctx: { writtenFiles: Array<{ name: string, size: number }> }) => void | Promise<void>
+  esbuildOptions?: (options: Record<string, unknown>) => void
+}
+/**
+ * Default export
+ */
+export default dtsxPlugin;

package/dist/plugins/vite.d.ts

@@ -0,0 +1,49 @@
+import type { DtsGenerationConfig, GenerationStats } from '../types';
+/**
+ * Create a Vite plugin for dtsx
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { dts } from '@stacksjs/dtsx/plugins/vite'
+ *
+ * export default {
+ *   plugins: [
+ *     dts({
+ *       root: './src',
+ *       outdir: './dist',
+ *     }),
+ *   ],
+ * }
+ * ```
+ */
+export declare function dts(options?: VitePluginOptions): VitePlugin;
+/**
+ * Alias for dts
+ */
+export declare const viteDts: typeof dts;
+/**
+ * Vite plugin options
+ */
+export declare interface VitePluginOptions extends Partial<DtsGenerationConfig> {
+  buildStart?: boolean
+  buildEnd?: boolean
+  writeBundle?: boolean
+  modes?: string[]
+  onGenerated?: (stats: GenerationStats) => void
+  onError?: (error: Error) => void
+}
+/**
+ * Vite plugin interface (minimal type for compatibility)
+ */
+declare interface VitePlugin {
+  name: string
+  apply?: 'build' | 'serve' | ((_config: { mode: string }) => boolean)
+  buildStart?: () => Promise<void> | void
+  buildEnd?: () => Promise<void> | void
+  writeBundle?: () => Promise<void> | void
+}
+/**
+ * Default export
+ */
+export default dts;

package/dist/plugins/webpack.d.ts

@@ -0,0 +1,66 @@
+import type { DtsGenerationConfig, GenerationStats } from '../types';
+/**
+ * Factory function for creating webpack plugin
+ */
+export declare function dtsxWebpack(options?: WebpackPluginOptions): DtsxWebpackPlugin;
+/**
+ * Alias matching common naming convention
+ */
+export declare const dts: typeof dtsxWebpack;
+/**
+ * webpack plugin options
+ */
+export declare interface WebpackPluginOptions extends Partial<DtsGenerationConfig> {
+  onCompile?: boolean
+  afterEmit?: boolean
+  onWatchRun?: boolean
+  onGenerated?: (stats: GenerationStats) => void
+  onError?: (error: Error) => void
+}
+/**
+ * webpack compiler interface (minimal type)
+ */
+declare interface WebpackCompiler {
+  hooks: {
+    compile: { tap: (name: string, callback: () => void) => void }
+    afterEmit: { tapAsync: (name: string, callback: (compilation: unknown, done: () => void) => void) => void }
+    watchRun: { tapAsync: (name: string, callback: (compiler: unknown, done: () => void) => void) => void }
+  }
+  options: {
+    entry?: unknown
+    output?: {
+      path?: string
+    }
+    context?: string
+  }
+}
+/**
+ * webpack plugin for dtsx
+ *
+ * @example
+ * ```ts
+ * // webpack.config.js
+ * const { DtsxWebpackPlugin } = require('@stacksjs/dtsx/plugins/webpack')
+ *
+ * module.exports = {
+ *   entry: './src/index.ts',
+ *   output: {
+ *     path: path.resolve(__dirname, 'dist'),
+ *   },
+ *   plugins: [
+ *     new DtsxWebpackPlugin({
+ *       root: './src',
+ *       outdir: './dist',
+ *     }),
+ *   ],
+ * }
+ * ```
+ */
+export declare class DtsxWebpackPlugin {
+  constructor(options?: WebpackPluginOptions);
+  apply(compiler: WebpackCompiler): void;
+}
+/**
+ * Default export
+ */
+export default DtsxWebpackPlugin;

package/dist/plugins.d.ts

@@ -0,0 +1,83 @@
+import type { Declaration, DtsGenerationConfig, GenerationStats } from './types';
+/**
+ * Helper to create a plugin
+ */
+export declare function definePlugin(plugin: Plugin): Plugin;
+/**
+ * Built-in plugin: Add banner comment
+ * Adds a banner comment to the top of generated files
+ */
+export declare function createBannerPlugin(banner: string): Plugin;
+/**
+ * Built-in plugin: Filter exports
+ * Only include declarations matching the filter
+ */
+export declare function createFilterPlugin(filter: (name: string) => boolean): Plugin;
+/**
+ * Global plugin manager instance
+ */
+export declare const pluginManager: PluginManager;
+/**
+ * Built-in plugin: Strip internal declarations
+ * Removes declarations marked with @internal in JSDoc
+ */
+export declare const stripInternalPlugin: Plugin;
+/**
+ * Context passed to plugin hooks
+ */
+export declare interface PluginContext {
+  filePath: string
+  sourceCode: string
+  config: DtsGenerationConfig
+  log: {
+    debug: (message: string) => void
+    info: (message: string) => void
+    warn: (message: string) => void
+    error: (message: string) => void
+  }
+}
+/**
+ * Transform context with mutable content
+ */
+export declare interface TransformContext extends PluginContext {
+  content: string
+}
+/**
+ * Declaration context for declaration hooks
+ */
+export declare interface DeclarationContext extends PluginContext {
+  declarations: Declaration[]
+}
+/**
+ * Plugin hook definitions
+ */
+export declare interface PluginHooks {
+  onStart?: (config: DtsGenerationConfig) => DtsGenerationConfig | void | Promise<DtsGenerationConfig | void>
+  onBeforeFile?: (ctx: TransformContext) => string | void | Promise<string | void>
+  onDeclarations?: (ctx: DeclarationContext) => Declaration[] | void | Promise<Declaration[] | void>
+  onAfterFile?: (ctx: TransformContext) => string | void | Promise<string | void>
+  onEnd?: (stats: GenerationStats) => void | Promise<void>
+  onError?: (error: Error, ctx: PluginContext) => void | Promise<void>
+}
+/**
+ * Plugin definition
+ */
+export declare interface Plugin extends PluginHooks {
+  name: string
+  version?: string
+  description?: string
+}
+/**
+ * Plugin manager for handling multiple plugins
+ */
+export declare class PluginManager {
+  register(plugin: Plugin): void;
+  unregister(name: string): boolean;
+  getPlugins(): readonly Plugin[];
+  runOnStart(config: DtsGenerationConfig): Promise<DtsGenerationConfig>;
+  runOnBeforeFile(filePath: string, sourceCode: string): Promise<string>;
+  runOnDeclarations(filePath: string, sourceCode: string, declarations: Declaration[]): Promise<Declaration[]>;
+  runOnAfterFile(filePath: string, sourceCode: string, dtsContent: string): Promise<string>;
+  runOnEnd(stats: GenerationStats): Promise<void>;
+  runOnError(error: Error, filePath: string, sourceCode: string): Promise<void>;
+}

package/dist/process-source.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Process TypeScript source code from a string (for stdin support)
+ * This is a lightweight module that avoids pulling in heavy dependencies
+ * like bun Glob, fs/promises, bundler, cache, config, etc.
+ */
+export declare function processSource(sourceCode: string, filename?: string, keepComments?: boolean, importOrder?: string[], isolatedDeclarations?: boolean): string;
+/**
+ * Fast path for project mode — skips cache lookup/store.
+ * Use when processing many files once (no cache benefit).
+ */
+export declare function processSourceDirect(sourceCode: string, filename?: string, keepComments?: boolean, importOrder?: string[], isolatedDeclarations?: boolean): string;

package/dist/processor/cache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get or create a cached RegExp for word boundary matching
+ */
+export declare function getCachedRegex(pattern: string): RegExp;
+/**
+ * Get cached import items or null if not cached
+ */
+export declare function getImportItemsFromCache(importText: string): string[] | null;
+/**
+ * Store import items in cache with eviction
+ */
+export declare function setImportItemsCache(importText: string, items: string[]): void;
+/**
+ * Clear processor caches (useful for testing or memory management)
+ */
+export declare function clearProcessorCaches(): void;

package/dist/processor/comments.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Comment formatting utilities for DTS output
+ */
+/**
+ * Format comments for DTS output
+ */
+export declare function formatComments(comments: string[] | undefined, keepComments?: boolean): string;

package/dist/processor/declarations.d.ts

@@ -0,0 +1,37 @@
+import type { Declaration } from '../types';
+/**
+ * Process function declaration to DTS format
+ */
+export declare function processFunctionDeclaration(decl: Declaration, keepComments?: boolean): string;
+/**
+ * Process variable declaration to DTS format
+ */
+export declare function processVariableDeclaration(decl: Declaration, keepComments?: boolean): string;
+/**
+ * Process interface declaration to DTS format
+ */
+export declare function processInterfaceDeclaration(decl: Declaration, keepComments?: boolean): string;
+/**
+ * Process type alias declaration to DTS format
+ */
+export declare function processTypeDeclaration(decl: Declaration, keepComments?: boolean): string;
+/**
+ * Process class declaration to DTS format
+ */
+export declare function processClassDeclaration(decl: Declaration, keepComments?: boolean): string;
+/**
+ * Process enum declaration to DTS format
+ */
+export declare function processEnumDeclaration(decl: Declaration, keepComments?: boolean): string;
+/**
+ * Process import statement
+ */
+export declare function processImportDeclaration(decl: Declaration): string;
+/**
+ * Process export statement
+ */
+export declare function processExportDeclaration(decl: Declaration, keepComments?: boolean): string;
+/**
+ * Process module/namespace declaration to DTS format
+ */
+export declare function processModuleDeclaration(decl: Declaration, keepComments?: boolean): string;

package/dist/processor/imports.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Parse an import statement into its components using string operations
+ * Avoids regex backtracking issues
+ */
+export declare function parseImportStatement(importText: string): {
+  defaultName: string | null
+  namedItems: string[]
+  source: string
+  isTypeOnly: boolean
+} | null;
+/**
+ * Extract all imported items from an import statement (with caching)
+ * Uses simple string operations to avoid regex backtracking
+ */
+export declare function extractAllImportedItems(importText: string): string[];
+/**
+ * Parse an import statement with detailed type-only information for each item
+ * Handles: import type { X }, import { type X, Y }, import * as X, etc.
+ */
+export declare function parseImportDetailed(importText: string): ParsedImport | null;
+/**
+ * Parse an export statement with detailed type-only information
+ * Handles: export type { X }, export { type X, Y }, export * from, etc.
+ */
+export declare function parseExportDetailed(exportText: string): {
+  namedItems: ImportItem[]
+  source: string | null
+  isTypeOnly: boolean
+  isNamespace: boolean
+  isDefault: boolean
+} | null;
+/**
+ * Check if an import item is type-only
+ */
+export declare function isTypeOnlyImportItem(itemText: string): boolean;
+/**
+ * Convert import items to type-only format
+ * E.g., "{ X, Y }" becomes "{ type X, type Y }"
+ */
+export declare function convertToTypeOnlyImport(importText: string): string;
+/**
+ * Merge value and type imports from the same module
+ * Combines separate import statements into one where possible
+ */
+export declare function mergeImports(imports: string[]): string[];
+/**
+ * Represents a single imported item with its type-only status
+ */
+export declare interface ImportItem {
+  name: string
+  originalName: string
+  isTypeOnly: boolean
+  isDefault: boolean
+}
+/**
+ * Detailed import statement parse result
+ */
+export declare interface ParsedImport {
+  defaultName: string | null
+  namedItems: ImportItem[]
+  source: string
+  isTypeOnly: boolean
+  isNamespace: boolean
+  namespaceName: string | null
+}

package/dist/processor/index.d.ts

@@ -0,0 +1,34 @@
+import { extractAllImportedItems, parseImportStatement } from './imports';
+import { formatComments } from './comments';
+import { processClassDeclaration, processEnumDeclaration, processFunctionDeclaration, processInterfaceDeclaration, processModuleDeclaration, processTypeDeclaration, processVariableDeclaration } from './declarations';
+import type { Declaration, ProcessingContext } from '../types';
+/**
+ * Process declarations and convert them to narrow DTS format
+ */
+export declare function processDeclarations(declarations: Declaration[], context: ProcessingContext, keepComments?: boolean, importOrder?: string[]): string;
+// Re-export all public APIs
+export { clearProcessorCaches } from './cache';
+export { formatComments } from './comments';
+export {
+  processClassDeclaration,
+  processEnumDeclaration,
+  processExportDeclaration,
+  processFunctionDeclaration,
+  processImportDeclaration,
+  processInterfaceDeclaration,
+  processModuleDeclaration,
+  processTypeDeclaration,
+  processVariableDeclaration,
+} from './declarations';
+export { extractAllImportedItems, parseImportStatement } from './imports';
+export {
+  extractSatisfiesType,
+  findMatchingBracket,
+  inferArrayType,
+  inferFunctionType,
+  inferNarrowType,
+  inferNarrowTypeInUnion,
+  inferObjectType,
+  isGenericType,
+  parseArrayElements,
+} from './type-inference';