generate .js.mjs and .js.d.mts files

Author: phryneas

resources/build-npm.js

@@ -13,6 +13,14 @@ const {
   showDirStats,
 } = require('./utils.js');
 
+const entryPoints = [
+  'index.ts',
+  'execution/execute.ts',
+  'jsutils/instanceOf.ts',
+  'language/parser.ts',
+  'language/ast.ts',
+];
+
 if (require.main === module) {
   fs.rmSync('./npmDist', { recursive: true, force: true });
   fs.mkdirSync('./npmDist');
@@ -57,11 +65,21 @@ if (require.main === module) {
 
   const tsProgram = ts.createProgram(['src/index.ts'], tsOptions, tsHost);
   const tsResult = tsProgram.emit();
+
   assert(
     !tsResult.emitSkipped,
     'Fail to generate `*.d.ts` files, please run `npm run check`',
   );
 
+  for (const [filename, contents] of Object.entries(
+    buildCjsEsmWrapper(
+      entryPoints.map((e) => './src/' + e),
+      tsProgram,
+    ),
+  )) {
+    writeGeneratedFile(filename, contents);
+  }
+
   assert(packageJSON.types === undefined, 'Unexpected "types" in package.json');
   const supportedTSVersions = Object.keys(packageJSON.typesVersions);
   assert(
@@ -137,3 +155,130 @@ function buildPackageJSON() {
 
   return packageJSON;
 }
+
+/**
+ *
+ * @param {string[]} files
+ * @param {ts.Program} tsProgram
+ * @returns
+ */
+function buildCjsEsmWrapper(files, tsProgram) {
+  /**
+   * @type {Record<string, string>} inputFiles
+   */
+  const inputFiles = {};
+  for (const file of files) {
+    const sourceFile = tsProgram.getSourceFile(file);
+    assert(sourceFile, `No source file found for ${file}`);
+
+    const generatedFileName = path.relative(
+      path.dirname(tsProgram.getRootFileNames()[0]),
+      file.replace(/\.ts$/, '.js.mts'),
+    );
+    const exportFrom = ts.factory.createStringLiteral(
+      './' + path.basename(file, '.ts') + '.js',
+    );
+
+    /**
+     * @type {ts.Statement[]}
+     */
+    const statements = [];
+
+    /** @type {string[]} */
+    const exports = [];
+
+    /** @type {string[]} */
+    const typeExports = [];
+
+    sourceFile.forEachChild((node) => {
+      if (ts.isExportDeclaration(node)) {
+        if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+          for (const element of node.exportClause.elements) {
+            if (node.isTypeOnly || element.isTypeOnly) {
+              typeExports.push(element.name.text);
+            } else {
+              exports.push(element.name.text);
+            }
+          }
+        }
+      } else if (
+        node.modifiers?.some(
+          (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+        )
+      ) {
+        if (ts.isVariableStatement(node)) {
+          for (const declaration of node.declarationList.declarations) {
+            if (declaration.name && ts.isIdentifier(declaration.name)) {
+              exports.push(declaration.name.text);
+            }
+          }
+        } else if (
+          ts.isFunctionDeclaration(node) ||
+          ts.isClassDeclaration(node)
+        ) {
+          exports.push(node.name.text);
+        } else if (ts.isTypeAliasDeclaration(node)) {
+          typeExports.push(node.name.text);
+        }
+      }
+    });
+    if (exports.length > 0) {
+      statements.push(
+        ts.factory.createExportDeclaration(
+          undefined,
+          undefined,
+          false,
+          ts.factory.createNamedExports(
+            exports.map((name) =>
+              ts.factory.createExportSpecifier(false, undefined, name),
+            ),
+          ),
+          exportFrom,
+        ),
+      );
+    }
+    if (typeExports.length > 0) {
+      statements.push(
+        ts.factory.createExportDeclaration(
+          undefined,
+          undefined,
+          true,
+          ts.factory.createNamedExports(
+            typeExports.map((name) =>
+              ts.factory.createExportSpecifier(false, undefined, name),
+            ),
+          ),
+          exportFrom,
+        ),
+      );
+    }
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    inputFiles[generatedFileName] = printer.printFile(
+      ts.factory.createSourceFile(
+        statements,
+        ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
+        ts.NodeFlags.None,
+      ),
+    );
+  }
+  /**
+   * @type {ts.CompilerOptions} options
+   */
+  const options = {
+    ...tsProgram.getCompilerOptions(),
+    declaration: true,
+    emitDeclarationOnly: false,
+    isolatedModules: true,
+    module: ts.ModuleKind.ESNext,
+  };
+  options.outDir = options.declarationDir;
+  const results = {};
+  const host = ts.createCompilerHost(options);
+  host.writeFile = (fileName, contents) => (results[fileName] = contents);
+  host.readFile = (fileName) => inputFiles[fileName];
+
+  const program = ts.createProgram(Object.keys(inputFiles), options, host);
+  program.emit();
+
+  return results;
+}