@stacksjs/dtsx 0.9.9 → 0.9.10

package/dist/lsp.d.ts

@@ -0,0 +1,317 @@
+/**
+ * Start LSP server on stdio
+ */
+export declare function startLSPServer(): void;
+/**
+ * Create a simple file watcher that emits diagnostics
+ */
+export declare function createFileWatcher(server: DtsxLanguageServer, onDiagnostics: (uri: string, diagnostics: Diagnostic[]) => void): (filePath: string) => void;
+/**
+ * LSP message types
+ */
+export declare interface LSPMessage {
+  jsonrpc: '2.0'
+  id?: number | string
+  method?: string
+  params?: unknown
+  result?: unknown
+  error?: LSPError
+}
+export declare interface LSPError {
+  code: number
+  message: string
+  data?: unknown
+}
+/**
+ * LSP initialization params
+ */
+export declare interface InitializeParams {
+  processId: number | null
+  rootUri: string | null
+  capabilities: ClientCapabilities
+}
+export declare interface ClientCapabilities {
+  textDocument?: {
+    synchronization?: {
+      dynamicRegistration?: boolean
+      willSave?: boolean
+      didSave?: boolean
+    }
+    hover?: {
+      dynamicRegistration?: boolean
+      contentFormat?: string[]
+    }
+    completion?: {
+      dynamicRegistration?: boolean
+      completionItem?: {
+        snippetSupport?: boolean
+        documentationFormat?: string[]
+      }
+    }
+    definition?: {
+      dynamicRegistration?: boolean
+    }
+    diagnostic?: {
+      dynamicRegistration?: boolean
+    }
+  }
+  workspace?: {
+    workspaceFolders?: boolean
+    configuration?: boolean
+  }
+}
+export declare interface ServerCapabilities {
+  textDocumentSync?: number
+  hoverProvider?: boolean
+  completionProvider?: {
+    triggerCharacters?: string[]
+    resolveProvider?: boolean
+  }
+  definitionProvider?: boolean
+  referencesProvider?: boolean
+  renameProvider?: boolean | { prepareProvider?: boolean }
+  documentSymbolProvider?: boolean
+  workspaceSymbolProvider?: boolean
+  codeActionProvider?: boolean | { codeActionKinds?: string[] }
+  signatureHelpProvider?: {
+    triggerCharacters?: string[]
+    retriggerCharacters?: string[]
+  }
+  documentHighlightProvider?: boolean
+  documentFormattingProvider?: boolean
+  diagnosticProvider?: {
+    interFileDependencies: boolean
+    workspaceDiagnostics: boolean
+  }
+}
+/**
+ * Text document item
+ */
+export declare interface TextDocumentItem {
+  uri: string
+  languageId: string
+  version: number
+  text: string
+}
+/**
+ * Position in a text document
+ */
+export declare interface Position {
+  line: number
+  character: number
+}
+/**
+ * Range in a text document
+ */
+export declare interface Range {
+  start: Position
+  end: Position
+}
+/**
+ * Diagnostic message
+ */
+export declare interface Diagnostic {
+  range: Range
+  severity?: LspDiagnosticSeverity
+  code?: string | number
+  source?: string
+  message: string
+}
+/**
+ * Hover response
+ */
+export declare interface Hover {
+  contents: string | { kind: string, value: string }
+  range?: Range
+}
+/**
+ * Location for go-to-definition
+ */
+export declare interface Location {
+  uri: string
+  range: Range
+}
+/**
+ * Document symbol
+ */
+export declare interface DocumentSymbol {
+  name: string
+  detail?: string
+  kind: SymbolKind
+  range: Range
+  selectionRange: Range
+  children?: DocumentSymbol[]
+}
+/**
+ * Workspace symbol
+ */
+export declare interface WorkspaceSymbol {
+  name: string
+  kind: SymbolKind
+  location: Location
+  containerName?: string
+}
+/**
+ * Code action
+ */
+export declare interface CodeAction {
+  title: string
+  kind?: string
+  diagnostics?: Diagnostic[]
+  isPreferred?: boolean
+  edit?: WorkspaceEdit
+  command?: Command
+}
+/**
+ * Workspace edit
+ */
+export declare interface WorkspaceEdit {
+  changes?: Record<string, TextEdit[]>
+}
+/**
+ * Text edit
+ */
+export declare interface TextEdit {
+  range: Range
+  newText: string
+}
+/**
+ * Command
+ */
+export declare interface Command {
+  title: string
+  command: string
+  arguments?: unknown[]
+}
+/**
+ * Signature help
+ */
+export declare interface SignatureHelp {
+  signatures: SignatureInformation[]
+  activeSignature?: number
+  activeParameter?: number
+}
+/**
+ * Signature information
+ */
+export declare interface SignatureInformation {
+  label: string
+  documentation?: string | { kind: string, value: string }
+  parameters?: ParameterInformation[]
+}
+/**
+ * Parameter information
+ */
+export declare interface ParameterInformation {
+  label: string | [number, number]
+  documentation?: string | { kind: string, value: string }
+}
+/**
+ * Document highlight
+ */
+export declare interface DocumentHighlight {
+  range: Range
+  kind?: DocumentHighlightKind
+}
+/**
+ * LSP Server for dtsx
+ */
+export declare class DtsxLanguageServer {
+  initialize(params: InitializeParams): { capabilities: ServerCapabilities };
+  didOpen(params: { textDocument: TextDocumentItem }): void;
+  didChange(params: { textDocument: { uri: string, version: number }, contentChanges: Array<{ text: string }> }): void;
+  didClose(params: { textDocument: { uri: string } }): void;
+  getDiagnostics(uri: string): Diagnostic[];
+  hover(params: { textDocument: { uri: string }, position: Position }): Hover | null;
+  completion(params: { textDocument: { uri: string }, position: Position }): Array<{ label: string, kind: number, detail?: string, documentation?: string }>;
+  definition(params: { textDocument: { uri: string }, position: Position }): Location | null;
+  references(params: { textDocument: { uri: string }, position: Position, context: { includeDeclaration: boolean } }): Location[];
+  prepareRename(params: { textDocument: { uri: string }, position: Position }): { range: Range, placeholder: string } | null;
+  rename(params: { textDocument: { uri: string }, position: Position, newName: string }): WorkspaceEdit | null;
+  documentSymbols(params: { textDocument: { uri: string } }): DocumentSymbol[];
+  workspaceSymbols(params: { query: string }): WorkspaceSymbol[];
+  codeActions(params: { textDocument: { uri: string }, range: Range, context: { diagnostics: Diagnostic[] } }): CodeAction[];
+  signatureHelp(params: { textDocument: { uri: string }, position: Position }): SignatureHelp | null;
+  documentHighlight(params: { textDocument: { uri: string }, position: Position }): DocumentHighlight[];
+  formatting(params: { textDocument: { uri: string }, options: { tabSize: number, insertSpaces: boolean } }): Promise<TextEdit[]>;
+  generateDts(uri: string): string | null;
+  handleMessage(message: LSPMessage): LSPMessage | null;
+}
+/**
+ * LSP Diagnostic severity (matches LSP specification)
+ */
+export declare enum LspDiagnosticSeverity {
+  Error = 1,
+  Warning = 2,
+  Information = 3,
+  Hint = 4,
+}
+/**
+ * Symbol kind enum (LSP spec)
+ */
+export declare enum SymbolKind {
+  File = 1,
+  Module = 2,
+  Namespace = 3,
+  Package = 4,
+  Class = 5,
+  Method = 6,
+  Property = 7,
+  Field = 8,
+  Constructor = 9,
+  Enum = 10,
+  Interface = 11,
+  Function = 12,
+  Variable = 13,
+  Constant = 14,
+  String = 15,
+  Number = 16,
+  Boolean = 17,
+  Array = 18,
+  Object = 19,
+  Key = 20,
+  Null = 21,
+  EnumMember = 22,
+  Struct = 23,
+  Event = 24,
+  Operator = 25,
+  TypeParameter = 26,
+}
+/**
+ * Completion item kind enum
+ */
+export declare enum CompletionItemKind {
+  Text = 1,
+  Method = 2,
+  Function = 3,
+  Constructor = 4,
+  Field = 5,
+  Variable = 6,
+  Class = 7,
+  Interface = 8,
+  Module = 9,
+  Property = 10,
+  Unit = 11,
+  Value = 12,
+  Enum = 13,
+  Keyword = 14,
+  Snippet = 15,
+  Color = 16,
+  File = 17,
+  Reference = 18,
+  Folder = 19,
+  EnumMember = 20,
+  Constant = 21,
+  Struct = 22,
+  Event = 23,
+  Operator = 24,
+  TypeParameter = 25,
+}
+/**
+ * Document highlight kind
+ */
+export declare enum DocumentHighlightKind {
+  Text = 1,
+  Read = 2,
+  Write = 3,
+}

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