@dtsx/dtsx 0.0.0-stage → 0.11.38

package/dist/src/transformers.d.ts

@@ -0,0 +1,188 @@
+import type { Declaration, DeclarationKind, ParameterDeclaration } from './types.js';
+import type { Plugin } from './plugins.js';
+/**
+ * Create a new declaration with defaults
+ */
+export declare function createDeclaration(kind: DeclarationKind, name: string, text: string, options?: Partial<Omit<Declaration, 'kind' | 'name' | 'text'>>): Declaration;
+/**
+ * Clone a declaration (deep copy).
+ * Uses the structured-clone algorithm where available — typically 3-5× faster
+ * than the JSON round-trip and correctly preserves nested arrays / Sets.
+ * Falls back to JSON for environments without structuredClone.
+ */
+export declare function cloneDeclaration(decl: Declaration): Declaration;
+/**
+ * Walk declarations with a visitor
+ */
+export declare function walkDeclarations(declarations: Declaration[], visitor: DeclarationVisitor, parent?: Declaration | null): void;
+/**
+ * Find declarations matching a predicate
+ */
+export declare function findDeclarations(declarations: Declaration[], predicate: (decl: Declaration) => boolean): Declaration[];
+/**
+ * Map declarations with a transformer
+ */
+export declare function mapDeclarations(declarations: Declaration[], transformer: Transformer, context: Omit<TransformerContext, 'index' | 'total' | 'allDeclarations'>): Promise<Declaration[]>;
+/**
+ * Compose multiple transformers into one
+ */
+export declare function composeTransformers(...transformers: Transformer[]): Transformer;
+/**
+ * Create a transformer that only applies to specific declaration kinds
+ */
+export declare function filterByKind(kinds: DeclarationKind | DeclarationKind[], transformer: Transformer): Transformer;
+/**
+ * Create a transformer that only applies when a predicate is true
+ */
+export declare function filterByPredicate(predicate: (decl: Declaration) => boolean, transformer: Transformer): Transformer;
+/**
+ * Create a transformer plugin from transformers
+ */
+export declare function createTransformerPlugin(options: {
+  name: string
+  version?: string
+  description?: string
+   
+  beforeParse?: TextTransformer
+   
+  transform?: Transformer
+   
+  afterGenerate?: TextTransformer
+}): Plugin;
+/**
+ * Rename declarations matching a pattern
+ */
+export declare function createRenameTransformer(pattern: string | RegExp, replacement: string | ((_match: string, _decl: Declaration) => string)): Transformer;
+/**
+ * Add a prefix to declaration names
+ */
+export declare function createPrefixTransformer(prefix: string, filter?: (decl: Declaration) => boolean): Transformer;
+/**
+ * Add a suffix to declaration names
+ */
+export declare function createSuffixTransformer(suffix: string, filter?: (decl: Declaration) => boolean): Transformer;
+/**
+ * Remove declarations by name pattern
+ */
+export declare function createRemoveTransformer(pattern: string | RegExp | ((_decl: Declaration) => boolean)): Transformer;
+/**
+ * Add JSDoc comments to declarations
+ */
+export declare function createJSDocTransformer(getJSDoc: (decl: Declaration) => string | string[] | null | undefined): Transformer;
+/**
+ * Modify type annotations
+ */
+export declare function createTypeTransformer(transformer: (type: string, decl: Declaration) => string | null | undefined): Transformer;
+/**
+ * Modify return types of functions
+ */
+export declare function createReturnTypeTransformer(transformer: (returnType: string, decl: Declaration) => string | null | undefined): Transformer;
+/**
+ * Transform function parameters
+ */
+export declare function createParameterTransformer(transformer: (
+    params: ParameterDeclaration[],
+    decl: Declaration,
+  ) => ParameterDeclaration[] | null | undefined): Transformer;
+/**
+ * Add modifiers (export, declare, etc.)
+ */
+export declare function createModifierTransformer(modifier: string, filter?: (decl: Declaration) => boolean): Transformer;
+/**
+ * Strip specific JSDoc tags
+ */
+export declare function createStripTagsTransformer(tags: string[]): Transformer;
+/**
+ * Wrap types in a utility type
+ */
+export declare function createWrapTypeTransformer(utilityType: string, filter?: (decl: Declaration) => boolean): Transformer;
+/**
+ * Plugin that prefixes all exported types with a namespace
+ */
+export declare function createNamespacePrefixPlugin(namespace: string): Plugin;
+/**
+ * Make all declarations readonly (for interfaces/types)
+ */
+export declare const readonlyTransformer: Transformer;
+/**
+ * Make all optional properties required
+ */
+export declare const requiredTransformer: Transformer;
+/**
+ * Make all required properties optional
+ */
+export declare const optionalTransformer: Transformer;
+/**
+ * Plugin that makes all interface properties readonly
+ */
+export declare const readonlyPlugin: Plugin;
+/**
+ * Plugin that strips @internal, @private, and @hidden tags
+ */
+export declare const stripPrivatePlugin: Plugin;
+/**
+ * Plugin that adds 'declare' keyword to all declarations
+ */
+export declare const declarePlugin: Plugin;
+/**
+ * Context available to transformers
+ */
+export declare interface TransformerContext {
+  filePath: string
+  sourceCode: string
+  index: number
+  total: number
+  allDeclarations: readonly Declaration[]
+  createDeclaration: typeof createDeclaration
+  cloneDeclaration: typeof cloneDeclaration
+  modifyText: (decl: Declaration, text: string) => Declaration
+  addModifier: (decl: Declaration, modifier: string) => Declaration
+  removeModifier: (decl: Declaration, modifier: string) => Declaration
+}
+/**
+ * Context for text transformers
+ */
+export declare interface TextTransformerContext {
+  filePath: string
+  phase: 'before' | 'after'
+}
+/**
+ * Visitor pattern for walking declaration trees
+ */
+export declare interface DeclarationVisitor {
+  enter?: (decl: Declaration, parent: Declaration | null) => void
+  leave?: (decl: Declaration, parent: Declaration | null) => void
+  function?: (_decl: Declaration, _parent: Declaration | null) => void
+  variable?: (decl: Declaration, parent: Declaration | null) => void
+  interface?: (decl: Declaration, parent: Declaration | null) => void
+  type?: (decl: Declaration, parent: Declaration | null) => void
+  class?: (decl: Declaration, parent: Declaration | null) => void
+  enum?: (decl: Declaration, parent: Declaration | null) => void
+  import?: (decl: Declaration, parent: Declaration | null) => void
+  export?: (decl: Declaration, parent: Declaration | null) => void
+  module?: (decl: Declaration, parent: Declaration | null) => void
+  namespace?: (decl: Declaration, parent: Declaration | null) => void
+  unknown?: (decl: Declaration, parent: Declaration | null) => void
+}
+/**
+ * Result of a transformer, can be:
+ * - Declaration: replaced declaration
+ * - Declaration[]: multiple declarations (split)
+ * - null: remove the declaration
+ * - undefined: no change
+ */
+export type TransformResult = Declaration | Declaration[] | null | undefined;
+/**
+ * Transformer function that operates on a single declaration
+ */
+export type Transformer = (
+  declaration: Declaration,
+  context: TransformerContext,
+) => TransformResult | Promise<TransformResult>;
+/**
+ * Text transformer operates on the raw text before/after processing
+ */
+export type TextTransformer = (
+  content: string,
+  context: TextTransformerContext,
+) => string | Promise<string>;

package/dist/src/transformers.js

@@ -0,0 +1,2 @@
+// @bun
+import{ci,li,Cn,vo,ui,So,ge,$o,He,Eo,fi,ko,di,To,Ao,Po,Do,pi,mi,Ro,Mo,Oo,Io,Fo,Lo,No,Bo}from"../chunk-kpbz61yy.js";import"../chunk-bxc2herz.js";export{li as cloneDeclaration,So as composeTransformers,ci as createDeclaration,To as createJSDocTransformer,pi as createModifierTransformer,Bo as createNamespacePrefixPlugin,Do as createParameterTransformer,fi as createPrefixTransformer,di as createRemoveTransformer,Eo as createRenameTransformer,Po as createReturnTypeTransformer,Oo as createStripTagsTransformer,ko as createSuffixTransformer,He as createTransformerPlugin,Ao as createTypeTransformer,Io as createWrapTypeTransformer,No as declarePlugin,ge as filterByKind,$o as filterByPredicate,vo as findDeclarations,ui as mapDeclarations,Mo as optionalTransformer,Fo as readonlyPlugin,mi as readonlyTransformer,Ro as requiredTransformer,Lo as stripPrivatePlugin,Cn as walkDeclarations};

package/dist/src/tree-shaker.d.ts

@@ -0,0 +1,69 @@
+import type { Declaration, DeclarationKind } from './types.js';
+/**
+ * Shake unused declarations from the tree
+ */
+export declare function treeShake(declarations: Declaration[], config?: TreeShakeConfig): TreeShakeResult;
+/**
+ * Build a declaration dependency graph for tree shaking
+ */
+export declare function buildDeclarationDependencyGraph(declarations: Declaration[]): Map<string, Set<string>>;
+/**
+ * Extract type references from a declaration
+ */
+export declare function extractTypeReferences(decl: Declaration): Set<string>;
+/**
+ * Tree shake content string
+ */
+export declare function treeShakeContent(content: string, config?: TreeShakeConfig): { content: string, removed: string[] };
+/**
+ * Get unused declarations (those that could be removed)
+ */
+export declare function findUnusedDeclarations(declarations: Declaration[], config?: Omit<TreeShakeConfig, 'debug'>): string[];
+/**
+ * Analyze dependencies for a declaration
+ */
+export declare function analyzeDependencies(declarationName: string, declarations: Declaration[]): {
+  directDependencies: string[]
+  transitiveDependencies: string[]
+  dependents: string[]
+};
+/**
+ * Create a tree shaker with preset configuration
+ */
+export declare function createTreeShaker(config?: TreeShakeConfig): {
+  shake: (declarations: Declaration[]) => TreeShakeResult
+  shakeContent: (content: string) => { content: string, removed: string[] }
+  findUnused: (declarations: Declaration[]) => string[]
+  analyzeDependencies: (name: string, declarations: Declaration[]) => { directDependencies: string[], transitiveDependencies: string[], dependents: string[] }
+  buildGraph: typeof buildDeclarationDependencyGraph
+  extractRefs: typeof extractTypeReferences
+};
+/**
+ * Tree shaking configuration
+ */
+export declare interface TreeShakeConfig {
+  entryPoints?: string[]
+  keepExported?: boolean
+  keep?: (string | RegExp)[]
+  remove?: (string | RegExp)[]
+  shakableKinds?: DeclarationKind[]
+  debug?: boolean
+}
+/**
+ * Result of tree shaking
+ */
+export declare interface TreeShakeResult {
+  declarations: Declaration[]
+  removed: string[]
+  dependencyGraph: Map<string, Set<string>>
+  stats: TreeShakeStats
+}
+/**
+ * Tree shaking statistics
+ */
+export declare interface TreeShakeStats {
+  totalBefore: number
+  totalAfter: number
+  removedCount: number
+  reductionPercent: number
+}

package/dist/src/tree-shaker.js

@@ -0,0 +1,2 @@
+// @bun
+import{rt,it,st,tr,nr,rr,ji}from"../chunk-eba562w8.js";export{rr as analyzeDependencies,it as buildDeclarationDependencyGraph,ji as createTreeShaker,st as extractTypeReferences,nr as findUnusedDeclarations,rt as treeShake,tr as treeShakeContent};

package/dist/src/tsconfig.d.ts

@@ -0,0 +1,8 @@
+/** Read the shared generation options across a JSONC tsconfig hierarchy. */
+export declare function readEffectiveTsconfig(path: string, readOptions?: { allowCircular?: boolean }, ancestors?: Set<string>): Promise<EffectiveTsconfig | undefined>;
+export declare interface EffectiveTsconfig {
+  isolatedDeclarations?: boolean
+  baseUrl?: string
+  paths?: Record<string, string[]>
+  pathsBasePath?: string
+}

package/dist/src/tsconfig.js

@@ -0,0 +1,2 @@
+// @bun
+import{X}from"../chunk-qzjzw9p2.js";import"../chunk-cpmqa8kd.js";export{X as readEffectiveTsconfig};

package/dist/src/type-mappings.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Get preset mappings
+ */
+export declare function getPresetMappings(preset: TypeMappingPreset): TypeMappingRule[];
+/**
+ * Create a type mapper with configuration
+ */
+export declare function createTypeMapper(config?: TypeMappingConfig): TypeMapper;
+/**
+ * Apply type mappings to declaration text
+ */
+export declare function applyTypeMappings(declarationText: string, mapper: TypeMapper, context?: Partial<TypeMappingContext>): string;
+/**
+ * Default type mappings for common patterns
+ */
+export declare const defaultTypeMappings: TypeMappingRule[];
+/**
+ * Strict mode mappings - converts unsafe types
+ */
+export declare const strictTypeMappings: TypeMappingRule[];
+/**
+ * Readonly mappings - adds immutability
+ */
+export declare const readonlyTypeMappings: TypeMappingRule[];
+/**
+ * Simplified mappings - reduces complexity
+ */
+export declare const simplifiedTypeMappings: TypeMappingRule[];
+/**
+ * Default type mapper instance
+ */
+export declare const defaultTypeMapper: TypeMapper;
+/**
+ * Strict type mapper instance
+ */
+export declare const strictTypeMapper: TypeMapper;
+/**
+ * Built-in type transformers
+ * @defaultValue
+ * ```ts
+ * {
+ *   makeReadonly: (type: string) => string,
+ *   makeNullable: (type: string) => string,
+ *   makeOptional: (type: string) => string,
+ *   makeRequired: (type: string) => string,
+ *   promisify: (type: string) => string,
+ *   unpromisify: (type: string) => string,
+ *   arrayify: (type: string) => string,
+ *   unarrayify: (type: string) => string
+ * }
+ * ```
+ */
+export declare const TypeTransformers: {
+  /**
+   * Make all types readonly
+   */
+  makeReadonly: (type: string) => string;
+  /**
+   * Make type nullable
+   */
+  makeNullable: (type: string) => string;
+  /**
+   * Make type optional (add undefined)
+   */
+  makeOptional: (type: string) => string;
+  /**
+   * Remove null/undefined from type
+   */
+  makeRequired: (type: string) => string;
+  /**
+   * Wrap in Promise
+   */
+  promisify: (type: string) => string;
+  /**
+   * Unwrap Promise
+   */
+  unpromisify: (type: string) => string;
+  /**
+   * Convert to array type
+   */
+  arrayify: (type: string) => string;
+  /**
+   * Unwrap array type
+   */
+  unarrayify: (type: string) => string
+};
+/**
+ * Custom type mappings for DTS generation
+ * Allows users to specify type replacements and transformations
+ */
+/**
+ * Type mapping rule
+ */
+export declare interface TypeMappingRule {
+  pattern: string | RegExp
+  replacement: string
+  condition?: (context: TypeMappingContext) => boolean
+  global?: boolean
+  priority?: number
+}
+/**
+ * Context passed to type mapping functions
+ */
+export declare interface TypeMappingContext {
+  type: string
+  declarationName?: string
+  declarationKind?: string
+  filePath?: string
+  isReturnType?: boolean
+  isParameterType?: boolean
+  isPropertyType?: boolean
+}
+/**
+ * Type mapping configuration
+ */
+export declare interface TypeMappingConfig {
+  rules: TypeMappingRule[]
+  presets?: TypeMappingPreset[]
+  includeDefaults?: boolean
+  cacheKey?: string
+}
+/**
+ * Available type mapping presets
+ */
+export type TypeMappingPreset = | 'strict' // Convert 'any' to 'unknown'
+| 'readonly' // Add readonly to array types
+| 'nullable' // Convert undefined unions to optional
+| 'branded' // Use branded types for primitives
+| 'simplified' // Simplify complex utility types;
+/**
+ * Type mapper class for applying transformations
+ */
+export declare class TypeMapper {
+  private rules;
+  private compiled;
+  private cache;
+  constructor(config?: TypeMappingConfig);
+  private recompile;
+  map(type: string, context?: Partial<TypeMappingContext>): string;
+  mapAll(types: string[], context?: Partial<TypeMappingContext>): string[];
+  addRule(rule: TypeMappingRule): void;
+  removeRules(pattern: string | RegExp): number;
+  clearCache(): void;
+  getRules(): readonly TypeMappingRule[];
+}

package/dist/src/type-mappings.js

@@ -0,0 +1,2 @@
+// @bun
+import{ri,ii,si,oi,ai,yn,K,wo,xo,wt,Co}from"../chunk-0yg5mcrf.js";export{yn as TypeMapper,Co as TypeTransformers,wt as applyTypeMappings,K as createTypeMapper,wo as defaultTypeMapper,ri as defaultTypeMappings,ai as getPresetMappings,si as readonlyTypeMappings,oi as simplifiedTypeMappings,xo as strictTypeMapper,ii as strictTypeMappings};

package/dist/src/types.d.ts

@@ -0,0 +1,230 @@
+/**
+ * DtsGenerationConfig
+ *
+ * This is the configuration object for the DTS generation process.
+ */
+export declare interface DtsGenerationConfig {
+  cwd: string
+  root: string
+  entrypoints: string[]
+  outdir: string
+  keepComments: boolean
+  clean: boolean
+  tsconfigPath: string
+  verbose: boolean | string[]
+  outputStructure?: 'mirror' | 'flat'
+  moduleSpecifierMode?: 'preserve' | 'node'
+  importOrder?: string[]
+  dryRun?: boolean
+  stats?: boolean
+  continueOnError?: boolean
+  logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent'
+  exclude?: string[]
+  outputFormat?: 'text' | 'json'
+  progress?: boolean
+  diff?: boolean
+  validate?: boolean
+  watch?: boolean
+  parallel?: boolean
+  concurrency?: number
+  declarationMap?: boolean
+  plugins?: import('./plugins.js').Plugin[]
+  bundle?: boolean
+  bundleOutput?: string
+  autoIncludeReExports?: boolean
+  failOnUnresolvedReExport?: boolean
+  incremental?: boolean
+  cacheDir?: string
+  clearCache?: boolean
+  indentStyle?: 'spaces' | 'tabs'
+  indentSize?: number
+  prettier?: boolean
+  include?: string[]
+  isolatedDeclarations?: boolean
+  typeMappings?: import('./type-mappings.js').TypeMappingConfig
+  lineEnding?: 'lf' | 'crlf' | 'auto'
+  normalizeOutput?: boolean
+  declarationOrder?: {
+    kinds?: import('./types.js').DeclarationKind[]
+    alphabetize?: boolean
+    groupExports?: boolean
+  }
+  tracking?: TrackingConfig
+  profiling?: ProfilingConfig
+  typeInference?: TypeInferenceConfig
+  typeChecking?: TypeCheckingConfig
+  typeValidation?: TypeValidationConfig
+}
+/**
+ * Tracking configuration for debugging type and import usage
+ */
+export declare interface TrackingConfig {
+  types?: boolean
+  relationships?: boolean
+  usage?: boolean
+  imports?: boolean
+  importUsage?: boolean
+  importRelationships?: boolean
+}
+/**
+ * Profiling configuration for performance analysis
+ */
+export declare interface ProfilingConfig {
+  memory?: boolean
+  memoryLimit?: number
+  cpu?: boolean
+  samplingInterval?: number
+  io?: boolean
+  trackOperations?: ('read' | 'write')[]
+  outputFile?: string
+}
+/**
+ * Type inference configuration
+ */
+export declare interface TypeInferenceConfig {
+  enabled?: boolean
+  strictness?: 'loose' | 'normal' | 'strict'
+  inferReturnTypes?: boolean
+  inferConstTypes?: boolean
+}
+/**
+ * Type checking configuration
+ */
+export declare interface TypeCheckingConfig {
+  enabled?: boolean
+  strictness?: 'loose' | 'normal' | 'strict'
+  warningsAsErrors?: boolean
+  maxErrors?: number
+}
+/**
+ * Type validation configuration
+ */
+export declare interface TypeValidationConfig {
+  enabled?: boolean
+  rules?: {
+    noAny?: boolean
+    noUnknown?: boolean
+    noImplicitAny?: boolean
+    explicitReturnTypes?: boolean
+    explicitParameterTypes?: boolean
+  }
+}
+/**
+ * Source location for error reporting
+ */
+export declare interface SourceLocation {
+  line: number
+  column: number
+  offset?: number
+}
+/**
+ * Detailed error information with source location
+ */
+export declare interface DtsError {
+  file: string
+  message: string
+  code?: string
+  location?: SourceLocation
+  stack?: string
+  suggestion?: string
+}
+/**
+ * Generation statistics
+ */
+export declare interface GenerationStats {
+  generationMode: 'isolated' | 'semantic'
+  filesProcessed: number
+  filesGenerated: number
+  filesFailed: number
+  filesValidated: number
+  validationErrors: number
+  declarationsFound: number
+  importsProcessed: number
+  exportsProcessed: number
+  durationMs: number
+  errors: DtsError[]
+}
+/**
+ * Declaration
+ *
+ * Represents a parsed declaration from TypeScript source
+ */
+export declare interface Declaration {
+  kind: DeclarationKind
+  name: string
+  text: string
+  leadingComments?: string[]
+  isExported: boolean
+  isDefault?: boolean
+  typeAnnotation?: string
+  inferredType?: string
+  computedKeyConstants?: import('./computed-keys.js').KeyConstants
+  inferenceError?: 'DTSX_UNSUPPORTED_VALUE_FLOW'
+  moduleForm?: 'namespace' | 'identifier' | 'quoted' | 'global'
+  modifiers?: string[]
+  generics?: string
+  extends?: string
+  implements?: string[]
+  members?: Declaration[]
+  parameters?: ParameterDeclaration[]
+  returnType?: string
+  value?: unknown
+  initializerStart?: number
+  source?: string
+  specifiers?: ImportSpecifier[]
+  isTypeOnly?: boolean
+  isSideEffect?: boolean
+  isAsync?: boolean
+  isGenerator?: boolean
+  overloads?: string[]
+  start?: number
+  end?: number
+}
+/**
+ * ParameterDeclaration
+ */
+export declare interface ParameterDeclaration {
+  name: string
+  type?: string
+  optional?: boolean
+  rest?: boolean
+  defaultValue?: string
+}
+/**
+ * ImportSpecifier
+ */
+export declare interface ImportSpecifier {
+  name: string
+  alias?: string
+  isType?: boolean
+}
+/**
+ * ProcessingContext
+ *
+ * Context passed through processing pipeline
+ */
+export declare interface ProcessingContext {
+  filePath: string
+  sourceCode: string
+  declarations: Declaration[]
+  imports?: Map<string, Set<string>>
+  exports?: Set<string>
+  usedTypes?: Set<string>
+  augmentationImports?: ReadonlySet<string>
+}
+/**
+ * DtsGenerationOption
+ *
+ * This is the configuration object for the DTS generation process.
+ */
+export type DtsGenerationOption = Partial<DtsGenerationConfig>;
+/**
+ * DtsGenerationOptions
+ *
+ * This is the configuration object for the DTS generation process.
+ */
+export type DtsGenerationOptions = DtsGenerationOption | DtsGenerationOption[];
+/**
+ * Declaration kind - all possible declaration types
+ */
+export type DeclarationKind = 'function' | 'variable' | 'interface' | 'type' | 'class' | 'enum' | 'import' | 'export' | 'module' | 'namespace' | 'unknown';

package/dist/src/types.js

@@ -0,0 +1 @@
+// @bun