shimmer

Author: ShaMan123

.github/workflows/test.yml

@@ -32,7 +32,7 @@ jobs:
 
       - name: Validate types.d
         run: |
-          npm run parse0
+          npm run parse
           diff=$(git diff --ignore-space-change types.d.ts)
           if [[ -n "$diff" ]]; then
             echo $diff

.prettierignore

@@ -0,0 +1,2 @@
+shim.d.ts
+types.d.ts

README.md

@@ -59,9 +59,7 @@ barDisposer();
 ### Shimming
 
 ```typescript
-import shim from "easy-add-event-listener/shim";
-
-shim();
+import "easy-add-event-listener/shim"; // shim implementation and TS declarations
 
 const disposer = window.addEventListener(
   "load",
@@ -71,7 +69,7 @@ const disposer = window.addEventListener(
 disposer();
 ```
 
-#### Shimming Types
+#### Shimming custom types
 
 - Run the cli to generate the shimmed types, refer to [this](#generate-types).
 - Load the types into your project by importing them or by using `patch-package`
@@ -85,6 +83,5 @@ The real effort here was to type the function:
 ### Generate Types
 
 ```bash
-npm run parse <input> <output>
-npm run parse0
+npm run parse
 ```

cli.mjs

@@ -4,49 +4,67 @@ import { readFileSync, writeFileSync } from "fs";
 import * as path from "path";
 import ts from "typescript";
 import { fileURLToPath } from "url";
+import { program } from "commander";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-const [inputPath, outputPath] = process.argv.slice(2);
-if (!inputPath || !outputPath) {
-  console.error(
-    "Please provide the input and output file paths as command-line arguments."
-  );
-  process.exit(1);
-}
-
+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(
+    process.cwd() === __dirname ? "[files...]" : "<files...>",
+    "Files to parse"
+  )
+  .option("-o,--output", "Output dir", __dirname)
+  .parse();
+const { output: outputPath } = program.opts();
+const files = program.args.length ? program.args : dtsFiles;
 const sourceFile = ts.createSourceFile(
   "ast.ts",
-  readFileSync(inputPath).toString(),
+  files
+    .map((file) => `// file: ${file}\n\n${readFileSync(file).toString()}`)
+    .join("\n\n\n\n"),
   ts.ScriptTarget.Latest
 );
 
 /**
- * @type {{ node: ts.InterfaceDeclaration, type: string, eventMap: string, ancestors: string[] }[]}
+ * @type {{ node: ts.InterfaceDeclaration, shim: ts.InterfaceDeclaration, type: string, eventMap: string, ancestors: string[] }[]}
  */
 const nodes = [];
 ts.forEachChild(sourceFile, visit);
 
-// Sort so that the condition is correct for subclasses
-nodes.sort((a, b) =>
-  b.ancestors.includes(a.type) ? 1 : a.ancestors.includes(b.type) ? -1 : 0
-);
-
 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}`;
-writeFileSync(path.resolve(__dirname, "types.d.ts"), value);
-console.log(`Successfully written types.d.ts`);
+writeFileSync(path.resolve(outputPath, "types.d.ts"), value);
+console.log("Successfully created types.d.ts");
 
 const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 writeFileSync(
-  outputPath,
-  printer.printNode(ts.EmitHint.Unspecified, sourceFile)
+  path.resolve(outputPath, "shim.d.ts"),
+  nodes
+    .map(({ shim }) => printer.printNode(ts.EmitHint.Unspecified, shim))
+    .join("\n\n")
 );
-console.log(`Successfully created ${outputPath}`);
+console.log("Successfully created shim.d.ts");
 
 /**
  * Finds a node in the source file by its name and kind.
@@ -100,45 +118,61 @@ function visit(node) {
     return;
   }
 
-  node.members
-    .filter(
-      (member) =>
-        ts.isMethodSignature(member) &&
-        member.name?.getText(sourceFile) === "addEventListener"
-    )
-    .forEach(
-      /**
-       *
-       * @param {ts.MethodSignature} methodNode
-       * @returns
-       */
-      (methodNode) => {
-        methodNode.type = ts.factory.createTypeReferenceNode("VoidFunction");
-      }
-    );
+  /**
+   * @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);
 
-  if (!heritageClauses.includes("EventTarget")) {
-    return;
-  }
+  // if (!heritageClauses.includes("EventTarget")) {
+  //   return;
+  // }
 
-  const eventMap = node.members
-    .filter(
-      (member) =>
-        member.name?.getText(sourceFile) === "addEventListener" &&
-        member.typeParameters?.length
-    )
+  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,
-    type: node.name.getText(sourceFile),
+    shim: ts.factory.createInterfaceDeclaration(
+      undefined,
+      node.name,
+      node.typeParameters,
+      undefined,
+      addEventListenerDeclarations.map((methodDeclarationNode) => {
+        return ts.factory.createMethodDeclaration(
+          methodDeclarationNode.modifiers,
+          undefined,
+          methodDeclarationNode.name,
+          methodDeclarationNode.questionToken,
+          methodDeclarationNode.typeParameters,
+          methodDeclarationNode.parameters,
+          ts.factory.createTypeReferenceNode("VoidFunction")
+        );
+      })
+    ),
+    type: generics
+      ? `${node.name.getText(sourceFile)}<${new Array(generics)
+          .fill("any")
+          .join(", ")}>`
+      : node.name.getText(sourceFile),
     eventMap,
     ancestors: heritageClauses,
   });

index.spec.js index.test.jsindex.spec.js renamed to index.test.js

@@ -5,7 +5,7 @@
   "type": "module",
   "main": "index.js",
   "bin": {
-    "addEventListener": "node cli.mjs"
+    "parse": "node cli.mjs"
   },
   "exports": {
     "/shim": {
@@ -14,9 +14,8 @@
     }
   },
   "scripts": {
-    "test": "node index.spec.js && tsc index.test.ts --noEmit",
-    "parse": "node cli.mjs",
-    "parse0": "node cli.mjs node_modules/typescript/lib/lib.dom.d.ts shimmed.ts"
+    "test": "node index.test.js && node shim.test.js && tsc index.test.ts shim.test.ts --noEmit",
+    "parse": "node cli.mjs"
   },
   "keywords": [
     "EventTarget",
@@ -32,6 +31,7 @@
   "license": "ISC",
   "devDependencies": {
     "@types/node": "^24.7.2",
+    "commander": "^14.0.1",
     "typescript": "^5.9.3"
   }
 }