codegen-index-mjs.mts

#!/usr/bin/env bun

import { readFileSync, writeFileSync } from "node:fs"
import * as path from "node:path"
import * as ts from "typescript"
import { fileURLToPath } from "node:url"

const __filename = fileURLToPath(import.meta.url)
const __dirname = path.dirname(__filename)
const repoRoot = path.resolve(__dirname, "..")
const declarationsPath = path.join(repoRoot, "index.d.ts")
const outputPath = path.join(repoRoot, "index.mjs")

export function generateIndexMjs(): void {
  const sourceText = readFileSync(declarationsPath, "utf8")
  const sourceFile = ts.createSourceFile(declarationsPath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
  const exportNames = getRuntimeExportNames(sourceFile)

  if (exportNames.length === 0) {
    throw new Error(`expected ${path.relative(repoRoot, declarationsPath)} to declare at least one runtime export`)
  }

  const output = [
    "// Generated from index.d.ts by scripts/codegen-index-mjs.mts. Do not edit.",
    'import { createRequire } from "node:module"',
    "",
    "const require = createRequire(import.meta.url)",
    'const binding = require("./index.js")',
    "",
    ...exportNames.map((name) => `export const ${name} = binding.${name}`),
    "",
  ].join("\n")

  writeFileSync(outputPath, output)
}

function getRuntimeExportNames(sourceFile: ts.SourceFile): string[] {
  const names: string[] = []

  for (const statement of sourceFile.statements) {
    if (!hasExportModifier(statement)) {
      continue
    }

    if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) {
      if (statement.name) {
        names.push(statement.name.text)
      }

      continue
    }

    if (ts.isVariableStatement(statement)) {
      for (const declaration of statement.declarationList.declarations) {
        collectBindingNames(declaration.name, names)
      }
    }
  }

  return names
}

function hasExportModifier(node: ts.Node): boolean {
  if (!ts.canHaveModifiers(node)) {
    return false
  }

  return ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false
}

function collectBindingNames(name: ts.BindingName, names: string[]): void {
  if (ts.isIdentifier(name)) {
    names.push(name.text)
    return
  }

  for (const element of name.elements) {
    if (ts.isBindingElement(element)) {
      collectBindingNames(element.name, names)
    }
  }
}

if (path.resolve(process.argv[1] ?? "") === __filename) {
  generateIndexMjs()
}