refactor: use generic "on" method rather than creating multiple functions

Author: brianrodri

src/lib/obsidian-dataview/adapter.ts

@@ -1,9 +1,12 @@
 import { DataviewApi, SMarkdownPage, STask, getAPI, isPluginEnabled } from "@/lib/obsidian-dataview/types";
-import { EventRef, Plugin } from "@/lib/obsidian/types";
+import { EventRef, MetadataCache, Plugin, TAbstractFile, TFile } from "@/lib/obsidian/types";
+import { ParametersFrom4Overloads } from "@/utils/type-utils";
 import { Task } from "@/data/task";
 import { mergeTaskParts } from "@/data/merge-task-parts";
 import { parseTaskEmojis } from "@/data/parse-task-emojis";
 
+type MetadataCacheOnFunctionParameters = ParametersFrom4Overloads<MetadataCache["on"]>;
+
 export class Dataview {
     private constructor(
         private readonly plugin: Plugin,
@@ -22,20 +25,39 @@ export class Dataview {
                 } else if (api.index.initialized) {
                     resolve(new Dataview(plugin, api));
                 } else {
-                    plugin.registerEvent(
-                        // @ts-expect-error - obsidian doesn't define types for third-party events.
-                        plugin.app.metadataCache.on("dataview:index-ready", () => resolve(new Dataview(plugin, api))),
-                    );
+                    const dv = new Dataview(plugin, api);
+                    plugin.registerEvent(dv.on("dataview:index-ready", () => resolve(dv)));
                 }
             }
         });
     }
 
-    public onMetadataChange(callback: () => void): EventRef {
-        // @ts-expect-error - obsidian doesn't define overloads for third-party events.
-        return this.plugin.app.metadataCache.on("dataview:metadata-change", callback);
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+
+    public on(name: "dataview:index-ready", callback: () => void, ctx?: any): EventRef;
+
+    public on(
+        name: "dataview:metadata-change",
+        callback:
+            | ((name: "delete", file: TFile) => void)
+            | ((name: "rename", file: TAbstractFile, oldPath: string) => void)
+            | ((name: "update", file: TFile) => void),
+        ctx?: any,
+    ): EventRef;
+
+    public on<Name extends MetadataCacheOnFunctionParameters[0]>(
+        name: Name,
+        callback: MetadataCache["on"] extends (name: Name, callback: infer F, ctx?: any) => EventRef ? F : never,
+        ctx?: any,
+    ): EventRef;
+
+    public on(name: string, callback: (...args: any[]) => any, ctx?: any): EventRef {
+        // @ts-expect-error - Rely on overloads for errors.
+        return this.plugin.app.metadataCache.on(name, callback, ctx);
     }
 
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+
     public getPages(query: string, originFile?: string): SMarkdownPage[] {
         return [...this.dv.pages(query, originFile)];
     }

src/lib/obsidian/types.ts

@@ -1,2 +1,2 @@
 export { Plugin } from "obsidian";
-export type { EventRef } from "obsidian";
+export type { EventRef, MetadataCache, TAbstractFile, TFile } from "obsidian";

src/main.tsx

@@ -6,7 +6,7 @@ export class Objo extends Plugin {
         this.app.workspace.onLayoutReady(async () => {
             const dv = await Dataview.getReady(this);
             this.log(dv);
-            this.registerEvent(dv.onMetadataChange(() => this.log(dv)));
+            this.registerEvent(dv.on("dataview:metadata-change", () => this.log(dv)));
         });
     }
 

src/utils/type-utils.ts

@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export type ParametersFrom4Overloads<T> =
+    T extends (
+        {
+            (...args: infer A1): any;
+            (...args: infer A2): any;
+            (...args: infer A3): any;
+            (...args: infer A4): any;
+        }
+    ) ?
+        A1 | A2 | A3 | A4
+    : T extends { (...args: infer A1): any; (...args: infer A2): any; (...args: infer A3): any } ? A1 | A2 | A3
+    : T extends { (...args: infer A1): any; (...args: infer A2): any } ? A1 | A2
+    : T extends (...args: infer A) => any ? A
+    : any;