@stacksjs/dtsx 0.9.9 → 0.9.11

package/dist/branded-types.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Type guard and constructor for FilePath
+ */
+export declare function asFilePath(path: string): FilePath;
+/**
+ * Type guard and constructor for DirectoryPath
+ */
+export declare function asDirectoryPath(path: string): DirectoryPath;
+/**
+ * Type guard and constructor for GlobPattern
+ */
+export declare function asGlobPattern(pattern: string): GlobPattern;
+/**
+ * Type guard and constructor for SourceCode
+ */
+export declare function asSourceCode(code: string): SourceCode;
+/**
+ * Type guard and constructor for DtsContent
+ */
+export declare function asDtsContent(content: string): DtsContent;
+/**
+ * Type guard and constructor for ModuleSpecifier
+ */
+export declare function asModuleSpecifier(specifier: string): ModuleSpecifier;
+/**
+ * Type guard and constructor for TypeName
+ */
+export declare function asTypeName(name: string): TypeName;
+/**
+ * Type guard and constructor for DeclarationName
+ */
+export declare function asDeclarationName(name: string): DeclarationName;
+/**
+ * Type guard and constructor for AbsolutePath
+ */
+export declare function asAbsolutePath(path: string): AbsolutePath;
+/**
+ * Type guard and constructor for RelativePath
+ */
+export declare function asRelativePath(path: string): RelativePath;
+/**
+ * Type guard and constructor for JsonString
+ */
+export declare function asJsonString(json: string): JsonString;
+/**
+ * Check if a value is a branded type of a specific brand
+ */
+export declare function isBranded<T, B extends string>(value: unknown, _brand: B): value is Brand<T, B>;
+/**
+ * Unwrap a branded type to its base type
+ * Useful when you need to pass branded types to external APIs
+ */
+export declare function unwrap<T>(branded: Brand<T, string>): T;
+/**
+ * Safe path operations that preserve branding
+ * @defaultValue
+ * ```ts
+ * {
+ *   join: (base: DirectoryPath, ...segments: string[]) => unknown,
+ *   dirname: (path: FilePath) => unknown,
+ *   basename: (path: FilePath) => unknown,
+ *   resolve: (...segments: string[]) => unknown,
+ *   isAbsolute: (path: string) => unknown,
+ *   relative: (from: DirectoryPath, to: FilePath) => unknown
+ * }
+ * ```
+ */
+export declare const BrandedPath: {
+  /**
+   * Join path segments, returning appropriate branded type
+   */
+  join: (base: DirectoryPath, ...segments: string[]) => unknown;
+  /**
+   * Get directory name from a file path
+   */
+  dirname: (path: FilePath) => unknown;
+  /**
+   * Get base name from a file path
+   */
+  basename: (path: FilePath) => unknown;
+  /**
+   * Resolve path to absolute
+   */
+  resolve: (...segments: string[]) => unknown;
+  /**
+   * Check if path is absolute
+   */
+  isAbsolute: (path: string) => unknown;
+  /**
+   * Get relative path from one path to another
+   */
+  relative: (from: DirectoryPath, to: FilePath) => unknown
+};
+/**
+ * Generic branded type creator
+ */
+export type Brand<T, B extends string> = T & { readonly [__brand]: B }
+/**
+ * Branded type for file paths
+ * Ensures file paths are validated before use
+ */
+export type FilePath = Brand<string, 'FilePath'>;
+/**
+ * Branded type for directory paths
+ */
+export type DirectoryPath = Brand<string, 'DirectoryPath'>;
+/**
+ * Branded type for glob patterns
+ */
+export type GlobPattern = Brand<string, 'GlobPattern'>;
+/**
+ * Branded type for TypeScript source code
+ */
+export type SourceCode = Brand<string, 'SourceCode'>;
+/**
+ * Branded type for declaration file content
+ */
+export type DtsContent = Brand<string, 'DtsContent'>;
+/**
+ * Branded type for module specifiers (import paths)
+ */
+export type ModuleSpecifier = Brand<string, 'ModuleSpecifier'>;
+/**
+ * Branded type for type names
+ */
+export type TypeName = Brand<string, 'TypeName'>;
+/**
+ * Branded type for declaration names
+ */
+export type DeclarationName = Brand<string, 'DeclarationName'>;
+/**
+ * Branded type for validated JSON strings
+ */
+export type JsonString = Brand<string, 'JsonString'>;
+/**
+ * Branded type for absolute paths
+ */
+export type AbsolutePath = Brand<string, 'AbsolutePath'>;
+/**
+ * Branded type for relative paths
+ */
+export type RelativePath = Brand<string, 'RelativePath'>;
+/**
+ * Type utility to extract the brand from a branded type
+ */
+export type ExtractBrand<T> = T extends Brand<unknown, infer B> ? B : never;
+/**
+ * Type utility to extract the base type from a branded type
+ */
+export type ExtractBase<T> = T extends Brand<infer U, string> ? U : T;

package/dist/bundler.d.ts

@@ -0,0 +1,55 @@
+import type { DtsGenerationConfig } from './types';
+/**
+ * Bundle multiple TypeScript files into a single .d.ts file
+ */
+export declare function bundleDeclarations(files: string[], sourceContents: Map<string, string>, config: DtsGenerationConfig): Promise<BundleResult>;
+/**
+ * Bundle multiple .d.ts files into a single file
+ */
+export declare function bundleDtsFiles(files: string[], config?: Partial<BundleConfig>): Promise<BundleResult>;
+/**
+ * Bundle and write to file
+ */
+export declare function bundleAndWrite(files: string[], outputPath: string, config?: Partial<BundleConfig>): Promise<BundleResult>;
+/**
+ * Create a bundler with preset configuration
+ */
+export declare function createBundler(config?: Partial<BundleConfig>): {
+  bundle: (files: string[]) => Promise<BundleResult>
+  bundleAndWrite: (files: string[], output: string) => Promise<BundleResult>
+};
+/**
+ * Resolve entry files from glob patterns
+ */
+export declare function resolveEntryFiles(patterns: string | string[], cwd?: string): Promise<string[]>;
+/**
+ * Bundle configuration options
+ */
+export declare interface BundleConfig {
+  entry: string | string[]
+  output: string
+  name?: string
+  includeSourceComments?: boolean
+  preserveFileSections?: boolean
+  externals?: string[]
+  banner?: string
+  footer?: string
+  sortDeclarations?: boolean
+  mergeDuplicates?: boolean
+  ambient?: boolean
+  moduleName?: string
+  includeReferences?: boolean
+  references?: string[]
+}
+/**
+ * Bundle result containing the combined declarations
+ */
+export declare interface BundleResult {
+  content: string
+  files: string[]
+  declarationCount: number
+  importCount: number
+  exportCount: number
+  size: number
+  warnings: string[]
+}

package/dist/cache.d.ts

@@ -0,0 +1,43 @@
+import type { DtsGenerationConfig } from './types';
+/**
+ * Add .dtsx-cache to .gitignore if not already present
+ */
+export declare function ensureGitignore(cwd: string): void;
+/**
+ * Cache entry for a single file
+ */
+export declare interface CacheEntry {
+  sourcePath: string
+  sourceHash: string
+  sourceMtime: number
+  dtsContent: string
+  dtsHash: string
+  generatedAt: number
+  configHash: string
+}
+/**
+ * Cache manifest containing all cached entries
+ */
+export declare interface CacheManifest {
+  version: number
+  configHash: string
+  entries: Record<string, CacheEntry>
+  createdAt: number
+  updatedAt: number
+}
+/**
+ * Incremental build cache manager
+ */
+export declare class BuildCache {
+  constructor(config: DtsGenerationConfig);
+  load(): boolean;
+  save(): void;
+  needsRegeneration(filePath: string, cwd: string): boolean;
+  getCached(filePath: string, cwd: string): string | null;
+  getCachedIfValid(filePath: string, cwd: string): string | null;
+  update(filePath: string, sourceContent: string, dtsContent: string, cwd: string): void;
+  remove(filePath: string, cwd: string): void;
+  clear(): void;
+  getStats(): { entries: number, size: number };
+  prune(existingFiles: Set<string>, cwd: string): number;
+}

package/dist/checker.d.ts

@@ -0,0 +1,107 @@
+import ts from 'typescript';
+import type { DtsGenerationConfig } from './types';
+/**
+ * Load TypeScript compiler options from tsconfig.json
+ */
+export declare function loadCompilerOptions(tsconfigPath: string, overrides?: Partial<ts.CompilerOptions>): ts.CompilerOptions;
+/**
+ * Type check TypeScript/declaration files
+ */
+export declare function typeCheck(files: string[], config?: TypeCheckConfig): Promise<TypeCheckResult>;
+/**
+ * Validate that generated .d.ts files are valid TypeScript
+ */
+export declare function validateDeclarations(dtsFiles: string[], config?: TypeCheckConfig): Promise<TypeCheckResult>;
+/**
+ * Check if source files are compatible with TypeScript's isolatedDeclarations mode
+ */
+export declare function checkIsolatedDeclarations(files: string[], tsconfigPath?: string): Promise<Map<string, IsolatedDeclarationsResult>>;
+/**
+ * Get type information for a specific position in a file
+ */
+export declare function getTypeAtPosition(filePath: string, line: number, column: number, tsconfigPath?: string): string | null;
+/**
+ * Get quick info (hover information) for a position
+ */
+export declare function getQuickInfo(filePath: string, line: number, column: number, tsconfigPath?: string): { type: string, documentation?: string } | null;
+/**
+ * Format type check results as a human-readable string
+ */
+export declare function formatTypeCheckResults(result: TypeCheckResult): string;
+/**
+ * Integrate type checking into DTS generation config
+ */
+export declare function typeCheckWithConfig(config: DtsGenerationConfig): Promise<TypeCheckResult>;
+/**
+ * Validate generated declarations match the source types
+ */
+export declare function validateGeneratedDeclarations(_sourceFiles: string[], _dtsFiles: string[], _tsconfigPath?: string): Promise<{
+    valid: boolean
+    mismatches: Array<{
+      sourceName: string
+      sourceType: string
+      dtsType: string
+    }>
+  }>;
+/**
+ * A diagnostic message from type checking
+ */
+export declare interface TypeDiagnostic {
+  file: string
+  line: number
+  column: number
+  message: string
+  code: number
+  severity: DiagnosticSeverity
+  source?: string
+  suggestion?: string
+  category: string
+}
+/**
+ * Result of type checking
+ */
+export declare interface TypeCheckResult {
+  success: boolean
+  diagnostics: TypeDiagnostic[]
+  errorCount: number
+  warningCount: number
+  infoCount: number
+  filesChecked: string[]
+  durationMs: number
+}
+/**
+ * Type checking configuration
+ */
+export declare interface TypeCheckConfig {
+  tsconfigPath?: string
+  rootDir?: string
+  strict?: boolean
+  declarationsOnly?: boolean
+  skipLibCheck?: boolean
+  include?: string[]
+  exclude?: string[]
+  warningsAsErrors?: boolean
+  maxErrors?: number
+  compilerOptions?: Partial<ts.CompilerOptions>
+}
+/**
+ * Isolated declarations checking result
+ */
+export declare interface IsolatedDeclarationsResult {
+  compatible: boolean
+  issues: IsolatedDeclarationsIssue[]
+}
+/**
+ * An issue found during isolated declarations checking
+ */
+export declare interface IsolatedDeclarationsIssue {
+  line: number
+  column: number
+  message: string
+  declarationName?: string
+  missingAnnotation?: 'return' | 'parameter' | 'variable' | 'property'
+}
+/**
+ * Diagnostic severity levels
+ */
+export type DiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';

package/dist/chunk-1bav913n.js

@@ -0,0 +1,6 @@
+// @bun
+import{tb as y}from"./chunk-9a6yn7sv.js";import{Vc as H,Xc as F}from"./chunk-57agx6g8.js";import{cd as R}from"./chunk-rw6j20e2.js";import{existsSync as V,readFileSync as G}from"fs";import{dirname as M,join as X,resolve as x}from"path";async function S(E){let A=[],z=new Set;async function q(I,L){let w=x(I);if(z.has(w))return;if(z.add(w),!V(w)){H.warn(`tsconfig not found: ${w}`);return}try{let O=G(w,"utf-8").replace(/\/\*[\s\S]*?\*\/|\/\/.*/g,""),K=JSON.parse(O),U=M(w),Y=B(U,L),W=[];if(K.references)for(let D of K.references){let $=x(U,D.path),J=V(X($,"tsconfig.json"))?X($,"tsconfig.json"):$;await q(J,Y);let b=B(M(J),Y);W.push(b)}let Z="./src";if(K.compilerOptions?.rootDir)Z=K.compilerOptions.rootDir;else if(K.include&&K.include.length>0){if(K.include[0].startsWith("src/"))Z="./src"}let _="./dist";if(K.compilerOptions?.outDir)_=K.compilerOptions.outDir;else if(K.compilerOptions?.declarationDir)_=K.compilerOptions.declarationDir;A.push({name:Y,root:U,tsconfigPath:w,references:W,config:{root:Z,outdir:_}})}catch(Q){let O=Q instanceof Error?Q.message:String(Q);H.warn(`Failed to parse ${w}: ${O}`)}}return await q(E),A}function B(E,A){let z=X(E,"package.json");if(V(z))try{let I=G(z,"utf-8"),L=JSON.parse(I);if(L.name)return L.name}catch{}let q=E.split("/").pop()||"unknown";return A?`${A}/${q}`:q}function N(E){let A=new Map(E.map((w)=>[w.name,w])),z=[],q=new Set,I=new Set;function L(w){if(q.has(w))return;if(I.has(w)){H.warn(`Circular dependency detected involving: ${w}`);return}I.add(w);let Q=A.get(w);if(Q){for(let O of Q.references)L(O);z.push(Q)}I.delete(w),q.add(w)}for(let w of E)L(w.name);return z}async function T(E){let A=Date.now(),z=N(E.projects);H.info(`Generating declarations for ${z.length} projects...`);let q=[],I=!0;for(let O of z){H.info(`
+[${O.name}] Generating...`);try{let K={...E.sharedConfig,...O.config,cwd:O.root,tsconfigPath:O.tsconfigPath},U=await y(K),Y=U.filesFailed===0;if(!Y)I=!1;q.push({name:O.name,stats:U,success:Y}),H.info(`[${O.name}] Generated ${U.filesGenerated} files`)}catch(K){I=!1;let U=K instanceof Error?K.message:String(K);q.push({name:O.name,stats:{filesProcessed:0,filesGenerated:0,filesFailed:0,filesValidated:0,validationErrors:0,declarationsFound:0,importsProcessed:0,exportsProcessed:0,durationMs:0,errors:[]},success:!1,error:U}),H.error(`[${O.name}] Failed: ${U}`)}}let L=Date.now()-A,w=q.filter((O)=>O.success).length,Q=q.length-w;if(H.info(`
+--- Workspace Generation Summary ---`),H.info(`Projects processed: ${q.length}`),H.info(`Successful:         ${w}`),Q>0)H.info(`Failed:             ${Q}`);return H.info(`Total duration:     ${L}ms`),H.info(`------------------------------------
+`),{success:I,projects:q,durationMs:L}}async function f(E,A){if(A?.logLevel)F(A.logLevel);let z=X(E,"tsconfig.json");if(!V(z))throw Error(`Root tsconfig.json not found at: ${z}`);H.info("Discovering workspace projects...");let q=await S(z);if(q.length===0)return H.warn("No projects found in workspace"),{success:!0,projects:[],durationMs:0};return H.info(`Found ${q.length} projects`),T({root:E,projects:q,sharedConfig:A})}async function v(E){let A=X(E,"package.json");if(!V(A))return[];try{let z=G(A,"utf-8"),q=JSON.parse(z),I=[];if(Array.isArray(q.workspaces))I=q.workspaces;else if(q.workspaces?.packages)I=q.workspaces.packages;return I}catch{return[]}}async function C(E,A){let{Glob:z}=awaitPromise.resolve(globalThis.Bun),q=[];for(let I of A){let L=new z(I);for await(let w of L.scan({cwd:E,absolute:!0,onlyFiles:!1})){let Q=X(w,"package.json");if(V(Q))q.push(w)}}return q}async function l(E,A){if(A?.logLevel)F(A.logLevel);let z=await v(E);if(z.length===0)return H.warn("No workspace patterns found in package.json"),{success:!0,projects:[],durationMs:0};H.info(`Found workspace patterns: ${z.join(", ")}`);let q=await C(E,z);if(q.length===0)return H.warn("No projects found matching workspace patterns"),{success:!0,projects:[],durationMs:0};H.info(`Found ${q.length} workspace packages`);let I=q.map((L)=>{let w=X(L,"tsconfig.json");return{name:B(L),root:L,tsconfigPath:V(w)?w:"",references:[]}});return T({root:E,projects:I,sharedConfig:A})}
+export{S as l,N as m,T as n,f as o,v as p,C as q,l as r};

package/dist/chunk-2wbhe1k8.js

@@ -0,0 +1,2 @@
+// @bun
+import{Ac as v,Bc as w,oc as j,pc as k,qc as l,rc as m,sc as n,tc as o,uc as p,vc as q,wc as r,xc as s,yc as t,zc as u}from"./chunk-begk3j01.js";import{Ec as a,Fc as b,Gc as c,Hc as d,Ic as e,Jc as f,Kc as g,Lc as h,Mc as i}from"./chunk-xnq1xw73.js";import"./chunk-rw6j20e2.js";export{l as processVariableDeclaration,n as processTypeDeclaration,s as processModuleDeclaration,m as processInterfaceDeclaration,q as processImportDeclaration,k as processFunctionDeclaration,r as processExportDeclaration,p as processEnumDeclaration,w as processDeclarations,o as processClassDeclaration,u as parseImportStatement,d as parseArrayElements,h as isGenericType,e as inferObjectType,b as inferNarrowTypeInUnion,a as inferNarrowType,g as inferFunctionType,c as inferArrayType,j as formatComments,f as findMatchingBracket,i as extractSatisfiesType,v as extractAllImportedItems,t as clearProcessorCaches};

package/dist/chunk-3d18fhrg.js

@@ -0,0 +1,3 @@
+// @bun
+import{tb as I}from"./chunk-9a6yn7sv.js";function z(J={}){let{onBuildStart:K=!1,onBuildEnd:L=!0,onGenerated:M,onError:C,...N}=J,w,q,F=async()=>{let j={...N};if(!j.outdir&&w)j.outdir=w;if(!j.entrypoints&&q)j.entrypoints=q;try{let k=await I(j);M?.(k)}catch(k){let H=k instanceof Error?k:Error(String(k));if(C?.(H),!C)console.error("[dtsx] Generation failed:",H.message)}};return{name:"dtsx",esbuildOptions(j){if(j.outdir&&typeof j.outdir==="string")w=j.outdir;if(j.entryPoints){if(Array.isArray(j.entryPoints))q=j.entryPoints;else if(typeof j.entryPoints==="object")q=Object.values(j.entryPoints)}},async buildStart(){if(K)await F()},async buildEnd(j){if(L)await F()}}}var R=z,T=z,V=z;
+export{z as ma,R as na,T as oa,V as pa};

package/dist/chunk-3g2v2ns2.js

@@ -0,0 +1,2 @@
+// @bun
+import{I as a,J as b,K as c,L as d,M as e,N as f,O as g,P as h}from"./chunk-d0p3jzwb.js";import"./chunk-rw6j20e2.js";export{b as toZod,e as toYup,c as toValibot,a as toJsonSchema,d as toIoTs,f as toArkType,h as getFormatExtension,g as convertToFormat};

package/dist/chunk-3j7r0fxz.js

@@ -0,0 +1,2 @@
+// @bun
+import{Q as a,R as b,S as c,T as d,U as e,V as f,W as g,X as h,Y as i}from"./chunk-r1ywapeb.js";import"./chunk-p1d09y82.js";import"./chunk-rw6j20e2.js";export{e as getGraphSummary,d as formatCircularAnalysis,f as findAllDependents,g as findAllDependencies,i as exportGraphAsJson,h as exportGraphAsDot,b as detectCircularDependencies,a as buildDependencyGraph,c as analyzeCircularDependencies};

package/dist/chunk-4qpg9xnt.js

@@ -0,0 +1,3 @@
+// @bun
+import{tb as I}from"./chunk-9a6yn7sv.js";class H{options;generateOptions;constructor(j={}){let{onCompile:F=!1,afterEmit:w=!0,onWatchRun:q=!1,onGenerated:z,onError:B,...J}=j;this.options={onCompile:F,afterEmit:w,onWatchRun:q,onGenerated:z,onError:B},this.generateOptions=J}apply(j){if(!this.generateOptions.outdir&&j.options.output?.path)this.generateOptions.outdir=j.options.output.path;if(!this.generateOptions.cwd&&j.options.context)this.generateOptions.cwd=j.options.context;if(!this.generateOptions.entrypoints&&j.options.entry){let w=j.options.entry;if(typeof w==="string")this.generateOptions.entrypoints=[w];else if(Array.isArray(w))this.generateOptions.entrypoints=w;else if(typeof w==="object"&&w!==null){let q=[];for(let z of Object.values(w))if(typeof z==="string")q.push(z);else if(Array.isArray(z))q.push(...z.filter((B)=>typeof B==="string"));else if(typeof z==="object"&&z!==null&&"import"in z){let B=z.import;if(typeof B==="string")q.push(B);else if(Array.isArray(B))q.push(...B)}if(q.length>0)this.generateOptions.entrypoints=q}}if(this.options.onCompile)j.hooks.compile.tap("DtsxWebpackPlugin",()=>{this.runGenerate()});if(this.options.afterEmit)j.hooks.afterEmit.tapAsync("DtsxWebpackPlugin",async(w,q)=>{await this.runGenerate(),q()});if(this.options.onWatchRun)j.hooks.watchRun.tapAsync("DtsxWebpackPlugin",async(w,q)=>{await this.runGenerate(),q()})}async runGenerate(){try{let j=await I(this.generateOptions);this.options.onGenerated?.(j)}catch(j){let F=j instanceof Error?j:Error(String(j));if(this.options.onError?.(F),!this.options.onError)console.error("[dtsx] Generation failed:",F.message)}}}function K(j={}){return new H(j)}var M=K,Q=H;
+export{H as qa,K as ra,M as sa,Q as ta};

package/dist/chunk-57agx6g8.js

@@ -0,0 +1,3 @@
+// @bun
+var K={debug:0,info:1,warn:2,error:3,silent:4},B="info",F="[dtsx]",I=!1,H=null;function y(j){return K[j]>=K[B]}function Q(){if(!I)return"";return`[${new Date().toISOString().slice(11,23)}] `}function S(j,C){let k=Q();if(j||k)return[`${k}${j}`,...C];return C}function z(j,C,k){let q=S(C,k);if(H){H(j,...q);return}switch(j){case"debug":console.debug(...q);break;case"info":console.log(...q);break;case"warn":console.warn(...q);break;case"error":console.error(...q);break}}function J(j){return{debug:(...k)=>{if(y("debug"))z("debug",j,k)},info:(...k)=>{if(y("info"))z("info",j,k)},warn:(...k)=>{if(y("warn"))z("warn",j,k)},error:(...k)=>{if(y("error"))z("error",j,k)},setLevel:(k)=>{B=k},getLevel:()=>B,child:(k)=>{let q=j?`${j}:${k}`:`[${k}]`;return J(q)},time:(k)=>{let q=performance.now();return()=>{let M=performance.now()-q;if(y("debug"))z("debug",j,[`${k}: ${M.toFixed(2)}ms`])}},progress:(k)=>{if(y("info"))if(typeof process<"u"&&process.stdout?.isTTY)process.stdout.write(`\r${j} ${k}`);else z("info",j,[k])}}}function Y(j={}){if(j.level)B=j.level;if(j.prefix!==void 0)F=j.prefix;if(j.timestamps!==void 0)I=j.timestamps;if(j.output)H=j.output;return J(F)}var U=J(F);function Z(j){return U.child(j)}function $(j){B=j}function N(){return B}function D(j){F=j}function G(j){I=j}var X={debug:()=>{},info:()=>{},warn:()=>{},error:()=>{},setLevel:()=>{},getLevel:()=>"silent",child:()=>X,time:()=>()=>{},progress:()=>{}};
+export{Y as Uc,U as Vc,Z as Wc,$ as Xc,N as Yc,D as Zc,G as _c,X as $c};

package/dist/chunk-5vqtjws2.js

@@ -0,0 +1,2 @@
+// @bun
+import{s as a,t as b,u as c,v as d,w as e,x as f,y as g}from"./chunk-w9abhtgg.js";import"./chunk-wfevdmvd.js";import"./chunk-p1d09y82.js";import"./chunk-74j5mydx.js";import"./chunk-rnt0wkrk.js";import"./chunk-begk3j01.js";import"./chunk-xnq1xw73.js";import"./chunk-rw6j20e2.js";export{f as startLSPServer,g as createFileWatcher,b as SymbolKind,a as LspDiagnosticSeverity,e as DtsxLanguageServer,d as DocumentHighlightKind,c as CompletionItemKind};

package/dist/chunk-6mwq397e.js

@@ -0,0 +1,2 @@
+// @bun
+import{tb as b,ub as c,vb as d}from"./chunk-9a6yn7sv.js";import"./chunk-wfevdmvd.js";import"./chunk-p1d09y82.js";import{ic as a}from"./chunk-hrmnrn4p.js";import"./chunk-74j5mydx.js";import"./chunk-rnt0wkrk.js";import"./chunk-begk3j01.js";import"./chunk-xnq1xw73.js";import"./chunk-f18nyrrb.js";import"./chunk-57agx6g8.js";import"./chunk-rw6j20e2.js";export{d as watch,a as processSource,c as processFile,b as generate};

package/dist/chunk-6qv7p9sg.js

@@ -0,0 +1,170 @@
+// @bun
+import{Vc as I}from"./chunk-57agx6g8.js";import{cpus as K}from"os";import{resolve as J}from"path";import{Worker as M}from"worker_threads";var __dirname="/home/runner/work/dtsx/dtsx/packages/dtsx/src";class L{workers=[];taskQueue=[];config;stats={totalTasks:0,completedTasks:0,failedTasks:0,averageDuration:0,activeWorkers:0,idleWorkers:0};isShuttingDown=!1;idleCheckInterval=null;constructor(q={}){let y=q.maxWorkers??Math.max(1,K().length-1);this.config={maxWorkers:y,taskTimeout:q.taskTimeout??30000,recycleAfter:q.recycleAfter??100,idleTimeout:q.idleTimeout??1e4,initialWorkers:q.initialWorkers??Math.min(2,y)}}async init(){let q=Math.min(this.config.initialWorkers,this.config.maxWorkers);for(let y=0;y<q;y++)this.createWorker();if(this.config.idleTimeout>0){if(this.idleCheckInterval=setInterval(()=>{this.checkIdleWorkers()},5000),this.idleCheckInterval&&typeof this.idleCheckInterval==="object"&&"unref"in this.idleCheckInterval)this.idleCheckInterval.unref()}}createWorker(){let q=`
+      const { parentPort } = require('worker_threads');
+      const bun = typeof Bun !== 'undefined' ? Bun : null;
+      const fs = bun ? null : require('node:fs');
+
+      const libsPromise = (async () => {
+        const { extractDeclarations } = await import('${J(__dirname,"extractor.js")}');
+        const { processDeclarations } = await import('${J(__dirname,"processor.js")}');
+        return { extractDeclarations, processDeclarations };
+      })();
+
+      // Dynamic import for ESM compatibility
+      async function processTask(task) {
+        const startTime = Date.now();
+
+        try {
+          const { extractDeclarations, processDeclarations } = await libsPromise;
+
+          const keepComments = task.config?.keepComments;
+          const isolatedDeclarations = task.config?.isolatedDeclarations;
+          const importOrder = task.config?.importOrder;
+
+          if (task.type === 'process-batch') {
+            const filePaths = task.filePaths;
+            const outPaths = task.outPaths;
+            const files = filePaths ? null : (task.files || []);
+            const fileCount = filePaths ? filePaths.length : files.length;
+            const writeOutput = task.writeOutput === true;
+            const results = writeOutput ? null : new Array(fileCount);
+            let errorResults = null;
+
+            let sources = task.sources;
+            if (!sources && fileCount > 0) {
+              const readPromises = new Array(fileCount);
+              for (let i = 0; i < fileCount; i++) {
+                const file = files ? files[i] : null;
+                const sourceCode = file ? file.sourceCode : undefined;
+                const filePath = filePaths ? filePaths[i] : file.filePath;
+                if (sourceCode != null) {
+                  readPromises[i] = Promise.resolve(sourceCode);
+                } else if (bun) {
+                  readPromises[i] = bun.file(filePath).text();
+                } else {
+                  readPromises[i] = Promise.resolve(fs.readFileSync(filePath, 'utf-8'));
+                }
+              }
+              sources = await Promise.all(readPromises);
+            }
+
+            const ctx = { filePath: '', sourceCode: '', declarations: [] };
+            const writePromises = writeOutput && bun ? new Array(fileCount) : null;
+            let success = true;
+
+            for (let i = 0; i < fileCount; i++) {
+              const file = files ? files[i] : null;
+              const filePath = filePaths ? filePaths[i] : file.filePath;
+              const outPath = outPaths ? outPaths[i] : (file ? file.outPath : undefined);
+              try {
+                const sourceCode = sources ? sources[i] : (file?.sourceCode || '');
+                const declarations = extractDeclarations(sourceCode, filePath, keepComments, isolatedDeclarations);
+                ctx.filePath = filePath;
+                ctx.sourceCode = sourceCode;
+                ctx.declarations = declarations;
+                const content = processDeclarations(declarations, ctx, true, importOrder);
+
+                if (writeOutput) {
+                  if (!outPath) {
+                    throw new Error('Missing outPath for ' + filePath);
+                  }
+                  if (bun) {
+                    writePromises[i] = bun.write(outPath, content);
+                  } else {
+                    fs.writeFileSync(outPath, content);
+                  }
+                } else if (results) {
+                  results[i] = {
+                    filePath,
+                    success: true,
+                    content,
+                    declarations,
+                  };
+                }
+              } catch (error) {
+                const message = error && error.message ? error.message : String(error);
+                if (writeOutput) {
+                  if (!errorResults) {
+                    errorResults = [];
+                  }
+                  errorResults.push({
+                    filePath,
+                    success: false,
+                    error: message,
+                  });
+                } else if (results) {
+                  results[i] = {
+                    filePath,
+                    success: false,
+                    error: message,
+                  };
+                }
+                success = false;
+              }
+            }
+
+            if (writePromises) {
+              await Promise.all(writePromises);
+            }
+
+            const errorMessage = errorResults?.length
+              ? (errorResults[0].filePath + ': ' + (errorResults[0].error || 'Worker batch failed'))
+              : undefined;
+
+            return {
+              id: task.id,
+              success,
+              filePath: task.filePath,
+              batchResults: writeOutput ? errorResults || undefined : results,
+              error: errorMessage,
+              duration: Date.now() - startTime,
+            };
+          }
+
+          if (task.type === 'extract') {
+            const declarations = extractDeclarations(task.sourceCode, task.filePath, keepComments, isolatedDeclarations);
+            return {
+              id: task.id,
+              success: true,
+              filePath: task.filePath,
+              declarations,
+              duration: Date.now() - startTime,
+            };
+          }
+
+          if (task.type === 'process') {
+            const declarations = extractDeclarations(task.sourceCode, task.filePath, keepComments, isolatedDeclarations);
+            const content = processDeclarations(declarations, {
+              filePath: task.filePath,
+              sourceCode: task.sourceCode,
+              declarations,
+            }, true, importOrder);
+
+            return {
+              id: task.id,
+              success: true,
+              filePath: task.filePath,
+              content,
+              declarations,
+              duration: Date.now() - startTime,
+            };
+          }
+
+          throw new Error('Unknown task type: ' + task.type);
+        } catch (error) {
+          return {
+            id: task.id,
+            success: false,
+            filePath: task.filePath,
+            error: error.message,
+            duration: Date.now() - startTime,
+          };
+        }
+      }
+
+      parentPort.on('message', async (task) => {
+        const result = await processTask(task);
+        parentPort.postMessage(result);
+      });
+    `,y=new M(q,{eval:!0}),F={worker:y,busy:!1,taskCount:0,lastActive:Date.now(),currentTask:null};return y.on("message",(E)=>{this.handleWorkerResult(F,E)}),y.on("error",(E)=>{I.error("Worker error:",E),this.handleWorkerError(F,E)}),y.on("exit",(E)=>{if(E!==0&&!this.isShuttingDown)I.error(`Worker exited with code ${E}`),this.removeWorker(F)}),this.workers.push(F),this.updateStats(),F}handleWorkerResult(q,y){if(q.busy=!1,q.taskCount++,q.lastActive=Date.now(),q.currentTask&&q.currentTask.id===y.id){clearTimeout(q.currentTask.timeout);let{resolve:E}=q.currentTask;q.currentTask=null,E(y)}if(y.success)this.stats.completedTasks++;else this.stats.failedTasks++;let F=this.stats.averageDuration*(this.stats.completedTasks+this.stats.failedTasks-1)+y.duration;if(this.stats.averageDuration=F/(this.stats.completedTasks+this.stats.failedTasks),this.updateStats(),q.taskCount>=this.config.recycleAfter)this.recycleWorker(q);this.processQueue()}handleWorkerError(q,y){if(q.busy=!1,q.currentTask){clearTimeout(q.currentTask.timeout);let{reject:F}=q.currentTask;q.currentTask=null,F(y)}this.stats.failedTasks++,this.updateStats(),this.recycleWorker(q),this.processQueue()}removeWorker(q){let y=this.workers.indexOf(q);if(y!==-1)this.workers.splice(y,1),q.worker.terminate();this.updateStats()}recycleWorker(q){if(this.removeWorker(q),!this.isShuttingDown&&this.workers.length<this.config.maxWorkers)this.createWorker()}checkIdleWorkers(){let q=Date.now(),y=1;for(let F=this.workers.length-1;F>=0;F--){let E=this.workers[F];if(!E.busy&&q-E.lastActive>this.config.idleTimeout&&this.workers.length>1)this.removeWorker(E)}}processQueue(){while(this.taskQueue.length>0){let q;for(let G=0;G<this.workers.length;G++)if(!this.workers[G].busy){q=this.workers[G];break}if(!q&&this.workers.length<this.config.maxWorkers)q=this.createWorker();if(!q)return;let{task:y,resolve:F,reject:E}=this.taskQueue.shift();q.busy=!0,q.lastActive=Date.now();let H=setTimeout(()=>{if(q.currentTask?.id===y.id)q.currentTask=null;E(Error(`Task ${y.id} timed out`)),this.recycleWorker(q)},this.config.taskTimeout);q.currentTask={id:y.id,resolve:F,reject:E,timeout:H},q.worker.postMessage(y),this.updateStats()}}async submit(q){return this.stats.totalTasks++,new Promise((y,F)=>{this.taskQueue.push({task:q,resolve:y,reject:F}),this.processQueue()})}async processFiles(q,y={}){let F=q.map((E,H)=>({id:`task-${H}-${Date.now()}`,type:"process",filePath:E.path,sourceCode:E.content,config:y}));return Promise.all(F.map((E)=>this.submit(E)))}updateStats(){let q=0;for(let y=0;y<this.workers.length;y++)if(this.workers[y].busy)q++;this.stats.activeWorkers=q,this.stats.idleWorkers=this.workers.length-q}getStats(){return{...this.stats}}async shutdown(){if(this.isShuttingDown=!0,this.idleCheckInterval)clearInterval(this.idleCheckInterval);while(this.taskQueue.length>0||this.workers.some((q)=>q.busy))await new Promise((q)=>setTimeout(q,100));await Promise.all(this.workers.map((q)=>q.worker.terminate())),this.workers=[]}}function N(q={}){return new L(q)}async function U(q,y={},F={}){let E=N(F);await E.init();try{return await E.processFiles(q,y)}finally{await E.shutdown()}}function V(q,y){let F=[];for(let E=0;E<q.length;E+=y)F.push(q.slice(E,E+y));return F}function X(q,y=K().length){if(q<=y)return 1;let E=y*3;return Math.max(1,Math.ceil(q/E))}
+export{L as Z,N as _,U as $,V as aa,X as ba};

package/dist/chunk-6s7n1gt0.js

@@ -0,0 +1,2 @@
+// @bun
+import{Oc as a,Pc as b,Qc as c,Rc as d,Sc as e,Tc as f}from"./chunk-f18nyrrb.js";import"./chunk-57agx6g8.js";import"./chunk-rw6j20e2.js";export{c as resetConfig,b as getConfig,e as defineConfigAsync,d as defineConfig,a as defaultConfig,f as config};

package/dist/chunk-74j5mydx.js

@@ -0,0 +1,3 @@
+// @bun
+import{nc as J}from"./chunk-rnt0wkrk.js";var S=typeof globalThis.Bun?.hash==="function";function z(u){if(S)return Bun.hash(u);let g=0;for(let f=0;f<u.length;f++){let b=u.charCodeAt(f);g=(g<<5)-g+b,g=g&g}return g}var T=100,G=0,B=new Map;function Y(u,g,f=!0,b=!1){let x=z(u),F=`${g}:${f?1:0}:${b?1:0}`,p=B.get(F);if(p&&p.contentHash===x)return p.lastAccess=++G,p.declarations;let j=J(u,g,f,b);if(B.set(F,{declarations:j,contentHash:x,lastAccess:++G}),B.size>T){let w=null,q=1/0;for(let[Q,v]of B)if(v.lastAccess<q)q=v.lastAccess,w=Q;if(w)B.delete(w)}return j}function $(){B.clear()}
+export{z as kc,Y as lc,$ as mc};

package/dist/chunk-7cpp6v8f.js

@@ -0,0 +1,2 @@
+// @bun
+import{A as b,B as c,C as d,D as e,E as f,F as g,G as h,H as i,z as a}from"./chunk-jm5ywn4e.js";import"./chunk-p1d09y82.js";import"./chunk-rw6j20e2.js";export{i as validateGeneratedDeclarations,c as validateDeclarations,h as typeCheckWithConfig,b as typeCheck,a as loadCompilerOptions,e as getTypeAtPosition,f as getQuickInfo,g as formatTypeCheckResults,d as checkIsolatedDeclarations};