@stacksjs/dtsx 0.9.9 → 0.9.11

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';

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,
+}