@dtsx/dtsx 0.0.0-stage → 0.11.38

package/dist/src/processor.js

@@ -0,0 +1,2 @@
+// @bun
+import"../chunk-zq93f8ca.js";import"../chunk-1j6092xz.js";import"../chunk-42j9cfte.js";import"../chunk-ag1b6d30.js";import"../chunk-zk3w5sqv.js";import{f}from"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import{n,Ot,ke,oe,et,o,tt,Ae,j}from"../chunk-8d3sdkv4.js";import{ee,h,te,ne,re,ie,On,In,se}from"../chunk-xa6rsd4b.js";import{Wn}from"../chunk-3t57mzvf.js";import{Ln,y}from"../chunk-vf3ybe5r.js";import"../chunk-4fygcxtb.js";import{l}from"../chunk-y1g6v96c.js";export{Wn as clearProcessorCaches,y as extractAllImportedItems,j as extractSatisfiesType,o as findMatchingBracket,f as formatComments,ke as inferArrayType,tt as inferFunctionType,n as inferNarrowType,Ot as inferNarrowTypeInUnion,et as inferObjectType,Ae as isGenericType,oe as parseArrayElements,Ln as parseImportStatement,re as processClassDeclaration,l as processDeclarations,ie as processEnumDeclaration,In as processExportDeclaration,ee as processFunctionDeclaration,On as processImportDeclaration,te as processInterfaceDeclaration,se as processModuleDeclaration,ne as processTypeDeclaration,h as processVariableDeclaration};

package/dist/src/profiling.d.ts

@@ -0,0 +1,114 @@
+import type { ProfilingConfig } from './types.js';
+/**
+ * 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 {
+  private config;
+  private memorySamples;
+  private cpuSamples;
+  private ioOperations;
+  private startTime;
+  private memoryInterval;
+  private cpuInterval;
+  private lastCpuUsage;
+  private isRunning;
+  constructor(config?: ProfilingConfig);
+  start(): void;
+  stop(): void;
+  private sampleMemory;
+  private sampleCpu;
+  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 {
+  private marks;
+  private durations;
+  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/src/profiling.js

@@ -0,0 +1,2 @@
+// @bun
+import{Ft,cr,zi,Hi,Lt,Ki}from"../chunk-88gwzbew.js";export{Ft as Profiler,Lt as Timer,Hi as createProfiledIo,cr as createProfiler,Ki as createTimer,zi as profileExecution};

package/dist/src/return-type-scope.d.ts

@@ -0,0 +1,3 @@
+import type { Declaration } from './types.js';
+/** Retain local declaration scope without exporting implementation names. */
+export declare function createReturnTypeScope(body: string, filename: string, freshName: () => string, retain: (declaration: Declaration) => void, generics?: string): { resolve: (type: string, position: number) => string, finish: (signature: string) => string };

package/dist/src/return-type-scope.js

@@ -0,0 +1,2 @@
+// @bun
+import{bi}from"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{bi as createReturnTypeScope};

package/dist/src/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/src/security.js

@@ -0,0 +1,2 @@
+// @bun
+import{L,C,Be,Fr,en,Lr,Nr,Br,ut,tn,ft,Wr,Us,zs,Hs,Ks}from"../chunk-h3n6256r.js";export{L as DEFAULT_SECURITY_CONFIG,C as SecurityError,Us as createSecureBatchProcessor,Wr as createSecureProcessor,Ks as createSecurityMiddleware,en as isBlockedPath,Hs as isSafePath,Nr as isSymlink,zs as sanitizeFilename,tn as validateFileBatch,ut as validateFilePath,Lr as validateFileSize,Be as validatePath,Fr as validatePaths,Br as validateSymlink,ft as withTimeout};

package/dist/src/source-cache.d.ts

@@ -0,0 +1,16 @@
+export declare function getSourceFile(filePath: string, sourceCode: string, contentHash?: number | bigint): CachedSourceFile;
+export declare function getSourceFileAsync(filePath: string, sourceCode: string, config?: AsyncParseConfig): Promise<CachedSourceFile>;
+export declare function batchParseSourceFiles(files: Array<{ filePath: string, sourceCode: string }>, config?: AsyncParseConfig & { concurrency?: number }): Promise<Map<string, CachedSourceFile>>;
+export declare function clearSourceFileCache(): void;
+export declare function getSourceFileCacheSize(): number;
+export declare function getPendingParseCount(): number;
+export declare function shouldUseAsyncParsing(sourceCode: string, config?: AsyncParseConfig): boolean;
+export declare interface CachedSourceFile {
+  fileName: string
+  text: string
+}
+export declare interface AsyncParseConfig {
+  asyncThreshold?: number
+  chunkSize?: number
+  yieldInterval?: number
+}

package/dist/src/source-cache.js

@@ -0,0 +1,2 @@
+// @bun
+import{At,Q,kn,Tn,An,Pn,Dn}from"../chunk-3fbt79hx.js";import"../chunk-pga5m4wm.js";import"../chunk-v6fwy63g.js";export{kn as batchParseSourceFiles,Tn as clearSourceFileCache,Pn as getPendingParseCount,At as getSourceFile,Q as getSourceFileAsync,An as getSourceFileCacheSize,Dn as shouldUseAsyncParsing};

package/dist/src/sourcemap.d.ts

@@ -0,0 +1,137 @@
+/**
+ * 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 {
+  private file;
+  private sourceRoot;
+  private sources;
+  private sourcesContent;
+  private names;
+  private mappings;
+  private sourceIndexMap;
+  private nameIndexMap;
+  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;
+  private encodeMappings;
+  toString(includeContent?: boolean): string;
+  toDataUrl(includeContent?: boolean): string;
+  toComment(includeContent?: boolean): string;
+}
+/**
+ * Source map consumer for reading source maps
+ */
+export declare class SourceMapConsumer {
+  private map;
+  private decodedMappings;
+  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;
+  private getMappings;
+  sourceContentFor(source: string): string | null;
+}

package/dist/src/sourcemap.js

@@ -0,0 +1,2 @@
+// @bun
+import{Xt,lt,Ds,Rs,Ms,Os,Ir,Is,Fs}from"../chunk-pjqzkgzk.js";export{lt as SourceMapConsumer,Xt as SourceMapGenerator,Ms as appendInlineSourceMap,Rs as appendSourceMapComment,Fs as buildDeclarationMappings,Ds as createSourceMap,Is as extractSourceMap,Ir as readSourceMap,Os as writeSourceMap};

package/dist/src/stx.d.ts

@@ -0,0 +1,20 @@
+/** Check whether a file path points at an STX component. */
+export declare function isStxFile(filePath: string): boolean;
+/** Collect all declaration-bearing STX blocks in document order. */
+export declare function parseStxScripts(source: string): StxScriptBlock[];
+/**
+ * Transform an STX component into a virtual TypeScript module.
+ *
+ * The output deliberately imports STX's own Vue-compatible `DefineComponent`
+ * type. This makes generated declarations consumable without a Vue dependency
+ * and exposes `$props` to STX's component utility types and call-site tooling.
+ */
+export declare function transformStxToTs(source: string): string;
+export declare interface StxScriptBlock {
+  content: string
+  kind: 'script' | 'ts'
+  attrs: string
+  context: 'server' | 'client' | 'universal'
+  lang: string
+  start: number
+}

package/dist/src/stx.js

@@ -0,0 +1,2 @@
+// @bun
+import{P,sa,D}from"../chunk-83qnrx0m.js";import"../chunk-sd8bywh9.js";export{P as isStxFile,sa as parseStxScripts,D as transformStxToTs};

package/dist/src/syntax-validator.d.ts

@@ -0,0 +1,7 @@
+export declare function validateTypeScriptSyntax(source: string): SyntaxIssue[];
+export declare interface SyntaxIssue {
+  line: number
+  column: number
+  message: string
+  code: string
+}

package/dist/src/syntax-validator.js

@@ -0,0 +1,2 @@
+// @bun
+import{me}from"../chunk-danfamyx.js";export{me as validateTypeScriptSyntax};

package/dist/src/tracking.d.ts

@@ -0,0 +1,95 @@
+import type { Declaration, TrackingConfig } from './types.js';
+/**
+ * Create a new tracker instance
+ */
+export declare function createTracker(config?: TrackingConfig): Tracker;
+/**
+ * Track declarations from a file
+ */
+export declare function trackDeclarations(declarations: Declaration[], file: string, tracker: Tracker): void;
+/**
+ * Analyze imports for a set of files
+ */
+export declare function analyzeImports(fileDeclarations: Map<string, Declaration[]>, config?: TrackingConfig): TrackingResults;
+/**
+ * Analyze types for a set of files
+ */
+export declare function analyzeTypes(fileDeclarations: Map<string, Declaration[]>, config?: TrackingConfig): TrackingResults;
+/**
+ * Type information tracked during processing
+ */
+export declare interface TrackedType {
+  name: string
+  kind: 'interface' | 'type' | 'class' | 'enum'
+  file: string
+  line?: number
+  usedBy: Set<string>
+  references: Set<string>
+  extendsFrom?: string[]
+  implementsFrom?: string[]
+}
+/**
+ * Import information tracked during processing
+ */
+export declare interface TrackedImport {
+  source: string
+  specifiers: string[]
+  isTypeOnly: boolean
+  file: string
+  usedSpecifiers: Set<string>
+  unusedSpecifiers: Set<string>
+}
+/**
+ * Type relationship information
+ */
+export declare interface TypeRelationship {
+  from: string
+  to: string
+  kind: 'extends' | 'implements' | 'references' | 'uses'
+  file: string
+}
+/**
+ * Tracking results from analysis
+ */
+export declare interface TrackingResults {
+  types: Map<string, TrackedType>
+  imports: Map<string, TrackedImport[]>
+  relationships: TypeRelationship[]
+  unusedTypes: string[]
+  unusedImports: TrackedImport[]
+  circularReferences: string[][]
+  statistics: TrackingStatistics
+}
+/**
+ * Tracking statistics
+ */
+export declare interface TrackingStatistics {
+  totalTypes: number
+  usedTypes: number
+  unusedTypes: number
+  totalImports: number
+  usedImports: number
+  unusedImports: number
+  totalRelationships: number
+  circularDependencies: number
+}
+/**
+ * Tracker class for collecting type and import information
+ */
+export declare class Tracker {
+  private config;
+  private types;
+  private imports;
+  private relationships;
+  private usageMap;
+  constructor(config?: TrackingConfig);
+  trackType(decl: Declaration, file: string): void;
+  trackTypeUsage(typeName: string, usedBy: string, file: string): void;
+  trackImport(source: string, specifiers: string[], isTypeOnly: boolean, file: string): void;
+  trackImportUsage(specifier: string, file: string): void;
+  trackTypeReference(typeName: string, file: string): void;
+  getResults(): TrackingResults;
+  private detectCircularReferences;
+  clear(): void;
+  formatResults(): string;
+}

package/dist/src/tracking.js

@@ -0,0 +1,2 @@
+// @bun
+import{Bt,Wt,jt,es,ts}from"../chunk-zgcdx773.js";export{Bt as Tracker,es as analyzeImports,ts as analyzeTypes,Wt as createTracker,jt as trackDeclarations};