bio-dts 0.14.1 → 0.15.1

package/README.md

@@ -28,6 +28,7 @@ Generates clean type definitions from ES5 code bases:
 * Converts JSDoc to [TSDoc](https://github.com/microsoft/tsdoc)
 * Only exposed documented parameters
 * Validates, where needed declared parameters
+* Supports [declaration maps](https://www.typescriptlang.org/tsconfig/#declarationMap)
 
 Checkout the [test fixtures](./test/fixtures) for full coverage.
 
@@ -46,11 +47,11 @@ import * as typescript from 'typescript';
 // transform JS so it keeps the shape,
 // but is properly digestable by the typescript
 // compiler
-const transformedCode = preTransform(jsCode);
+const { code } = preTransform(jsCode);
 
 // post process typescript compiler type code
 // removing internals, and fixing up the definitions
-const transformedCode = postTransform(tsCode);
+const { code } = postTransform(tsCode);
 
 // execute the full pipeline, including invoking the
 // typescript compiler

package/bin/cmd.js

@@ -9,6 +9,7 @@ import os from 'node:os';
 import fs from 'node:fs';
 
 import generateTypes from '../lib/generate-types.js';
+import { readTsConfigOptions } from '../lib/tsconfig.js';
 
 async function run() {
 
@@ -63,14 +64,18 @@ async function run() {
 
   console.log(`Generating types for ${files.length} files...`);
 
+  const tsConfigOptions = readTsConfigOptions(ts);
+
   const generateOptions = {
     allowJs: true,
     declaration: true,
     emitDeclarationOnly: true,
+    ...tsConfigOptions,
     ...options,
     verbose
   };
 
+  verbose && Object.keys(tsConfigOptions).length && console.log('Using tsconfig options', tsConfigOptions);
   verbose && console.log('Using options ', generateOptions);
 
   const {

package/lib/generate-types.js

@@ -4,10 +4,23 @@ import preTransform from './pre-transform.js';
 
 import postTransform from './post-transform.js';
 
+import remapping from '@jridgewell/remapping';
+
+
 /**
+ * @typedef { import('typescript').CompilerHost } CompilerHost
+ * @typedef { import('typescript').WriteFileCallback } WriteFileCallback
+ *
+ * @typedef { {
+ *   _readFile: (fileName: string) => string,
+ *   _writeFile: WriteFileCallback,
+ *   ___cache: Record<string, string>
+ * } } CompilerHostExtension
+ *
  * @typedef { import('typescript').CompilerOptions } CompilerOptions
  * @typedef { import('typescript').createCompilerHost } createCompilerHost
  * @typedef { import('typescript').createProgram } createProgram
+ *
  * @typedef { {
  *   createCompilerHost: createCompilerHost,
  *   createProgram: createProgram
@@ -18,7 +31,7 @@ import postTransform from './post-transform.js';
  * @param { string[] } fileNames
  * @param { CompilerOptions } compilerOptions
  * @param { TypeScript } ts
- * @param { { lax: boolean } } generateOptions
+ * @param { { lax?: boolean } } [generateOptions]
  */
 export default function generateTypes(fileNames, compilerOptions, ts, generateOptions) {
 
@@ -29,13 +42,19 @@ export default function generateTypes(fileNames, compilerOptions, ts, generateOp
   // CompilerOptions.JsxEmit.None = 0
   const jsx = compilerOptions.jsx !== 0;
 
+  const declarationMap = compilerOptions.declarationMap;
+  const sourceRoot = compilerOptions.sourceRoot;
+
   const names = new Set(fileNames.map((p) => path.resolve(p)));
 
-  const host = ts.createCompilerHost(compilerOptions);
+  const host = /** @type { CompilerHost & CompilerHostExtension } */ (
+    ts.createCompilerHost(compilerOptions)
+  );
 
-  // @ts-expect-error
   host._readFile = host.readFile;
 
+  host.___cache = {};
+
   /**
    * @param {string} fileName
    *
@@ -43,44 +62,121 @@ export default function generateTypes(fileNames, compilerOptions, ts, generateOp
    */
   host.readFile = (fileName) => {
 
-    // @ts-expect-error
     let src = host._readFile(fileName);
 
     if (names.has(path.resolve(fileName))) {
       isVerbose(compilerOptions, fileName) && console.debug('[generate-types] [pre]', fileName, src);
 
       try {
-        src = preTransform(src, { jsx });
+
+        const sourceMapOptions = declarationMap ? {
+          sourceFileName: fileName,
+          sourceMapName: fileName + '___pre',
+          sourceRoot
+        } : {};
+
+        const transformed = preTransform(src, {
+          ...sourceMapOptions,
+          jsx
+        });
+
+        if (transformed.map) {
+          host.___cache[fileName + '___pre'] = JSON.stringify(transformed.map);
+        }
+
+        src = transformed.code;
+
+        isVerbose(compilerOptions, fileName) && console.debug('[generate-types] [pre] [generated]', fileName, src);
       } catch (err) {
         console.error(`[generate-types] [pre] failed to parse ${fileName} with contents ${src}`, err);
         throw err;
       }
 
-      isVerbose(compilerOptions, fileName) && console.debug('[generate-types] [pre] [generated]', fileName, src);
     }
 
     return src;
   };
 
-  // @ts-expect-error
   host._writeFile = host.writeFile;
 
-  host.writeFile = (fileName, text, ...args) => {
-    isVerbose(compilerOptions, fileName) && console.debug('[generate-types] [post]', fileName, text);
+  host.writeFile = (fileName, text, writeByteOrderMark, onError, sourceFiles, ...args) => {
+
+    const [ sourceFile ] = sourceFiles;
+
+    const originalFileName = /** @type {string|null} */ (
+      'originalFileName' in sourceFile && sourceFile.originalFileName || null
+    );
+
+    if (fileName.toLowerCase().endsWith('.d.ts.map')) {
+
+      if (originalFileName) {
+        host.___cache[originalFileName + '___ts'] = text;
+      }
+
+      return;
+    }
 
     if (fileName.toLowerCase().endsWith('.d.ts')) {
+
+      isVerbose(compilerOptions, fileName) && console.debug('[generate-types] [post]', fileName, text);
+
       try {
-        text = postTransform(text, generateOptions);
+        const sourceMap_pre_json = host.___cache[originalFileName + '___pre'];
+        const sourceMap_ts_json = host.___cache[originalFileName + '___ts'];
+
+        const sourceMapOptions = sourceMap_pre_json && sourceMap_ts_json && {
+          sourceFileName: fileName + '___ts',
+          sourceMapName: fileName,
+          sourceRoot
+        } || {};
+
+        const transformed = postTransform(text, {
+          ...sourceMapOptions,
+          ...generateOptions
+        });
+
+        if (transformed.map) {
+          const sourceMap_pre = JSON.parse(sourceMap_pre_json);
+          const sourceMap_ts = JSON.parse(sourceMap_ts_json);
+          const sourceMap_post = transformed.map;
+
+          const combined = remapping(
+            [
+              sourceMap_post,
+              sourceMap_ts,
+              sourceMap_pre
+            ],
+            () => null
+          );
+
+          const combinedJSON = JSON.parse(JSON.stringify(combined));
+
+          // produce source maps with relative paths to sources,
+          // following typescript conventions
+          if (combinedJSON.sources) {
+            const mapDir = path.dirname(path.resolve(fileName));
+            combinedJSON.sources = combinedJSON.sources.map(src =>
+              path.relative(mapDir, path.resolve(src))
+            );
+          }
+
+          // keep maps small, do not inline source text in declaration maps
+          delete combinedJSON.sourcesContent;
+
+          host._writeFile(fileName + '.map', JSON.stringify(combinedJSON), writeByteOrderMark, onError, sourceFiles, ...args);
+        }
+
+        text = transformed.code;
+
+        isVerbose(compilerOptions, fileName) && console.debug('[generate-types] [post] [generated]', fileName, text);
       } catch (err) {
         console.error(`[generate-types] [post] failed to parse ${fileName} with contents ${text}`, err);
         throw err;
       }
 
-      isVerbose(compilerOptions, fileName) && console.debug('[generate-types] [post] [generated]', fileName, text);
     }
 
-    // @ts-expect-error
-    host._writeFile(fileName, text, ...args);
+    host._writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, ...args);
   };
 
   const program = ts.createProgram(fileNames, compilerOptions, host);

package/lib/post-transform.js

@@ -15,6 +15,12 @@ import {
  * @typedef { import('./util.js').Path<T> } Path
  */
 
+/**
+ * @typedef { import('./util.js').ParseOptions } ParseOptions
+ *
+ * @typedef { { lax?: boolean } & ParseOptions } TransformOptions
+ */
+
 /**
  * @param { { name: string, key?: { name?: string }, comments?: any[] } } m
  *
@@ -35,17 +41,18 @@ function isPublic(m) {
 
 /**
  * @param { string } src
- * @param { { lax: boolean } } [options]
+ * @param { TransformOptions } [transformOptions]
  *
- * @return { string }
+ * @return { import('./util.js').PrintResult }
  */
-export default function transform(src, options) {
+export default function transform(src, transformOptions = {}) {
 
   const {
-    lax = false
-  } = options || {};
+    lax = false,
+    ...parseOptions
+  } = transformOptions;
 
-  const ast = parseDts(src);
+  const ast = parseDts(src, parseOptions);
   const body = path(ast).get('program', 'body');
 
   const replacements = [];
@@ -627,7 +634,7 @@ declare function p${
     }
   }
 
-  return print(ast).code;
+  return print(ast, parseOptions);
 }
 
 function traverse(path, cb) {

package/lib/pre-transform.js

@@ -1,10 +1,32 @@
 import { matcher, parse, path, print } from './util.js';
 
+import { SourceMapConsumer, SourceMapGenerator } from '@jridgewell/source-map';
+
 /**
  * @template T
  * @typedef { import('./util.js').Path<T> } Path
  */
 
+/**
+ * @typedef { import('ast-types/lib/gen/kinds').PrintableKind } WithLocation
+ */
+
+/**
+ * @typedef { import('./util.js').ParseOptions } ParseOptions
+ *
+ * @typedef { { jsx?: boolean } & ParseOptions } TransformOptions
+ */
+
+
+/**
+ * @typedef { import('recast').types.namedTypes.ClassMethod } ClassMethod
+ * @typedef { import('recast').types.namedTypes.ClassDeclaration } ClassDeclaration
+ */
+
+/**
+ * @typedef { import('ast-types').ASTNode } ASTNode
+ */
+
 import {
   parse as parseJSDoc
 } from './parsers/jsdoc.js';
@@ -15,32 +37,39 @@ import {
 
 function superCall() {
   return b.expressionStatement.from({
-    'expression': {
-      'type': 'CallExpression',
-      'callee': {
-        'type': 'Super'
-      },
-      'arguments': []
-    }
+    expression: b.callExpression.from({
+      callee: b.super(),
+      arguments: []
+    })
   });
 }
 
+/**
+ * @return { ClassMethod }
+ */
 function clazzConstructor(cls, comments) {
   const constructor = cls.ctor.value;
 
   return b.classMethod.from({
-    'static': false,
-    'key': {
-      'type': 'Identifier',
-      'name': 'constructor'
-    },
-    'kind': 'constructor',
-    'params': constructor.params,
-    'body': constructor.body,
-    'comments': comments
+    static: false,
+    key: b.identifier.from({
+      name: 'constructor',
+      loc: cls.identifier.loc
+    }),
+    kind: 'constructor',
+    params: constructor.params,
+    body: constructor.body,
+    comments,
+    loc: constructor.loc
   });
 }
 
+/**
+ * @param { any } cls
+ * @param { ClassMethod } ctor
+ *
+ * @return { ClassDeclaration }
+ */
 function clazzDefinition(cls, ctor) {
 
   const members = [
@@ -49,79 +78,63 @@ function clazzDefinition(cls, ctor) {
 
       // class method
       if (m.member.type === 'FunctionExpression') {
-        return {
-          'type': 'ClassMethod',
-          'static': false,
-          'key': {
-            'type': 'Identifier',
-            'name': m.name
-          },
-          'kind': 'method',
-          'params': m.member.params,
-          'body': m.member.body,
-          'comments': m.comments
-        };
+        return b.classMethod.from({
+          static: false,
+          key: m.identifier,
+          kind: 'method',
+          async: m.member.async || false,
+          params: m.member.params,
+          body: m.member.body,
+          comments: m.comments || null,
+          loc: m.member.loc
+        });
       }
 
       // save to transform into class property
-      return {
-        'type': 'ClassProperty',
-        'static': false,
-        'key': {
-          'type': 'Identifier',
-          'name': m.name
-        },
-        'value': m.member,
-        'comments': m.comments
-      };
+      return b.classProperty.from({
+        static: false,
+        key: m.identifier,
+        value: m.member,
+        comments: m.comments || null,
+        loc: m.member.loc
+      });
     })
   ];
 
   const staticMembers = cls.staticMembers.map(m => {
 
     if (m.member.type === 'FunctionExpression') {
-      return {
-        'type': 'ClassMethod',
-        'static': true,
-        'key': {
-          'type': 'Identifier',
-          'name': m.name
-        },
-        'kind': 'method',
-        'params': m.member.params,
-        'body': m.member.body,
-        'comments': m.comments
-      };
+      return b.classMethod.from({
+        static: true,
+        key: m.identifier,
+        kind: 'method',
+        async: m.member.async || false,
+        params: m.member.params,
+        body: m.member.body,
+        comments: m.comments || null,
+        loc: m.member.loc
+      });
     }
 
-    return {
-      'type': 'ClassProperty',
-      'static': true,
-      'key': {
-        'type': 'Identifier',
-        'name': m.name
-      },
-      'value': m.member,
-      'comments': m.comments
-    };
+    return b.classProperty.from({
+      static: true,
+      key: m.identifier,
+      value: m.member,
+      comments: m.comments || null,
+      loc: m.member.loc
+    });
   });
 
   return b.classDeclaration.from({
-    'id': {
-      'type': 'Identifier',
-      'name': cls.name
-    },
-    'superClass': cls.superDeclaration ? {
-      'type': 'Identifier',
-      'name': cls.superDeclaration.clazz
-    } : null,
-    'body': {
-      'type': 'ClassBody',
-      'body': [
+    id: cls.identifier,
+    superClass: cls.superDeclaration ? cls.superDeclaration.clazz : null,
+    body: b.classBody.from({
+      body: [
         ...members,
         ...staticMembers
       ]
-    }
+    }),
+    loc: cls.node.value.loc
   });
 }
 
@@ -136,21 +149,23 @@ function splitComment(cls) {
   const [ intro, ...rest ] = comment?.value?.split(/\* @param/) || [];
 
   return {
-    ctorComments: rest.length ? [ {
-      leading: true,
-      trailing: false,
-      type: 'CommentBlock',
-      value: '*\n * @param' + rest.join('* @param'),
-    } ] : [],
+    ctorComments: rest.length ? [
+      b.commentBlock.from({
+        leading: true,
+        trailing: false,
+        value: '*\n * @param' + rest.join('* @param'),
+        loc: comment.loc
+      })
+    ] : [],
     additionalComments: [
       ...additionalComments,
       ...(
         intro ? [
-          {
+          b.commentBlock.from({
             leading: true,
-            type: 'CommentBlock',
-            value: intro
-          }
+            value: intro,
+            loc: comment.loc
+          })
         ] : []
       )
     ]
@@ -159,13 +174,25 @@ function splitComment(cls) {
 
 /**
  * @param { string } src
- * @param { { jsx?: boolean } } [parseOptions]
+ * @param { TransformOptions } [transformOptions]
  *
- * @return {string}
+ * @return { import('./util.js').PrintResult }
  */
-export default function transform(src, parseOptions = {}) {
+export default function transform(src, transformOptions = {}) {
+
+  const {
+    jsx,
+    ...parseOptions
+  } = transformOptions;
+
+  /**
+   * @type { ASTNode }
+   */
+  const ast = parse(src, transformOptions);
 
-  const ast = parse(src, parseOptions);
+  /**
+   * @type {Path<ASTNode[]>}
+   */
   const body = path(ast).get('program', 'body');
 
   const inheritsImports = findInheritsImports(body);
@@ -229,9 +256,115 @@ export default function transform(src, parseOptions = {}) {
 
   inheritsImports.forEach(m => m.node.replace());
 
-  return print(ast).code;
+  const {
+    code,
+    map
+  } = print(ast, parseOptions);
+
+  if (!map) {
+    return {
+      code
+    };
+  } else {
+
+    // source maps are broken through function -> class transformation
+    // we have to manually fix them
+    const generatedAst = parse(code, transformOptions);
+
+    return {
+      code,
+      map: fixSourceMap(generatedAst, map, classes)
+    };
+  }
 }
 
+
+/**
+ * @param {ASTNode} generatedAst
+ * @param {any} map
+ * @param {any} originalClasses
+ *
+ * @return {any} fixed map
+ */
+function fixSourceMap(generatedAst, map, originalClasses) {
+
+  /**
+   * @type {Path<ASTNode[]>}
+   */
+  const body = path(generatedAst).get('program', 'body');
+
+  const consumer = new SourceMapConsumer(map);
+
+  const source = consumer.sources[0];
+
+  const generator = SourceMapGenerator.fromSourceMap(consumer);
+
+  for (const originalCls of originalClasses) {
+
+    const clsName = originalCls.identifier.name;
+
+    // add mappings for classes and their constructors
+    // back to the original function
+    const generatedCls = findClass(body, clsName);
+
+    const generatedCtor = findClassCtor(generatedCls.clsDeclaration);
+
+    // add mapping from class constructor to original fn
+    generator.addMapping({
+      generated: {
+        line: generatedCtor.value.loc.start.line,
+        column: generatedCtor.value.loc.start.column,
+      },
+      name: `${clsName} constructor`,
+      source,
+      original: {
+        line: originalCls.loc.start.line,
+        column: originalCls.loc.start.column
+      }
+    });
+
+    // add mapping from class to original fn
+    generator.addMapping({
+      generated: {
+        line: generatedCls.node.value.loc.start.line,
+        column: generatedCls.node.value.loc.start.column,
+      },
+      name: `${clsName} class`,
+      source,
+      original: {
+        line: originalCls.loc.start.line,
+        column: originalCls.loc.start.column
+      }
+    });
+
+    // add mapping for static members
+    for (const originalMember of originalCls.staticMembers) {
+
+      const name = originalMember.identifier.name;
+
+      const generatedMember = findStaticMember(generatedCls.clsDeclaration, name);
+
+      // add mapping from member to original
+      generator.addMapping({
+        generated: {
+          line: generatedMember.value.loc.start.line,
+          column: generatedMember.value.loc.start.column,
+        },
+        name: `${clsName}#${name}`,
+        source,
+        original: {
+          line: originalMember.loc.start.line,
+          column: originalMember.loc.start.column
+        }
+      });
+    }
+  }
+
+
+  return generator.toJSON();
+}
+
+
 function findInheritsImports(nodes) {
   const importsMatches = matcher`
     import $1 from 'inherits-browser';
@@ -261,14 +394,14 @@ function findSuperDeclarations(cls, nodes, importDeclarations) {
 
     if (inheritsExpressions.length === 1) {
 
-      const clazz = inheritsExpressions[0][1].value.name;
+      const clazz = inheritsExpressions[0][1].value;
 
       const inheritsExpression = {
         node: inheritsExpressions[0][0]
       };
 
       const superCallMatches = matcher`
-        ${clazz}.call($$$);
+        ${clazz.name}.call($$$);
       `;
 
       const superCalls = superCallMatches(cls.ctor.get('body', 'body'));
@@ -284,12 +417,14 @@ function findSuperDeclarations(cls, nodes, importDeclarations) {
 }
 
 /**
- * @param {any[]} nodes
+ * @param {Path<ASTNode[]>} nodes
  *
  * @return { {
- *   name: string,
+ *   identifier: any,
  *   ctor: any,
- *   node: any
+ *   node: any,
+ *   name: string,
+ *   loc: any
  * }[] }
  */
 function findConstructors(nodes) {
@@ -335,14 +470,111 @@ function findConstructors(nodes) {
     if (isClassName(name) && !isFunctionTagged(node) && !isReturning(ctor)) {
 
       return {
+        identifier: identifier.value,
         name,
         ctor,
-        node
+        node,
+        loc: node.value.loc
       };
     }
   }).filter(n => n);
 }
 
+/**
+ * @param { Path<ASTNode> } clsNode
+ *
+ * @return { Path<ASTNode & WithLocation> }
+ */
+function findClassCtor(clsNode) {
+
+  const ctors = clsNode.get('body', 'body').filter(node => {
+    const value = node.value;
+
+    return value.type === 'ClassMethod' && value.key?.name === 'constructor';
+  });
+
+  if (!ctors.length) {
+    throw new Error('no constructor');
+  }
+
+  return ctors[0];
+}
+
+/**
+ * @param { Path<ASTNode> } clsNode
+ * @param { string } name
+ *
+ * @return { Path<ASTNode & WithLocation> }> }
+ */
+function findStaticMember(clsNode, name) {
+
+  const members = clsNode.get('body', 'body').filter(node => {
+    const value = node.value;
+
+    return [ 'ClassProperty', 'ClassMethod' ].includes(value.type) && value.static && value.key?.name === name;
+  });
+
+  if (!members.length) {
+    throw new Error(`no member ${name}`);
+  }
+
+  return members[0];
+}
+
+/**
+ * @param { Path<ASTNode[]> } nodes
+ * @param { string } name
+ *
+ * @return { {
+ *   clsDeclaration: any,
+ *   node: any
+ * } }
+ */
+function findClass(nodes, name) {
+
+  const cls = matcher`
+    class ${name} extends $$$ {
+      $$$
+    }
+  `;
+
+  const namedExportCls = matcher`
+    export class ${name} extends $$$ {
+      $$$
+    }
+  `;
+
+  const defaultExportCls = matcher`
+    export default class ${name} extends $$$ {
+      $$$
+    }
+  `;
+
+  const matches = [
+    ...cls(nodes),
+    ...namedExportCls(nodes).map(
+      m => [ m[0].get('declaration'), m[0] ]
+    ),
+    ...defaultExportCls(nodes).map(
+      m => [ m[0].get('declaration'), m[0] ]
+    )
+  ].map(match => {
+
+    const [ clsDeclaration, node = clsDeclaration ] = match;
+
+    return {
+      clsDeclaration,
+      node
+    };
+  });
+
+  if (!matches.length) {
+    throw new Error(`not found: class ${name}`);
+  }
+
+  return matches[0];
+}
+
 /**
  * @param { string } name
  *
@@ -389,6 +621,10 @@ function isReturning(ctorPath) {
   return returnStatements(ctorPath.get('body', 'body')).length > 0;
 }
 
+/**
+ * @param {any} cls
+ * @param {Path<ASTNode[]>} nodes
+ */
 function findStaticMembers(cls, nodes) {
 
   const names = matcher`
@@ -399,14 +635,19 @@ function findStaticMembers(cls, nodes) {
     const [ node, identifier, member ] = match;
 
     return {
-      name: identifier.value.name,
+      identifier: identifier.value,
       member: member.value,
       comments: node.get('comments').value,
-      node
+      node,
+      loc: node.value.loc
     };
   });
 }
 
+/**
+ * @param {any} cls
+ * @param {Path<ASTNode[]>} nodes
+ */
 function findProtoMembers(cls, nodes) {
 
   const names = matcher`
@@ -417,7 +658,7 @@ function findProtoMembers(cls, nodes) {
     const [ node, identifier, member ] = match;
 
     return {
-      name: identifier.value.name,
+      identifier: identifier.value,
       member: member.value,
       comments: node.get('comments').value,
       node,
@@ -426,6 +667,9 @@ function findProtoMembers(cls, nodes) {
   });
 }
 
+/**
+ * @param {any} cls
+ */
 function findEmbeddedMembers(cls) {
 
   const memberDeclarations = matcher`
@@ -436,7 +680,7 @@ function findEmbeddedMembers(cls) {
     const [ node, identifier, member ] = match;
 
     return {
-      name: identifier.value.name,
+      identifier: identifier.value,
       member: member.value,
       comments: node.get('comments').value,
       node,

package/lib/tsconfig.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+
+/**
+ * Read ESM-relevant compiler options from the nearest tsconfig.json,
+ * starting from `cwd`.
+ *
+ * Options are sourced selectively: only `module`, `moduleResolution`, and
+ * `target` are returned because these affect how declarations are generated.
+ * Other options (strict, lib, paths, …) are not meaningful here.
+ *
+ * @param { import('typescript') } ts
+ * @param { string } [cwd]
+ *
+ * @return { Partial<import('typescript').CompilerOptions> }
+ */
+export function readTsConfigOptions(ts, cwd = process.cwd()) {
+
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists);
+
+  if (!configPath) {
+    return {};
+  }
+
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+
+  if (configFile.error) {
+    return {};
+  }
+
+  const { options } = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    path.dirname(configPath)
+  );
+
+  const result = /** @type { Partial<import('typescript').CompilerOptions> } */ ({});
+
+  if (options.module !== undefined) result.module = options.module;
+  if (options.moduleResolution !== undefined) result.moduleResolution = options.moduleResolution;
+  if (options.target !== undefined) result.target = options.target;
+
+  return result;
+}

package/lib/util.js

@@ -6,8 +6,22 @@ import { Path as PathConstructor } from 'ast-types';
  * @typedef { import('ast-types/lib/path.js').Path<T> } Path
  */
 
+/**
+ * @typedef { import('recast/lib/printer.js').PrintResultType } PrintResult
+ */
+
+/**
+ * @typedef { {
+ *  inputSourceMap?: string,
+ *  sourceFileName?: string,
+ *  sourceMapName?: string,
+ *  sourceRoot?: string,
+ * } } ParseOptions
+ */
+
 import * as typescriptParser from './parsers/typescript.js';
 
+
 const DBG = /match/.test(process?.env?.LOG_DEBUG);
 
 const formatOptions = {
@@ -50,22 +64,35 @@ export function hasProperty(obj, property) {
 
 /**
  * @param { string } code
- * @param { { jsx?: boolean } } [parseOptions]
+ * @param { ParseOptions & { jsx?: boolean } } [parseOptions]
  *
  * @return {any}
  */
-export function parse(code, parseOptions) {
+export function parse(code, parseOptions = {}) {
+
+  const {
+    jsx = false,
+    ...options
+  } = parseOptions;
+
   const parser = {
-    parse: parseOptions?.jsx ? typescriptParser.jsx : typescriptParser.js
+    parse: jsx ? typescriptParser.jsx : typescriptParser.js
   };
 
   return recastParse(code, {
     parser,
-    ...formatOptions
+    ...formatOptions,
+    ...options
   });
 }
 
-export function parseDts(code) {
+/**
+ * @param { string } code
+ * @param { ParseOptions } [options]
+ *
+ * @return { any }
+ */
+export function parseDts(code, options = {}) {
 
   const parser = {
     parse: typescriptParser.dts
@@ -73,12 +100,22 @@ export function parseDts(code) {
 
   return recastParse(code, {
     parser,
-    ...formatOptions
+    ...formatOptions,
+    ...options
   });
 }
 
-export function print(node) {
-  return recastPrint(node, formatOptions);
+/**
+ * @param { any } node
+ * @param { ParseOptions } [options]
+ *
+ * @return { PrintResult }
+ */
+export function print(node, options = {}) {
+  return recastPrint(node, {
+    ...formatOptions,
+    ...options
+  });
 }
 
 /**
@@ -139,6 +176,10 @@ export function matcher(strings, ...args) {
       node = node[0];
     }
 
+    if (node && node.type === 'ClassProperty') {
+      node = node.key;
+    }
+
     if (node && node.type === 'ExpressionStatement') {
       node = node.expression;
     }
@@ -182,6 +223,10 @@ export function matcher(strings, ...args) {
       node = node[0];
     }
 
+    if (node && node.type === 'ClassProperty') {
+      node = node.key;
+    }
+
     if (node && node.type === 'ExpressionStatement') {
       node = node.expression;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bio-dts",
-  "version": "0.14.1",
+  "version": "0.15.1",
   "description": "Generate sane and clean types from JavaScript sources",
   "type": "module",
   "bin": "./bin/cmd.js",
@@ -11,14 +11,16 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "all": "run-s lint check-types test test:dts:*",
+    "all": "run-s lint check-types test test:dts",
     "lint": "eslint .",
     "check-types": "tsc --noEmit",
     "test": "mocha test",
-    "test:dts:default": "node bin/cmd.js --outDir test/fixtures/snapshots/default -r test/fixtures/pre",
-    "test:dts:jsx": "node bin/cmd.js --jsx preserve --outDir test/fixtures/snapshots/jsx -r test/fixtures/jsx",
-    "test:dts:declaration-map": "node bin/cmd.js --declarationMap --outDir test/fixtures/snapshots/declaration-map -r test/fixtures/pre",
-    "test:dts:lax": "node bin/cmd.js --declarationMap --lax --outDir test/fixtures/snapshots/lax -r test/fixtures/lax"
+    "test:dts": "run-s test:dts:*",
+    "test:dts:default": "node bin/cmd.js --module CommonJS --outDir test/fixtures/snapshots/default -r test/fixtures/pre",
+    "test:dts:jsx": "node bin/cmd.js --module CommonJS --jsx preserve --outDir test/fixtures/snapshots/jsx -r test/fixtures/jsx",
+    "test:dts:declaration-map": "node bin/cmd.js --module CommonJS --declarationMap --outDir test/fixtures/snapshots/declaration-map -r test/fixtures/pre",
+    "test:dts:lax": "node bin/cmd.js --module CommonJS --declarationMap --lax --outDir test/fixtures/snapshots/lax -r test/fixtures/lax",
+    "test:dts:esm": "node bin/cmd.js --outDir test/fixtures/snapshots/esm -r test/fixtures/esm"
   },
   "repository": {
     "type": "git",
@@ -27,19 +29,21 @@
   "author": "Nico Rehwaldt",
   "license": "MIT",
   "dependencies": {
-    "@babel/parser": "^7.28.5",
+    "@babel/parser": "^7.29.7",
+    "@jridgewell/remapping": "^2.3.5",
+    "@jridgewell/source-map": "^0.3.11",
     "recast": "^0.23.11",
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
-    "@babel/types": "^7.28.5",
+    "@babel/types": "^7.29.7",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.10.4",
-    "chai": "^6.2.1",
-    "eslint": "^8.56.0",
-    "eslint-plugin-bpmn-io": "^1.0.0",
-    "mocha": "^11.7.5",
-    "npm-run-all2": "^8.0.4",
+    "@types/node": "^24.13.0",
+    "chai": "^6.2.2",
+    "eslint": "^9.39.4",
+    "eslint-plugin-bpmn-io": "^2.3.1",
+    "mocha": "^11.7.6",
+    "npm-run-all2": "^9.0.1",
     "typescript": "^5.9.3"
   },
   "sideEffects": false,