Started making solid typings

Author: Developer-Mike

src/@types/Backlinks.d.ts

@@ -0,0 +1,5 @@
+import { TFile } from "obsidian"
+
+export default interface Backlink {
+  recomputeBacklink(file: TFile | null): void
+}

src/@types/Canvas.d.ts

@@ -25,9 +25,9 @@ export interface Canvas {
 
   getData(): CanvasData
   setData(data: CanvasData): void
-
   /** Basically setData (if clearCanvas == true), but without modifying the history */
-  importData(data: CanvasData, clearCanvas?: boolean): void
+  importData(data: CanvasData, clearCanvas?: boolean, /* custom */ silent?: boolean): void
+  clear(): void
 
   nodes: Map<string, CanvasNode>
   edges: Map<string, CanvasEdge>
@@ -39,7 +39,7 @@ export interface Canvas {
 
   wrapperEl: HTMLElement
   canvasEl: HTMLElement
-  menu: PopupMenu
+  menu: CanvasPopupMenu
   cardMenuEl: HTMLElement
   canvasControlsEl: HTMLElement
   quickSettingsButton: HTMLElement
@@ -48,6 +48,8 @@ export interface Canvas {
   canvasRect: DOMRect
   getViewportBBox(): BBox
   setViewport(tx: number, ty: number, tZoom: number): void
+
+  viewportChanged: boolean
   markViewportChanged(): void
 
   x: number
@@ -82,6 +84,8 @@ export interface Canvas {
   createTextNode(options: { [key: string]: any }): CanvasNode
   createGroupNode(options: { [key: string]: any }): CanvasNode
   createFileNode(options: { [key: string]: any }): CanvasNode
+  createFileNodes(filepaths: string[], position: Position): CanvasNode[]
+  createLinkNode(options: { [key: string]: any }): CanvasNode
 
   addNode(node: CanvasNode): void
   removeNode(node: CanvasNode): void
@@ -97,6 +101,8 @@ export interface Canvas {
 
   posFromEvt(event: MouseEvent): Position
   onDoubleClick(event: MouseEvent): void
+  handleCopy(e: ClipboardEvent): void
+
   handlePaste(): void
   requestSave(): void
 
@@ -355,11 +361,13 @@ export interface CanvasEdge extends CanvasElement {
 }
 
 export interface NodeInteractionLayer {
+  canvas: Canvas
   interactionEl: HTMLElement
   setTarget(node: CanvasNode): void
 }
 
-export interface PopupMenu {
+export interface CanvasPopupMenu {
+  canvas: Canvas
   menuEl: HTMLElement
   render(): void
 }

src/@types/Obsidian.d.ts

@@ -9,7 +9,7 @@ declare module "obsidian" {
     /** @public */
     scope: Scope
     /** @public */
-    vault: Vault
+    vault: ExtendedVault
     /** @public */
     fileManager: FileManager
     /**
@@ -20,22 +20,35 @@ declare module "obsidian" {
 
     internalPlugins: any
 
-    // Custom
     /** @public */
     metadataCache: ExtendedMetadataCache
     /** @public */
     workspace: Workspace & ExtendedWorkspace
   }
 
+  export interface ExtendedVault extends Vault {
+    getMarkdownFiles: () => TFile[]
+
+    // Custom
+    recurseChildrenAC: (origin: TAbstractFile, traverse: (file: TAbstractFile) => void) => void
+  }
+
   export interface ExtendedMetadataCache extends MetadataCache {
+    vault: ExtendedVault
+
     fileCache: FileCache
     metadataCache: MetadataCacheMap
     resolvedLinks: ResolvedLinks
 
+    computeMetadataAsync: (buffer: ArrayBuffer) => Promise<ExtendedCachedMetadata>
+
     computeFileMetadataAsync: (file: TFile) => void
     saveFileCache: (filepath: string, cache: FileCacheEntry) => void
     linkResolver: () => void
-    resolveLinks: (filepath: string) => void
+    resolveLinks: (filepath: string, /* custom */ cachedContent: any) => void
+
+    // Custom
+    registerInternalLinkAC: (canvasName: string, from: string, to: string) => void
   }
 
   export interface ExtendedWorkspace {

src/@types/OutgoingLink.d.ts

@@ -0,0 +1,8 @@
+import { TFile } from "obsidian"
+
+export default interface OutgoingLink {
+  file: TFile
+
+  recomputeLinks(): void
+  recomputeUnlinked(): void
+}

src/patchers/backlinks-patcher.ts

@@ -1,6 +1,7 @@
-import { TAbstractFile, TFile, TFolder } from "obsidian"
+import { ExtendedVault, TAbstractFile, TFile, TFolder } from "obsidian"
 import PatchHelper from "src/utils/patch-helper"
 import Patcher from "./patcher"
+import Backlink from "src/@types/Backlinks"
 
 export default class BacklinksPatcher extends Patcher {
   private isRecomputingBacklinks: boolean = false
@@ -9,7 +10,7 @@ export default class BacklinksPatcher extends Patcher {
     if (!this.plugin.settings.getSetting('canvasMetadataCompatibilityEnabled')) return
 
     const that = this
-    const backlinkPatch = PatchHelper.tryPatchWorkspacePrototype(this.plugin, () => (
+    const backlinkPatch = PatchHelper.tryPatchWorkspacePrototype<Backlink>(this.plugin, () => (
       (this.plugin.app.workspace.getLeavesOfType('backlink').first()?.view as any)?.backlink
     ), {
       recomputeBacklink: PatchHelper.OverrideExisting(next => function (file: TFile, ...args: any[]) {
@@ -20,7 +21,7 @@ export default class BacklinksPatcher extends Patcher {
       })
     })
 
-    const vaultPatch = PatchHelper.patchPrototype<any>(this.plugin, this.plugin.app.vault, {
+    const vaultPatch = PatchHelper.patchPrototype<ExtendedVault>(this.plugin, this.plugin.app.vault, {
       recurseChildrenAC: _next => function (origin: TAbstractFile, traverse: (file: TAbstractFile) => void) {
         for (var stack = [origin]; stack.length > 0;) {
           var current = stack.pop()
@@ -32,8 +33,8 @@ export default class BacklinksPatcher extends Patcher {
           }
         }
       },
-      getMarkdownFiles: PatchHelper.OverrideExisting(next => function (file: TFile, ...args: any[]) {
-        if (!that.isRecomputingBacklinks) return next.call(this, file, ...args)
+      getMarkdownFiles: PatchHelper.OverrideExisting(next => function (...args: any[]) {
+        if (!that.isRecomputingBacklinks) return next.call(this, ...args)
 
         // If we are recomputing backlinks, we need to include markdown as well as canvas files
         var files: TFile[] = []
@@ -45,7 +46,7 @@ export default class BacklinksPatcher extends Patcher {
           }
         })
 
-        return files
+        return "files"
       })
     })
 

src/patchers/canvas-patcher.ts

@@ -2,7 +2,7 @@ import { EditorView, ViewUpdate } from "@codemirror/view"
 import JSONSS from "json-stable-stringify"
 import { around } from "monkey-around"
 import { editorInfoField, requireApiVersion, WorkspaceLeaf } from "obsidian"
-import { BBox, CanvasData, CanvasEdge, CanvasEdgeData, CanvasElement, CanvasNode, CanvasNodeData, CanvasView } from "src/@types/Canvas"
+import { BBox, Canvas, CanvasData, CanvasEdge, CanvasEdgeData, CanvasElement, CanvasNode, CanvasNodeData, CanvasPopupMenu, CanvasView, NodeInteractionLayer } from "src/@types/Canvas"
 import PatchHelper from "src/utils/patch-helper"
 import JSONC from "tiny-jsonc"
 import { CanvasEvent } from "../events"
@@ -39,7 +39,7 @@ export default class CanvasPatcher extends Patcher {
     })
 
     // Patch canvas view
-    PatchHelper.patchPrototype<any>(this.plugin, canvasView, {
+    PatchHelper.patchPrototype<CanvasView>(this.plugin, canvasView, {
       getViewData: PatchHelper.OverrideExisting(next => function (...args: any) {
         const canvasData = this.canvas.getData()
 
@@ -79,7 +79,7 @@ export default class CanvasPatcher extends Patcher {
     })
 
     // Patch canvas
-    PatchHelper.patchPrototype<any>(this.plugin, canvasView.canvas, {
+    PatchHelper.patchPrototype<Canvas>(this.plugin, canvasView.canvas, {
       markViewportChanged: PatchHelper.OverrideExisting(next => function (...args: any) {
         that.triggerWorkspaceEvent(CanvasEvent.ViewportChanged.Before, this)
         const result = next.call(this, ...args)
@@ -245,7 +245,7 @@ export default class CanvasPatcher extends Patcher {
     })
 
     // Patch canvas popup menu
-    PatchHelper.patchPrototype<any>(this.plugin, canvasView.canvas.menu, {
+    PatchHelper.patchPrototype<CanvasPopupMenu>(this.plugin, canvasView.canvas.menu, {
       render: PatchHelper.OverrideExisting(next => function (...args: any) {
         const result = next.call(this, ...args)
         that.triggerWorkspaceEvent(CanvasEvent.PopupMenuCreated, this.canvas)
@@ -255,7 +255,7 @@ export default class CanvasPatcher extends Patcher {
     })
 
     // Patch interaction layer
-    PatchHelper.patchPrototype<any>(this.plugin, canvasView.canvas.nodeInteractionLayer, {
+    PatchHelper.patchPrototype<NodeInteractionLayer>(this.plugin, canvasView.canvas.nodeInteractionLayer, {
       setTarget: PatchHelper.OverrideExisting(next => function (node: CanvasNode) {
         const result = next.call(this, node)
         that.triggerWorkspaceEvent(CanvasEvent.NodeInteraction, this.canvas, node)
@@ -287,7 +287,7 @@ export default class CanvasPatcher extends Patcher {
   private patchNode(node: CanvasNode) {
     const that = this
 
-    PatchHelper.patch<any>(this.plugin, node, {
+    PatchHelper.patch<CanvasNode>(this.plugin, node, {
       setData: PatchHelper.OverrideExisting(next => function (data: CanvasNodeData, addHistory?: boolean) {
         const result = next.call(this, data)
 
@@ -332,7 +332,7 @@ export default class CanvasPatcher extends Patcher {
   private patchEdge(edge: CanvasEdge) {
     const that = this
 
-    PatchHelper.patch<any>(this.plugin, edge, {
+    PatchHelper.patch<CanvasEdge>(this.plugin, edge, {
       setData: PatchHelper.OverrideExisting(next => function (data: CanvasEdgeData, addHistory?: boolean) {
         const result = next.call(this, data)
 

src/patchers/metadata-cache-patcher.ts

@@ -1,4 +1,4 @@
-import { TFile } from "obsidian"
+import { ExtendedMetadataCache, TFile } from "obsidian"
 import { CanvasData, CanvasNodeData } from "src/@types/Canvas"
 import { ExtendedCachedMetadata, MetadataCacheMap } from "src/@types/Obsidian"
 import HashHelper from "src/utils/hash-helper"
@@ -11,7 +11,7 @@ export default class MetadataCachePatcher extends Patcher {
     if (!this.plugin.settings.getSetting('canvasMetadataCompatibilityEnabled')) return
 
     const that = this
-    await PatchHelper.patchPrototype<any>(this.plugin, this.plugin.app.metadataCache, {
+    PatchHelper.patchPrototype<ExtendedMetadataCache>(this.plugin, this.plugin.app.metadataCache, {
       getCache: PatchHelper.OverrideExisting(next => function (filepath: string, ...args: any[]) {
         // Bypass the "md" extension check by handling the "canvas" extension here
         if (PathHelper.extension(filepath) === 'canvas') {

src/patchers/outgoing-links-patcher.ts

@@ -1,12 +1,13 @@
 import PatchHelper from "src/utils/patch-helper"
 import Patcher from "./patcher"
+import OutgoingLink from "src/@types/OutgoingLink"
 
 export default class OutgoingLinksPatcher extends Patcher {
   protected async patch() {
     if (!this.plugin.settings.getSetting('canvasMetadataCompatibilityEnabled')) return
 
     const that = this
-    const outgoingLinkPatch = PatchHelper.tryPatchWorkspacePrototype(this.plugin, () => (
+    const outgoingLinkPatch = PatchHelper.tryPatchWorkspacePrototype<OutgoingLink>(this.plugin, () => (
       (this.plugin.app.workspace.getLeavesOfType('outgoing-link').first()?.view as any)?.outgoingLink
     ), {
       recomputeLinks: PatchHelper.OverrideExisting(next => function (...args: any[]) {

src/utils/_type-test.ts

@@ -0,0 +1,40 @@
+import { Canvas } from "src/@types/Canvas"
+import PatchHelper from "./patch-helper"
+
+PatchHelper.patchPrototype<Canvas>(null as any, null as any, {
+  // @ts-expect-error
+  onResize: PatchHelper.OverrideExisting((next) => function (width: number, height: number) {
+    console.log("Resizing canvas")
+
+    // @ts-expect-error
+    next.call(this, width, height)
+  }),
+  onDoubleClick: (next) => function (event: MouseEvent) {
+    console.log("Double click")
+    next.call(this, event)
+  },
+  createFileNode: (next) => function (file: File) {
+    // @ts-expect-error
+    return next?.(file, null, "dfsaf")
+  },
+  // @ts-expect-error
+  getData: (next) => function (...args: any[]) {
+    console.log("Getting data")
+    return 0
+  },
+  createTextNode: (next) => function (text: Record<string, any>) {
+    console.log("Creating text node")
+    return next.call(this, text)
+  },
+  createGroupNode: PatchHelper.OverrideExisting((next) => function (options: Record<string, any>) {
+    console.log("Creating group node")
+    return next.call(this, options)
+  })
+})
+
+PatchHelper.patchPrototype<Canvas>(null as any, null as any, {
+  createTextNode: PatchHelper.OverrideExisting((next) => function (text: Record<string, any>) {
+    console.log("Creating text node")
+    return 0 as any
+  })
+})

src/utils/patch-helper.ts

@@ -1,17 +1,32 @@
 import { around } from "monkey-around"
 import { Plugin } from "obsidian"
 
+// All keys in T that are functions
+type FunctionKeys<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never
+}[keyof T]
+
+// The type of the function at key K in T
+type KeyFunction<T, K extends FunctionKeys<T>> = 
+  T[K] extends (...args: any[]) => any ? T[K] : never
+
+// The type of a patch function for key K in T
+type KeyFunctionReplacement<T, K extends FunctionKeys<T>> = 
+  (this: T, ...args: Parameters<KeyFunction<T, K>>) => ReturnType<KeyFunction<T, K>>
+
+// The wrapper of a patch function for key K in T
+type PatchFunctionWrapper<T, K extends FunctionKeys<T>> = 
+  (next: KeyFunction<T, K>) => KeyFunctionReplacement<T, K>
+
+// The object of patch functions for T
 type FunctionPatchObject<T> = {
-  [Key in keyof T | any]: ((next: T[Key | any]) => (this: T, ...args: any) => any) & { __overrideExisting?: boolean }
+  [K in FunctionKeys<T>]?: PatchFunctionWrapper<T, K> & { __overrideExisting?: boolean }
 }
 
 export default class PatchHelper {
-  static OverrideExisting<
-    T,
-    K extends keyof T
-  >(fn: (next: T[K]) => (this: T, ...args: any[]) => any) {
-    return Object.assign(fn, { __overrideExisting: true })
-  }
+  static OverrideExisting<T, K extends FunctionKeys<T>>(
+    fn: PatchFunctionWrapper<T, K> & { __overrideExisting?: boolean }
+  ) { return Object.assign(fn, { __overrideExisting: true }) }
 
   static patchPrototype<T>(
     plugin: Plugin,
@@ -31,9 +46,9 @@ export default class PatchHelper {
     const target = prototype ? object.constructor.prototype : object
 
     // Validate override requirements
-    for (const key of Object.keys(patches) as Array<keyof T>) {
+    for (const key of Object.keys(patches) as Array<FunctionKeys<T>>) {
       const patch = patches[key]
-      if (patch.__overrideExisting) {
+      if (patch?.__overrideExisting) {
         if (typeof target[key] !== 'function')
           throw new Error(`Method ${String(key)} does not exist on target`)
       }