@stacksjs/dtsx 0.9.8 → 0.9.10

package/dist/extractor/index.d.ts

@@ -0,0 +1,70 @@
+import { extractClassDeclaration, extractEnumDeclaration, extractExportAssignment, extractExportDeclaration, extractFunctionDeclaration, extractImportDeclaration, extractInterfaceDeclaration, extractModuleDeclaration, extractTypeAliasDeclaration, extractVariableStatement, findReferencedTypes } from './declarations';
+import { getSourceFileAsync } from './cache';
+import { shouldIncludeNonExportedFunction, shouldIncludeNonExportedInterface } from './helpers';
+import type { AsyncParseConfig } from './cache';
+import type { Declaration } from '../types';
+export type { AsyncParseConfig } from './cache';
+/**
+ * Clear all extractor caches (source files and declarations)
+ */
+export declare function clearSourceFileCache(): void;
+/**
+ * Extract only public API declarations from TypeScript source code
+ * Uses fast string-based scanner (no TypeScript parser) for maximum performance.
+ * Delegates to extract.ts which owns the shared declaration cache with proper LRU eviction.
+ */
+export declare function extractDeclarations(sourceCode: string, filePath: string, keepComments?: boolean, isolatedDeclarations?: boolean): Declaration[];
+/**
+ * Async version of extractDeclarations that yields to the event loop for large files
+ * Use this when processing many files in parallel to prevent blocking
+ */
+export declare function extractDeclarationsAsync(sourceCode: string, filePath: string, keepComments?: boolean, config?: AsyncParseConfig): Promise<Declaration[]>;
+/**
+ * Batch extract declarations from multiple files asynchronously
+ * Useful for processing many files while keeping the event loop responsive
+ */
+export declare function batchExtractDeclarations(files: Array<{ filePath: string, sourceCode: string, keepComments?: boolean }>, config?: AsyncParseConfig & { concurrency?: number }): Promise<Map<string, Declaration[]>>;
+export {
+  buildClassBody,
+  buildClassDeclaration,
+  buildFunctionSignature,
+  buildInterfaceDeclaration,
+  buildModuleBody,
+  buildModuleDeclaration,
+  buildTypeDeclaration,
+  buildVariableDeclaration,
+  getInterfaceBody,
+} from './builders';
+export {
+  batchParseSourceFiles,
+  getPendingParseCount,
+  getSourceFileAsync,
+  getSourceFileCacheSize,
+  shouldUseAsyncParsing,
+} from './cache';
+export {
+  extractClassDeclaration,
+  extractEnumDeclaration,
+  extractExportAssignment,
+  extractExportDeclaration,
+  extractFunctionDeclaration,
+  extractImportDeclaration,
+  extractInterfaceDeclaration,
+  extractModuleDeclaration,
+  extractReferencedTypeDeclarations,
+  extractTypeAliasDeclaration,
+  extractVariableStatement,
+  findReferencedTypes,
+} from './declarations';
+export {
+  extractJSDocComments,
+  extractTripleSlashDirectives,
+  extractTypesFromModuleText,
+  getNodeText,
+  getParameterName,
+  hasAsyncModifier,
+  hasExportModifier,
+  isBuiltInType,
+  shouldIncludeNonExportedFunction,
+  shouldIncludeNonExportedInterface,
+} from './helpers';

package/dist/extractor/scanner.d.ts

@@ -0,0 +1,6 @@
+import type { Declaration } from '../types';
+/**
+ * Scan TypeScript source code and extract declarations without using the TypeScript parser.
+ * This is the fast path that replaces createSourceFile() + AST walk.
+ */
+export declare function scanDeclarations(_source: string, _filename: string, _keepComments?: boolean, _isolatedDeclarations?: boolean): Declaration[];

package/dist/extractor.d.ts

@@ -1,6 +1,5 @@
-import type { Declaration } from './types';
 /**
- * Extract only public API declarations from TypeScript source code
- * This focuses on what should be in .d.ts files, not implementation details
+ * Extractor module - re-exports from modular structure
+ * @deprecated Import from './extractor/index' directly for better tree-shaking
  */
-export declare function extractDeclarations(sourceCode: string, filePath: string, keepComments?: boolean): Declaration[];
+export * from './extractor/index';

package/dist/formats.d.ts

@@ -0,0 +1,50 @@
+import type { Declaration } from './types';
+/**
+ * Convert declarations to JSON Schema
+ */
+export declare function toJsonSchema(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to Zod schema
+ */
+export declare function toZod(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to Valibot schema
+ */
+export declare function toValibot(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to io-ts codec
+ */
+export declare function toIoTs(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to Yup schema
+ */
+export declare function toYup(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to ArkType schema
+ */
+export declare function toArkType(declarations: Declaration[], options?: Partial<FormatOptions>): string;
+/**
+ * Convert declarations to the specified format
+ */
+export declare function convertToFormat(declarations: Declaration[], options: FormatOptions): string;
+/**
+ * Get file extension for output format
+ */
+export declare function getFormatExtension(format: OutputFormat): string;
+/**
+ * Options for format conversion
+ */
+export declare interface FormatOptions {
+  format: OutputFormat
+  includeSchema?: boolean
+  jsonSchemaDraft?: '2020-12' | '2019-09' | 'draft-07'
+  allOptional?: boolean
+  includeDescriptions?: boolean
+  indent?: number
+  exportName?: string
+  useInfer?: boolean
+}
+/**
+ * Supported output formats
+ */
+export type OutputFormat = 'dts' | 'json-schema' | 'zod' | 'io-ts' | 'yup' | 'valibot' | 'arktype';

package/dist/formatter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Format declaration file content
+ */
+export declare function formatDts(content: string, config?: FormatterConfig, filePath?: string): Promise<FormatResult>;
+/**
+ * Format multiple files
+ */
+export declare function formatFiles(files: Map<string, string>, config?: FormatterConfig): Promise<Map<string, FormatResult>>;
+/**
+ * Create a formatter with preset configuration
+ */
+export declare function createFormatter(config?: FormatterConfig): {
+  format: (content: string, filePath?: string) => Promise<FormatResult>
+  formatMany: (files: Map<string, string>) => Promise<Map<string, FormatResult>>
+};
+/**
+ * Quick format with sensible defaults
+ */
+export declare function quickFormat(content: string): Promise<string>;
+/**
+ * Formatter configuration options
+ */
+export declare interface FormatterConfig {
+  usePrettier?: boolean
+  prettierConfigPath?: string
+  prettierOptions?: PrettierOptions
+  builtIn?: BuiltInFormatterOptions
+}
+/**
+ * Prettier-compatible options
+ */
+export declare interface PrettierOptions {
+  printWidth?: number
+  tabWidth?: number
+  useTabs?: boolean
+  semi?: boolean
+  singleQuote?: boolean
+  trailingComma?: 'none' | 'es5' | 'all'
+  bracketSpacing?: boolean
+  parser?: string
+}
+/**
+ * Built-in formatter options (when Prettier is not available)
+ */
+export declare interface BuiltInFormatterOptions {
+  indentSize?: number
+  useTabs?: boolean
+  maxLineWidth?: number
+  trailingNewline?: boolean
+  normalizeWhitespace?: boolean
+  sortImports?: boolean
+  groupImports?: boolean
+}
+/**
+ * Result of formatting operation
+ */
+export declare interface FormatResult {
+  content: string
+  usedPrettier: boolean
+  warnings?: string[]
+}

package/dist/generator.d.ts

@@ -1,9 +1,18 @@
-import type { DtsGenerationConfig } from './types';
+import type { DtsGenerationConfig, GenerationStats } from './types';
 /**
  * Generate DTS files from TypeScript source files
  */
-export declare function generate(options?: Partial<DtsGenerationConfig>): Promise<void>;
+export declare function generate(options?: Partial<DtsGenerationConfig>): Promise<GenerationStats>;
 /**
  * Process a single TypeScript file and generate its DTS
  */
-export declare function processFile(filePath: string, config: DtsGenerationConfig): Promise<string>;
+export declare function processFile(filePath: string, config: DtsGenerationConfig): Promise<string>;
+/**
+ * Watch mode - regenerate DTS files on source changes
+ */
+export declare function watch(options?: Partial<DtsGenerationConfig>): Promise<void>;
+/**
+ * Process TypeScript source code from a string (for stdin support)
+ * Re-exported from process-source.ts for backward compatibility
+ */
+export { processSource } from './process-source';

package/dist/import-sorter.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Parse an import statement
+ */
+export declare function parseImport(statement: string): ParsedImport | null;
+/**
+ * Detect the group for an import source
+ */
+export declare function detectGroup(source: string, isTypeOnly?: boolean): ImportGroup;
+/**
+ * Sort imports according to configuration
+ */
+export declare function sortImports(imports: string[], config?: ImportSortConfig): string[];
+/**
+ * Sort imports in a file content
+ */
+export declare function sortImportsInContent(content: string, config?: ImportSortConfig): string;
+/**
+ * Create a configured import sorter
+ */
+export declare function createImportSorter(config?: ImportSortConfig): {
+  sort: (imports: string[]) => string[]
+  sortContent: (content: string) => string
+  parse: typeof parseImport
+  detectGroup: typeof detectGroup
+};
+/**
+ * Default import group order
+ */
+export declare const DEFAULT_GROUP_ORDER: ImportGroup[];
+/**
+ * Preset configurations
+ */
+export declare const presets: {
+  /**
+   * Default preset - groups by type, alphabetizes
+   */
+  default: unknown;
+  /**
+   * Node.js style - node: first, then external, then relative
+   */
+  node: unknown;
+  /**
+   * Bun style - bun first
+   */
+  bun: unknown;
+  /**
+   * Type imports separated
+   */
+  typeSeparated: unknown;
+  /**
+   * No grouping, just alphabetize
+   */
+  alphabetical: unknown;
+  /**
+   * Keep original order
+   */
+  none: unknown
+};
+/**
+ * Import sorting module for organizing imports in declaration files
+ */
+/**
+ * Import sorting configuration
+ */
+export declare interface ImportSortConfig {
+  order?: string[]
+  groupByType?: boolean
+  groups?: ImportGroup[]
+  alphabetize?: boolean
+  caseInsensitive?: boolean
+  typeImportsLast?: boolean
+  separateTypeImports?: boolean
+  customGroups?: Record<string, string[]>
+}
+/**
+ * Parsed import information
+ */
+export declare interface ParsedImport {
+  statement: string
+  source: string
+  isTypeOnly: boolean
+  group: ImportGroup
+  specifiers: string[]
+  defaultImport?: string
+  namespaceImport?: string
+  lineNumber?: number
+}
+/**
+ * Import group types
+ */
+export type ImportGroup = | 'builtin'
+  | 'external'
+  | 'internal'
+  | 'parent'
+  | 'sibling'
+  | 'index'
+  | 'type'
+  | 'unknown'
+  | string // Custom group name;

package/dist/incremental.d.ts

@@ -0,0 +1,84 @@
+import type { Declaration, DtsGenerationConfig } from './types';
+/**
+ * Create an incremental build wrapper
+ */
+export declare function createIncrementalBuilder(cache: IncrementalCache, configHash: string): void;
+/**
+ * Prune old cache entries
+ */
+export declare function pruneCache(cache: IncrementalCache, _maxAge?: number, // 7 days default: unknown): Promise<number>;
+/**
+ * Format incremental build result
+ */
+export declare function formatIncrementalResult(result: IncrementalBuildResult): string;
+/**
+ * Extract dependencies from source content
+ */
+export declare function extractDependencies(content: string, basePath: string): string[];
+/**
+ * Incremental build configuration
+ */
+export declare interface IncrementalConfig {
+  enabled?: boolean
+  cacheDir?: string
+  format?: 'json' | 'binary'
+  maxAge?: number
+  force?: boolean
+  validateCache?: boolean
+}
+/**
+ * Cached file entry for incremental builds
+ */
+export declare interface IncrementalCacheEntry {
+  filePath: string
+  hash: string
+  mtime: number
+  declarations: Declaration[]
+  dtsContent: string
+  dependencies: string[]
+  cachedAt: number
+  configHash: string
+}
+/**
+ * Cache manifest for incremental builds
+ */
+export declare interface IncrementalCacheManifest {
+  version: string
+  entries: Record<string, IncrementalCacheEntry>
+  createdAt: number
+  updatedAt: number
+}
+/**
+ * Incremental build result
+ */
+export declare interface IncrementalBuildResult {
+  rebuilt: string[]
+  cached: string[]
+  skipped: string[]
+  stats: CacheStats
+}
+/**
+ * Cache statistics
+ */
+export declare interface CacheStats {
+  totalEntries: number
+  hits: number
+  misses: number
+  hitRatio: number
+  sizeBytes: number
+  timeSavedMs: number
+}
+/**
+ * Incremental build cache manager
+ */
+export declare class IncrementalCache {
+  constructor(config?: IncrementalConfig);
+  init(): Promise<void>;
+  save(): Promise<void>;
+  get(filePath: string, configHash: string): Promise<IncrementalCacheEntry | null>;
+  set(filePath: string, content: string, declarations: Declaration[], dtsContent: string, dependencies: string[], configHash: string): Promise<void>;
+  invalidate(filePath: string): void;
+  clear(): Promise<void>;
+  getStats(): CacheStats;
+  static hashConfig(config: DtsGenerationConfig): string;
+}

package/dist/index.d.ts

@@ -1,7 +1,60 @@
+/**
+ * @stacksjs/dtsx - A modern, fast .d.ts generation tool
+ *
+ * This module exports the full API. For minimal bundle size when only
+ * using the core generator, import directly from './generator'.
+ *
+ * Core exports (most commonly used):
+ * - generate, watch, processFile, processSource from './generator'
+ * - extractDeclarations, extractDeclarationsAsync from './extractor'
+ * - processDeclarations from './processor'
+ * - DtsGenerationConfig, Declaration types from './types'
+ *
+ * Optional/Advanced exports are available but may increase bundle size:
+ * - LSP support: './lsp'
+ * - Type checking: './checker'
+ * - Circular dependency detection: './circular'
+ * - Custom transformers: './transformers'
+ * - Worker pool: './worker'
+ */
+// Common utilities
+export * from './branded-types';
+export * from './bundler';
+export * from './cache';
+export * from './checker';
+// Advanced features - larger bundle impact
+export * from './circular';
+export * from './compat';
 export * from './config';
+export * from './diff';
+export * from './docs';
+export * from './errors';
 export * from './extractor';
+export * from './formats';
+export * from './formatter';
+// Core API - essential for dts generation
 export * from './generator';
+export * from './import-sorter';
+export * from './incremental';
+export * from './logger';
+export * from './lsp';
+export * from './memory';
+export * from './merger';
+export * from './optimizer';
+export * from './output-normalizer';
+export * from './parallel-processor';
 export * from './parser';
+export * from './plugins';
 export * from './processor';
+export * from './profiling';
+export * from './security';
+export * from './sourcemap';
+export * from './tracking';
+export * from './transformers';
+export * from './tree-shaker';
+export * from './type-mappings';
 export * from './types';
-export * from './utils';
+export * from './utils';
+export * from './watcher';
+export * from './worker';
+export * from './workspace';

package/dist/logger.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Create a logger instance
+ */
+export declare function createLogger(options?: LoggerOptions): Logger;
+/**
+ * Create a scoped logger for a specific module
+ * @example
+ * const log = scopedLogger('extractor')
+ * log.debug('Parsing file...') // [dtsx:extractor] Parsing file...
+ */
+export declare function scopedLogger(scope: string): Logger;
+/**
+ * Set the global log level
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * Get the current log level
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * Set the log prefix
+ */
+export declare function setLogPrefix(prefix: string): void;
+/**
+ * Enable or disable timestamps
+ */
+export declare function setTimestamps(enabled: boolean): void;
+/**
+ * Default logger instance
+ */
+export declare const logger: Logger;
+/**
+ * No-op logger for silent mode or testing
+ */
+export declare const nullLogger: Logger;
+export declare interface LoggerOptions {
+  level?: LogLevel
+  prefix?: string
+  timestamps?: boolean
+  output?: (level: LogLevel, ...args: unknown[]) => void
+}
+export declare interface Logger {
+  debug: (...args: unknown[]) => void
+  info: (...args: unknown[]) => void
+  warn: (...args: unknown[]) => void
+  error: (...args: unknown[]) => void
+  setLevel: (level: LogLevel) => void
+  getLevel: () => LogLevel
+  child: (scope: string) => Logger
+  time: (label: string) => () => void
+  progress: (message: string) => void
+}
+/**
+ * Logger abstraction for dtsx
+ * Provides configurable logging with verbosity levels and scoped loggers
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';