cli.js

#!/usr/bin/env node

import { program } from "commander";
import { existsSync, readFileSync, writeFileSync } from "fs";
import * as path from "path";
import ts from "typescript";

const dtsFiles = [
  "node_modules/typescript/lib/lib.dom.d.ts",
  "node_modules/@types/node/web-globals/events.d.ts",
  "node_modules/undici-types/eventsource.d.ts",
  "node_modules/undici-types/websocket.d.ts",
];

program
  .name("easyAddEventListener parser")
  .description("Parses TS files in order to obtain addEventListener signatures")
  .argument(
    "[files...]",
    `Files to parse (default: ${JSON.stringify(dtsFiles, null, 2)})`
  )
  .option("-o,--output <dir>", "Output dir", process.cwd())
  .option(
    "--patch",
    "Patch input files with `addEventListener(): VoidFunction`",
    false
  )
  .parse();
const { output: outputDir, patch } = program.opts();
const files = program.args.length
  ? program.args
  : dtsFiles
      .map((file) => path.resolve(process.cwd(), file))
      .filter((file) => existsSync(file));

if (!files) {
  program.error("Files not found");
}

const sourceFiles = files.map((file) =>
  ts.createSourceFile(
    file,
    readFileSync(file).toString(),
    ts.ScriptTarget.Latest
  )
);

/**
 * @type {{ node: ts.InterfaceDeclaration, signatures: ts.MethodSignature[], type: string, eventMap: string, ancestors: string[] }[]}
 */
const nodes = [];
sourceFiles.forEach((sourceFile) => {
  ts.forEachChild(sourceFile, (child) => visit(child, sourceFile));
});

const condition = nodes
  .filter(({ eventMap }) => !!eventMap)
  // Sort so that the condition is correct for subclasses
  .sort((a, b) =>
    b.ancestors.includes(a.type)
      ? 1
      : a.ancestors.includes(b.type)
      ? -1
      : b.ancestors.length - a.ancestors.length
  )
  .map(({ type, eventMap }) => `T extends ${type} ? ${eventMap} : `)
  .concat("never")
  .join("");
const value = `export type EventMap<T extends EventTarget> = ${condition}`;
const typesFile = path.resolve(outputDir, "types.d.ts");
writeFileSync(typesFile, value);
console.log(`Successfully created ${path.relative(process.cwd(), typesFile)}`);

const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
const shimTypesFile = path.resolve(outputDir, "shims.d.ts");
writeFileSync(
  shimTypesFile,
  nodes
    .map(({ node, signatures }) =>
      printer.printNode(
        ts.EmitHint.Unspecified,
        ts.factory.createInterfaceDeclaration(
          undefined,
          node.name,
          node.typeParameters,
          undefined,
          signatures.map((methodDeclarationNode) => {
            return ts.factory.createMethodDeclaration(
              methodDeclarationNode.modifiers,
              undefined,
              methodDeclarationNode.name,
              methodDeclarationNode.questionToken,
              methodDeclarationNode.typeParameters,
              methodDeclarationNode.parameters,
              ts.factory.createTypeReferenceNode("VoidFunction")
            );
          })
        )
      )
    )
    .join("\n\n")
);
console.log(
  `Successfully created ${path.relative(process.cwd(), shimTypesFile)}`
);

if (patch) {
  // Change return type => mutate AST
  nodes.forEach(({ signatures }) => {
    signatures.forEach((methodDeclarationNode) => {
      methodDeclarationNode.type =
        ts.factory.createTypeReferenceNode("VoidFunction");
    });
  });

  sourceFiles.forEach((sourceFile) => {
    writeFileSync(
      sourceFile.fileName,
      printer.printNode(ts.EmitHint.Unspecified, sourceFile)
    );
    console.log(
      `Successfully patched ${path.relative(
        process.cwd(),
        sourceFile.fileName
      )}`
    );
  });
}

/**
 * Finds a node in the source file by its name and kind.
 * @param {string} nodeName
 * @param {ts.SyntaxKind} nodeKind
 * @param {ts.SourceFile} sourceFile
 * @returns {ts.Node | undefined}
 */
function findNode(nodeName, nodeKind, sourceFile) {
  let foundNode;

  /**
   * @param {ts.Node} node
   */
  function search(node) {
    if (foundNode) return;

    if (node.kind === nodeKind && node.name?.getText(sourceFile) === nodeName) {
      foundNode = node;
      return;
    }

    ts.forEachChild(node, search);
  }

  search(sourceFile);
  return foundNode;
}

/**
 * @param {ts.Node} node
 * @param {string[]} tree
 * @param {ts.SourceFile} sourceFile
 */
function visitHeritageClauses(node, tree, sourceFile) {
  node.heritageClauses?.flatMap((clause) =>
    clause.types.forEach((type) => {
      const name = type.expression.getText(sourceFile);
      tree.push(name);
      const found = findNode(
        name,
        ts.SyntaxKind.InterfaceDeclaration,
        sourceFile
      );
      found && visitHeritageClauses(found, tree, sourceFile);
    })
  );
}

/**
 *
 * @param {ts.Node} node
 * @param {ts.SourceFile} sourceFile
 */
function visit(node, sourceFile) {
  if (!ts.isInterfaceDeclaration(node)) {
    ts.forEachChild(node, (child) => visit(child, sourceFile));
    return;
  }

  /**
   * @type {ts.MethodSignature[]}
   */
  const addEventListenerDeclarations = node.members.filter(
    (member) =>
      ts.isMethodSignature(member) &&
      member.name?.getText(sourceFile) === "addEventListener"
  );

  if (!addEventListenerDeclarations.length) {
    return;
  }

  const heritageClauses = [];
  visitHeritageClauses(node, heritageClauses, sourceFile);

  const eventMap = addEventListenerDeclarations
    .filter((member) => member.typeParameters?.length)
    .flatMap((member) => member.typeParameters)
    .map((typeParam) => typeParam.constraint.getText(sourceFile))
    .find((k) => k.startsWith("keyof"))
    ?.replace("keyof", "")
    .trim();

  const generics =
    node.typeParameters?.filter((node) => !node.default).length ?? 0;

  nodes.push({
    node,
    signatures: addEventListenerDeclarations,
    type: generics
      ? `${node.name.getText(sourceFile)}<${new Array(generics)
          .fill("any")
          .join(", ")}>`
      : node.name.getText(sourceFile),
    eventMap,
    ancestors: heritageClauses,
  });
}