@stacksjs/dtsx 0.9.9 → 0.9.11

package/dist/memory.d.ts

@@ -0,0 +1,110 @@
+import type { Declaration, DtsGenerationConfig } from './types';
+/**
+ * Create memory-optimized configuration
+ */
+export declare function createMemoryOptimizedConfig(baseConfig: DtsGenerationConfig, memoryConfig?: MemoryConfig): DtsGenerationConfig & { memory: Required<MemoryConfig> };
+/**
+ * Estimate memory usage for a file
+ */
+export declare function estimateMemoryUsage(filePath: string): {
+  fileSizeMB: number
+  estimatedMemoryMB: number
+  recommendedChunkSize: number
+};
+/**
+ * Format memory stats for display
+ */
+export declare function formatMemoryStats(stats: MemoryStats): string;
+/**
+ * Create a streaming processor with default config
+ */
+export declare function createStreamingProcessor(config?: MemoryConfig): StreamingProcessor;
+/**
+ * Memory configuration options
+ */
+export declare interface MemoryConfig {
+  maxMemoryMB?: number
+  chunkSize?: number
+  aggressiveGC?: boolean
+  maxDeclarationsInMemory?: number
+  profile?: boolean
+  cleanupInterval?: number
+}
+/**
+ * Memory usage statistics
+ */
+export declare interface MemoryStats {
+  heapUsed: number
+  heapTotal: number
+  external: number
+  arrayBuffers: number
+  rss: number
+  heapUsedMB: number
+  percentUsed: number
+}
+/**
+ * Memory profiling entry
+ */
+export declare interface MemoryProfile {
+  timestamp: number
+  operation: string
+  memoryBefore: MemoryStats
+  memoryAfter: MemoryStats
+  duration: number
+}
+/**
+ * Streaming file processor for large files
+ */
+export declare class StreamingProcessor {
+  constructor(config?: MemoryConfig);
+  startMonitoring(): void;
+  stopMonitoring(): void;
+  triggerCleanup(): void;
+  getMemoryStats(): MemoryStats;
+  profile<T>(operation: string, fn: () => Promise<T>): Promise<T>;
+  getProfiles(): MemoryProfile[];
+  clearProfiles(): void;
+  *streamFile(filePath: string): AsyncGenerator<string, void, unknown>;
+  processFileInChunks<T>(filePath: string, processor: (chunk: string[]) => Promise<T[]>, chunkLines?: number): Promise<T[]>;
+  streamWrite(filePath: string, contentGenerator: AsyncGenerator<string>): Promise<void>;
+}
+/**
+ * Declaration pool for memory-efficient declaration management
+ */
+export declare class DeclarationPool {
+  constructor(maxSize?: number);
+  add(key: string, declaration: Declaration): void;
+  get(key: string): Declaration | undefined;
+  has(key: string): boolean;
+  delete(key: string): void;
+  clear(): void;
+  get size(): number;
+}
+/**
+ * Lazy loading wrapper for large objects
+ */
+export declare class LazyLoader<T> {
+  constructor(loader: () => T | Promise<T>);
+  get(): Promise<T>;
+  isLoaded(): boolean;
+  unload(): void;
+}
+/**
+ * String interning for memory efficiency
+ */
+export declare class StringInterner {
+  constructor(maxSize?: number);
+  intern(str: string): string;
+  get size(): number;
+  clear(): void;
+}
+/**
+ * Object pool for reusing declaration objects
+ */
+export declare class ObjectPool<T> {
+  constructor(factory: () => T, reset: (obj: T) => void, maxSize?: number);
+  acquire(): T;
+  release(obj: T): void;
+  get size(): number;
+  clear(): void;
+}

package/dist/merger.d.ts

@@ -0,0 +1,38 @@
+import type { Declaration } from './types';
+/**
+ * Merge declarations with the same name
+ */
+export declare function mergeDeclarations(declarations: Declaration[], config?: MergeConfig): MergeResult;
+/**
+ * Merge declarations in content string
+ */
+export declare function mergeDeclarationsInContent(content: string, _config?: MergeConfig): string;
+/**
+ * Merge configuration
+ */
+export declare interface MergeConfig {
+  mergeInterfaces?: boolean
+  mergeNamespaces?: boolean
+  mergeTypes?: boolean
+  mergeEnums?: boolean
+  deduplicateIdentical?: boolean
+  conflictStrategy?: 'first' | 'last' | 'error'
+  preserveAllComments?: boolean
+}
+/**
+ * Result of merge operation
+ */
+export declare interface MergeResult {
+  declarations: Declaration[]
+  mergedCount: number
+  merges: MergeDetail[]
+}
+/**
+ * Details of a single merge
+ */
+export declare interface MergeDetail {
+  name: string
+  kind: string
+  sourceCount: number
+  memberCount: number
+}

package/dist/optimizer.d.ts

@@ -0,0 +1,52 @@
+import type { Declaration } from './types';
+/**
+ * Optimize declarations
+ */
+export declare function optimizeDeclarations(declarations: Declaration[], config?: OptimizerConfig): { declarations: Declaration[], result: OptimizationResult };
+/**
+ * Optimize a .d.ts file
+ */
+export declare function optimizeFile(filePath: string, config?: OptimizerConfig): Promise<OptimizationResult>;
+/**
+ * Minify .d.ts content
+ */
+export declare function minifyDts(content: string): string;
+/**
+ * Optimizer configuration
+ */
+export declare interface OptimizerConfig {
+  removeUnusedImports?: boolean
+  deduplicateDeclarations?: boolean
+  inlineSimpleTypes?: boolean
+  removeEmptyInterfaces?: boolean
+  mergeInterfaces?: boolean
+  sortDeclarations?: boolean
+  sortImports?: boolean
+  removeComments?: boolean
+  minify?: boolean
+  treeShake?: boolean
+  entryPoints?: string[]
+}
+/**
+ * Optimization result
+ */
+export declare interface OptimizationResult {
+  originalSize: number
+  optimizedSize: number
+  savings: number
+  savingsPercent: number
+  removedImports: number
+  removedDeclarations: number
+  mergedInterfaces: number
+  inlinedTypes: number
+}
+/**
+ * Type usage tracker for tree shaking
+ */
+declare class _TypeUsageTracker {
+  addDeclaration(decl: Declaration): void;
+  addUsage(typeName: string): void;
+  addReference(fromType: string, toType: string): void;
+  getReachableTypes(): Set<string>;
+  isUsed(typeName: string): boolean;
+}

package/dist/output-normalizer.d.ts

@@ -0,0 +1,123 @@
+import type { DeclarationKind } from './types';
+/**
+ * Normalize output content
+ */
+export declare function normalizeOutput(content: string, config?: OutputNormalizerConfig): string;
+/**
+ * Normalize line endings
+ */
+export declare function normalizeLineEndings(content: string, style: LineEnding): string;
+/**
+ * Detect current line ending style
+ */
+export declare function detectLineEnding(content: string): LineEnding;
+/**
+ * Remove trailing whitespace from all lines
+ */
+export declare function removeTrailingWhitespace(content: string): string;
+/**
+ * Normalize blank lines (limit consecutive blank lines)
+ */
+export declare function normalizeBlankLines(content: string, max: number): string;
+/**
+ * Ensure content ends with exactly one newline
+ */
+export declare function ensureTrailingNewline(content: string): string;
+/**
+ * Normalize indentation
+ */
+export declare function normalizeIndent(content: string, config: { style?: 'spaces' | 'tabs', size?: number }): string;
+/**
+ * Process and organize imports
+ */
+export declare function processImports(content: string, config: ImportGrouping): string;
+/**
+ * Order declarations by kind
+ */
+export declare function orderDeclarations(content: string, config: DeclarationOrder): string;
+/**
+ * Preserve and format comments
+ */
+export declare function preserveCommentFormatting(content: string): string;
+/**
+ * Create a configured normalizer
+ */
+export declare function createOutputNormalizer(config?: OutputNormalizerConfig): {
+  normalize: (content: string) => string
+  normalizeLineEndings: (content: string) => string
+  removeTrailingWhitespace: typeof removeTrailingWhitespace
+  normalizeBlankLines: (content: string) => string
+  ensureTrailingNewline: typeof ensureTrailingNewline
+  processImports: (content: string) => string
+  orderDeclarations: (content: string) => string
+};
+/**
+ * Default declaration order
+ */
+export declare const DEFAULT_DECLARATION_ORDER: DeclarationKind[];
+/**
+ * Default import group order
+ */
+export declare const DEFAULT_IMPORT_GROUP_ORDER: ImportGroupType[];
+/**
+ * Preset configurations
+ */
+export declare const normalizerPresets: {
+  /** Default preset - LF, trailing newline, basic cleanup */
+  default: unknown;
+  /** Minimal preset - just line endings and trailing newline */
+  minimal: unknown;
+  /** Strict preset - all normalization enabled */
+  strict: unknown;
+  /** Windows preset - CRLF line endings */
+  windows: unknown;
+  /** Tabs preset - use tabs for indentation */
+  tabs: unknown
+};
+/**
+ * Declaration ordering configuration
+ */
+export declare interface DeclarationOrder {
+  kinds?: DeclarationKind[]
+  alphabetize?: boolean
+  groupExports?: boolean
+}
+/**
+ * Import grouping configuration
+ */
+export declare interface ImportGrouping {
+  enabled?: boolean
+  groups?: ImportGroupType[]
+  separateGroups?: boolean
+  alphabetize?: boolean
+}
+/**
+ * Output normalizer configuration
+ */
+export declare interface OutputNormalizerConfig {
+  lineEnding?: LineEnding
+  trailingNewline?: boolean
+  maxBlankLines?: number
+  trimTrailingWhitespace?: boolean
+  normalizeIndentation?: boolean
+  indent?: {
+    style?: 'spaces' | 'tabs'
+    size?: number
+  }
+  declarationOrder?: DeclarationOrder
+  importGrouping?: ImportGrouping
+  preserveComments?: boolean
+  insertFinalNewline?: boolean
+}
+/**
+ * Line ending style
+ */
+export type LineEnding = 'lf' | 'crlf' | 'auto';
+export type ImportGroupType = | 'builtin' // node:* modules
+  | 'external' // npm packages
+  | 'scoped' // @org/* packages
+  | 'internal' // @/* or ~/* aliases
+  | 'parent' // ../* imports
+  | 'sibling' // ./* imports
+  | 'index' // . or ./index
+  | 'type' // import type;

package/dist/parallel-processor.d.ts

@@ -0,0 +1,63 @@
+import type { DtsGenerationConfig } from './types';
+/**
+ * Build dependency graph from source files
+ */
+export declare function buildProcessingGraph(files: string[], rootDir?: string): Promise<Map<string, ProcessingNode>>;
+/**
+ * Process files in parallel respecting dependencies
+ */
+export declare function processInParallel(files: string[], options?: ParallelProcessorConfig): Promise<ParallelProcessingResult>;
+/**
+ * Get topological processing order (respects dependencies)
+ */
+export declare function getTopologicalOrder(graph: Map<string, ProcessingNode>): string[];
+/**
+ * Find files that can be processed independently (no dependencies on other files in the set)
+ */
+export declare function findIndependentFiles(graph: Map<string, ProcessingNode>): string[];
+/**
+ * Get processing levels (files at same level can be processed in parallel)
+ */
+export declare function getProcessingLevels(graph: Map<string, ProcessingNode>): string[][];
+/**
+ * Analyze graph for parallelization potential
+ */
+export declare function analyzeParallelizationPotential(graph: Map<string, ProcessingNode>): {
+    totalFiles: number
+    independentFiles: number
+    maxParallelism: number
+    levels: number
+    estimatedSpeedup: number
+  };
+/**
+ * Node in the processing dependency graph
+ */
+export declare interface ProcessingNode {
+  path: string
+  dependencies: Set<string>
+  dependents: Set<string>
+  state: 'pending' | 'processing' | 'completed' | 'failed'
+  result?: string
+  error?: Error
+  duration?: number
+}
+/**
+ * Configuration for parallel processing
+ */
+export declare interface ParallelProcessorConfig {
+  maxConcurrency?: number
+  rootDir?: string
+  config?: Partial<DtsGenerationConfig>
+  onProgress?: (completed: number, total: number, current: string) => void
+  onError?: (path: string, error: Error) => boolean
+}
+/**
+ * Result of parallel processing
+ */
+export declare interface ParallelProcessingResult {
+  success: Map<string, string>
+  failed: Map<string, Error>
+  totalTimeMs: number
+  maxConcurrent: number
+  processingOrder: string[]
+}

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;