@stacksjs/dtsx 0.9.8 → 0.9.10

package/dist/processor/type-inference.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Enable clean default collection for the next type inference pass.
+ * Must be called before inferNarrowType when you need a @defaultValue.
+ */
+export declare function enableCleanDefaultCollection(): void;
+/**
+ * Consume the computed clean default (also disables collection).
+ * Returns null if no clean default was computed.
+ */
+export declare function consumeCleanDefault(): string | null;
+/**
+ * Infer and narrow types from values
+ * @param inUnion - When true, widens number/boolean literals to their base types (used in array union contexts)
+ * @param _depth - Internal recursion depth counter (do not set manually)
+ */
+export declare function inferNarrowType(value: unknown, isConst?: boolean, inUnion?: boolean, _depth?: number): string;
+/**
+ * Infer and narrow types from values in union context (for arrays)
+ * Widens number/boolean literals to base types unless const
+ */
+export declare function inferNarrowTypeInUnion(value: unknown, isConst?: boolean, _depth?: number): string;
+/**
+ * Infer array type from array literal
+ */
+export declare function inferArrayType(value: string, isConst: boolean, _depth?: number): string;
+/**
+ * Parse array elements handling nested structures
+ */
+export declare function parseArrayElements(content: string): string[];
+/**
+ * Infer object type from object literal
+ */
+export declare function inferObjectType(value: string, isConst: boolean, _depth?: number): string;
+/**
+ * Clean parameter defaults from function parameters
+ */
+export declare function cleanParameterDefaults(params: string): string;
+/**
+ * Find matching bracket for nested structures
+ */
+export declare function findMatchingBracket(str: string, start: number, openChar: string, closeChar: string): number;
+/**
+ * Infer function type from function expression
+ */
+export declare function inferFunctionType(value: string, inUnion?: boolean, _depth?: number, isConst?: boolean): string;
+/**
+ * Check if a type annotation is a generic/broad type that should be replaced with narrow inference
+ */
+export declare function isGenericType(typeAnnotation: string): boolean;
+/**
+ * Extract type from 'satisfies' operator
+ * e.g., "{ port: 3000 } satisfies { port: number }" returns "{ port: number }"
+ */
+export declare function extractSatisfiesType(value: string): string | null;
+/**
+ * Infer mapped type from type expression
+ * Handles patterns like { [K in keyof T]: V }
+ */
+export declare function inferMappedType(typeStr: string): string | null;
+/**
+ * Infer conditional type from type expression
+ * Handles patterns like T extends U ? X : Y
+ */
+export declare function inferConditionalType(typeStr: string): string | null;
+/**
+ * Infer template literal type from type expression
+ * Handles patterns like `${string}-${number}`
+ */
+export declare function inferTemplateLiteralTypeAdvanced(typeStr: string): string | null;
+/**
+ * Infer infer keyword usage in conditional types
+ * Handles patterns like T extends (infer U)[] ? U : never
+ */
+export declare function extractInferTypes(typeStr: string): string[];
+/**
+ * Check if a type uses advanced TypeScript features
+ */
+export declare function isComplexType(_typeStr: string): boolean;
+/**
+ * Simplify complex type for declaration output
+ * Returns simplified version if too complex
+ */
+export declare function simplifyComplexType(typeStr: string, maxDepth?: number): string;
+/**
+ * Parse utility type and extract its parameters
+ * Handles Partial<T>, Required<T>, Pick<T, K>, Omit<T, K>, etc.
+ */
+export declare function parseUtilityType(typeStr: string): { name: string, params: string[] } | null;
+/**
+ * Parse type parameters from a comma-separated string
+ * Handles nested types properly
+ */
+export declare function parseTypeParameters(paramsStr: string): string[];
+/**
+ * Infer keyof type
+ */
+export declare function inferKeyofType(typeStr: string): string | null;
+/**
+ * Infer typeof type
+ */
+export declare function inferTypeofType(typeStr: string): string | null;
+/**
+ * Check if type is an indexed access type
+ * e.g., T[K], Person['name']
+ */
+export declare function isIndexedAccessType(typeStr: string): boolean;

package/dist/processor.d.ts

@@ -1,45 +1,5 @@
-import type { Declaration, ProcessingContext } from './types';
 /**
- * Process declarations and convert them to narrow DTS format
+ * Processor module - re-exports from modular structure
+ * @deprecated Import from './processor/index' directly for better tree-shaking
  */
-export declare function processDeclarations(declarations: Declaration[], context: ProcessingContext, keepComments?: boolean): string;
-/**
- * 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): string;
-/**
- * Process module/namespace declaration to DTS format
- */
-export declare function processModuleDeclaration(decl: Declaration, keepComments?: boolean): string;
-/**
- * Infer and narrow types from values
- */
-export declare function inferNarrowType(value: any, isConst?: boolean): string;
+export * from './processor/index';

package/dist/profiling.d.ts

@@ -0,0 +1,101 @@
+import type { ProfilingConfig } from './types';
+/**
+ * Create a new profiler instance
+ */
+export declare function createProfiler(config?: ProfilingConfig): Profiler;
+/**
+ * Profile a function execution
+ */
+export declare function profileExecution<T>(fn: () => T | Promise<T>, config?: ProfilingConfig): Promise<{ result: T, profile: ProfilingResults }>;
+/**
+ * Create a profiled I/O wrapper
+ */
+export declare function createProfiledIo(profiler: Profiler): {
+  read: <T>(path: string, fn: () => Promise<T>) => Promise<T>
+  write: (path: string, fn: () => Promise<void>, size: number) => Promise<void>
+};
+/**
+ * Create a simple timer
+ */
+export declare function createTimer(): Timer;
+/**
+ * Memory profiling data snapshot
+ */
+export declare interface MemoryProfileSnapshot {
+  timestamp: number
+  heapUsed: number
+  heapTotal: number
+  external: number
+  arrayBuffers: number
+  rss: number
+}
+/**
+ * CPU profiling data
+ */
+export declare interface CpuProfile {
+  timestamp: number
+  user: number
+  system: number
+  total: number
+}
+/**
+ * I/O operation record
+ */
+export declare interface IoOperation {
+  timestamp: number
+  operation: 'read' | 'write'
+  path: string
+  size: number
+  durationMs: number
+}
+/**
+ * Profiling results
+ */
+export declare interface ProfilingResults {
+  startTime: number
+  endTime: number
+  durationMs: number
+  memory: {
+    samples: MemoryProfileSnapshot[]
+    peak: MemoryProfileSnapshot
+    average: MemoryProfileSnapshot
+    warnings: string[]
+  }
+  cpu: {
+    samples: CpuProfile[]
+    totalUser: number
+    totalSystem: number
+  }
+  io: {
+    operations: IoOperation[]
+    totalReads: number
+    totalWrites: number
+    totalReadBytes: number
+    totalWriteBytes: number
+    totalReadMs: number
+    totalWriteMs: number
+  }
+}
+/**
+ * Profiler class for collecting performance data
+ */
+export declare class Profiler {
+  constructor(config?: ProfilingConfig);
+  start(): void;
+  stop(): void;
+  recordIo(operation: 'read' | 'write', path: string, size: number, durationMs: number): void;
+  getResults(): ProfilingResults;
+  formatResults(): string;
+  writeResults(): Promise<void>;
+}
+/**
+ * Simple timer for manual profiling
+ */
+export declare class Timer {
+  mark(name: string): void;
+  measure(name: string, fromMark: string): number;
+  getDurations(name: string): number[];
+  getAverage(name: string): number;
+  getSummary(): Map<string, { count: number, total: number, average: number, min: number, max: number }>;
+  clear(): void;
+}

package/dist/security.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Validate that a path is safe and within the allowed root directory
+ */
+export declare function validatePath(filePath: string, config?: SecurityConfig): string;
+/**
+ * Validate multiple paths
+ */
+export declare function validatePaths(filePaths: string[], config?: SecurityConfig): string[];
+/**
+ * Check if a path matches any blocked pattern
+ */
+export declare function isBlockedPath(filePath: string, config?: SecurityConfig): boolean;
+/**
+ * Validate file size
+ */
+export declare function validateFileSize(filePath: string, config?: SecurityConfig): Promise<number>;
+/**
+ * Check if path is a symbolic link
+ */
+export declare function isSymlink(filePath: string): Promise<boolean>;
+/**
+ * Validate that a path is not a symlink (or follow it if allowed)
+ */
+export declare function validateSymlink(filePath: string, config?: SecurityConfig): Promise<string>;
+/**
+ * Full path validation including all security checks
+ */
+export declare function validateFilePath(filePath: string, config?: SecurityConfig): Promise<{ path: string, size: number }>;
+/**
+ * Validate a batch of files with total size limit
+ */
+export declare function validateFileBatch(filePaths: string[], config?: SecurityConfig): Promise<{ paths: string[], totalSize: number }>;
+/**
+ * Create a timeout wrapper for async operations
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, operation?: string): Promise<T>;
+/**
+ * Create a secure file processor with all protections
+ */
+export declare function createSecureProcessor<T>(processor: (filePath: string) => Promise<T>, config?: SecurityConfig): (filePath: string) => Promise<T>;
+/**
+ * Create a secure batch processor
+ */
+export declare function createSecureBatchProcessor<T>(processor: (filePaths: string[]) => Promise<T>, config?: SecurityConfig): (filePaths: string[]) => Promise<T>;
+/**
+ * Sanitize a filename to prevent path traversal
+ */
+export declare function sanitizeFilename(filename: string): string;
+/**
+ * Check if a path is safe (doesn't contain traversal sequences)
+ */
+export declare function isSafePath(path: string): boolean;
+/**
+ * Create security middleware for the generator
+ */
+export declare function createSecurityMiddleware(config?: SecurityConfig): {
+  validatePath: (filePath: string) => string
+  validatePaths: (filePaths: string[]) => string[]
+  validateFile: (filePath: string) => Promise<{ path: string, size: number }>
+  validateBatch: (filePaths: string[]) => Promise<{ paths: string[], totalSize: number }>
+  withTimeout: <T>(promise: Promise<T>, operation?: string) => Promise<T>
+  secureProcessor: <T>(processor: (filePath: string) => Promise<T>) => (filePath: string) => Promise<T>
+  isBlocked: (filePath: string) => boolean
+  getConfig: () => Required<SecurityConfig>
+};
+/**
+ * Default security configuration
+ */
+export declare const DEFAULT_SECURITY_CONFIG: Required<SecurityConfig>;
+/**
+ * Security configuration options
+ */
+export declare interface SecurityConfig {
+  rootDir?: string
+  maxFileSize?: number
+  maxTotalSize?: number
+  timeout?: number
+  followSymlinks?: boolean
+  maxFiles?: number
+  blockedPatterns?: string[]
+}
+/**
+ * Security error codes
+ */
+export type SecurityErrorCode = | 'PATH_TRAVERSAL'
+  | 'FILE_TOO_LARGE'
+  | 'TOTAL_SIZE_EXCEEDED'
+  | 'TIMEOUT'
+  | 'SYMLINK_NOT_ALLOWED'
+  | 'MAX_FILES_EXCEEDED'
+  | 'BLOCKED_PATTERN'
+  | 'INVALID_PATH';
+/**
+ * Security validation error
+ */
+export declare class SecurityError extends Error {
+  public readonly code: SecurityErrorCode;
+  public readonly path?: string;
+  constructor(message: string, code: SecurityErrorCode, path?: string);
+}

package/dist/sourcemap.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Create source map for generated .d.ts content
+ */
+export declare function createSourceMap(options: {
+  generatedFile: string
+  sourceFile: string
+  sourceContent?: string
+  sourceRoot?: string
+  mappings: Array<{
+    generatedLine: number
+    generatedColumn: number
+    originalLine: number
+    originalColumn: number
+    name?: string
+  }>
+}): SourceMapGenerator;
+/**
+ * Append source map comment to content
+ */
+export declare function appendSourceMapComment(content: string, mapFileName: string): string;
+/**
+ * Append inline source map to content
+ */
+export declare function appendInlineSourceMap(content: string, generator: SourceMapGenerator, includeContent?: boolean): string;
+/**
+ * Write source map file
+ */
+export declare function writeSourceMap(mapPath: string, generator: SourceMapGenerator, includeContent?: boolean): Promise<void>;
+/**
+ * Read and parse source map file
+ */
+export declare function readSourceMap(mapPath: string): Promise<SourceMapConsumer>;
+/**
+ * Extract source map from content (inline or reference)
+ */
+export declare function extractSourceMap(content: string, filePath: string): Promise<SourceMapConsumer | null>;
+/**
+ * Build source mappings from declaration info
+ */
+export declare function buildDeclarationMappings(_generatedContent: string, _declarationInfos: Array<{
+    name: string
+    generatedStart: number
+    originalLine: number
+    originalColumn: number
+  }>): Array<{
+    generatedLine: number
+    generatedColumn: number
+    originalLine: number
+    originalColumn: number
+    name: string
+  }>;
+/**
+ * Source map configuration
+ */
+export declare interface SourceMapConfig {
+  sourceMap?: boolean
+  inlineSourceMap?: boolean
+  inlineSources?: boolean
+  sourceRoot?: string
+  mapExtension?: string
+}
+/**
+ * Source map v3 format
+ */
+export declare interface SourceMapV3 {
+  version: 3
+  file: string
+  sourceRoot?: string
+  sources: string[]
+  sourcesContent?: (string | null)[]
+  names: string[]
+  mappings: string
+}
+/**
+ * Source position
+ */
+export declare interface SourcePosition {
+  line: number
+  column: number
+}
+/**
+ * Mapping entry
+ */
+export declare interface Mapping {
+  generated: SourcePosition
+  original: SourcePosition
+  sourceIndex: number
+  nameIndex?: number
+}
+/**
+ * Source map generator
+ */
+export declare class SourceMapGenerator {
+  constructor(options: { file: string, sourceRoot?: string });
+  addSource(source: string, content?: string): number;
+  addName(name: string): number;
+  addMapping(mapping: {
+    generated: SourcePosition
+    original: SourcePosition
+    source: string
+    name?: string
+  }): void;
+  generate(includeContent?: boolean): SourceMapV3;
+  toString(includeContent?: boolean): string;
+  toDataUrl(includeContent?: boolean): string;
+  toComment(includeContent?: boolean): string;
+}
+/**
+ * Source map consumer for reading source maps
+ */
+export declare class SourceMapConsumer {
+  constructor(map: SourceMapV3 | string);
+  originalPositionFor(generated: SourcePosition): {
+    source: string | null
+    line: number | null
+    column: number | null
+    name: string | null
+  };
+  generatedPositionFor(original: {
+    source: string
+    line: number
+    column: number
+  }): SourcePosition | null;
+  sourceContentFor(source: string): string | null;
+}