Fix broken part after Obsidian update

Author: snezhig

config/inversify.types.ts

@@ -63,9 +63,10 @@ const SI = {
     api: "",
     defer: "",
     "factory:api": "",
-    "factory:processor": "",
+    "processor:factory": "",
     processor: "",
     "processor:args": "",
+    "processor:argument.transformer": "",
 };
 
 for (const key of Object.keys(SI)) {

config/services/processors.config.ts

@@ -6,6 +6,7 @@ import ReplaceProcessor from "@src/Components/Processor/ReplaceProcessor";
 import FunctionProcessor from "@src/Components/Processor/FunctionProcessor";
 import { ProcessorTypes } from "@src/Components/Processor/ProcessorUtils";
 import FunctionV2Processor from "@src/Components/Processor/FunctionV2Processor";
+import ProcessorArgumentTransformer from "@src/Components/Processor/ProcessorArgumentTransformer";
 
 export default new ContainerModule(bind => {
     bind(SI.processor).to(ReplaceProcessor).whenTargetNamed(ProcessorTypes.Replace);
@@ -14,5 +15,6 @@ export default new ContainerModule(bind => {
     bind(SI["processor:args"]).toDynamicValue(c =>
         c.container.get<KeyStorageInterface<SettingsType>>(SI["settings:storage"]).get("processor").get("args").value()
     );
-    bind(SI["factory:processor"]).toAutoNamedFactory(SI.processor);
+    bind(SI["processor:factory"]).toAutoNamedFactory(SI.processor);
+    bind(SI["processor:argument.transformer"]).to(ProcessorArgumentTransformer);
 });

main.ts

@@ -157,6 +157,7 @@ export default class MetaTitlePlugin extends Plugin implements PluginInterface {
             } catch (e) {
                 //TODO: refactor
                 this.fc.toggle(id, false);
+                this.logger.log(e);
                 new Notice(e);
             }
         }

manifest.json

@@ -1,8 +1,8 @@
 {
   "id": "obsidian-front-matter-title-plugin",
   "name": "Front Matter Title",
-  "version": "3.10.0",
-  "minAppVersion": "1.5.3",
+  "version": "3.11.0",
+  "minAppVersion": "1.7.4",
   "description": "Lets you define a title in frontmatter to be displayed as the filename for explorer, graph, search and etc.",
   "author": "Snezhig",
   "authorUrl": "https://github.com/snezhig",

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-front-matter-title",
-  "version": "3.10.0",
+  "version": "3.11.0",
   "description": "This is a sample plugin for Obsidian (https://obsidian.md)",
   "main": "main.js",
   "scripts": {
@@ -33,7 +33,7 @@
     "eslint": "^8.44.0",
     "jest": "^29.6.1",
     "jest-mock-extended": "^3.0.4",
-    "obsidian": "^1.4.11",
+    "obsidian": "^1.7.2",
     "prettier": "^2.8.8",
     "ts-debounce": "^4.0.0",
     "ts-jest": "^29.1.1",

package.json

@@ -5,6 +5,16 @@ import { injectable } from "inversify";
 export default class Debugger implements LoggerInterface {
     constructor(private name: string, private enabled: () => boolean) {}
 
+    info(...value: any[]): void {
+        this.log(...value);
+    }
+    debug(...value: any[]): void {
+        this.log(...value);
+    }
+    warn(...value: any[]): void {
+        this.log(...value);
+    }
+
     log(...value: any) {
         if (this.enabled()) {
             console.debug(`[${this.name}]`, ...value);

src/Components/Debug/Debugger.ts

@@ -1,3 +1,6 @@
 export default interface LoggerInterface {
     log(...value: any[]): void;
+    info(...value: any[]): void;
+    debug(...value: any[]): void;
+    warn(...value: any[]): void;
 }

src/Components/Debug/LoggerInterface.ts

@@ -2,20 +2,24 @@ import { inject, injectable } from "inversify";
 import ProcessorInterface from "./Interfaces";
 import SI from "../../../config/inversify.types";
 import { FunctionV2ObjArg, ProcessorTypes } from "@src/Components/Processor/ProcessorUtils";
+import ObsidianFacade from "@src/Obsidian/ObsidianFacade";
 
 @injectable()
 export default class FunctionV2Processor implements ProcessorInterface {
     private readonly func: Function | null;
 
     constructor(
         @inject(SI["processor:args"])
-        args: string[]
+        args: string[],
+        @inject(SI["facade:obsidian"])
+        private facade: ObsidianFacade
     ) {
         this.func = args?.[0] ? new Function("obj", args[0]) : null;
     }
 
     process(value: string): string {
         const obj = JSON.parse(value) as FunctionV2ObjArg;
+        obj.file = this.facade.getTFile(obj.path);
         return this.func?.(obj) ?? obj.title;
     }
 

src/Components/Processor/FunctionV2Processor.ts

@@ -21,8 +21,10 @@ export default class ProcessorListener implements ListenerInterface {
     constructor(
         @inject(SI["event:dispatcher"])
         private dispatcher: EventDispatcherInterface<AppEvents & ResolverEvents>,
-        @inject(SI["factory:processor"])
-        private factory: ProcessorFactory
+        @inject(SI["processor:factory"])
+        private factory: ProcessorFactory,
+        @inject(SI["processor:argument.transformer"])
+        private transformer: ProcessorArgumentTransformer
     ) {}
 
     bind(): void {
@@ -71,7 +73,7 @@ export default class ProcessorListener implements ListenerInterface {
         if (this.processor === null) {
             return;
         }
-        const arg = ProcessorArgumentTransformer.transform(event, this.processor.getType());
+        const arg = this.transformer.transform(event, this.processor.getType());
         const value = this.processor.process(arg) ?? null;
         if (value) {
             obj.modify(value);

src/Components/Processor/ProccessorListener.ts

@@ -1,15 +1,21 @@
 import EventInterface from "@src/Components/EventDispatcher/Interfaces/EventInterface";
 import { ResolverEvents } from "@src/Resolver/ResolverType";
 import { FunctionV2ObjArg, ProcessorTypes } from "@src/Components/Processor/ProcessorUtils";
+import { injectable } from "inversify";
 
+@injectable()
 export default class ProcessorArgumentTransformer {
-    static transform(event: EventInterface<ResolverEvents["resolver:resolved"]>, type: ProcessorTypes): string | null {
+    transform(event: EventInterface<ResolverEvents["resolver:resolved"]>, type: ProcessorTypes): string | null {
         switch (type) {
             case ProcessorTypes.Function:
             case ProcessorTypes.Replace:
                 return event.get().value;
             case ProcessorTypes.FunctionV2:
-                return JSON.stringify({ path: event.get().path, title: event.get().value } as FunctionV2ObjArg);
+                return JSON.stringify({
+                    path: event.get().path,
+                    title: event.get().value,
+                    file: null,
+                } as FunctionV2ObjArg);
         }
     }
 }

src/Components/Processor/ProcessorArgumentTransformer.ts

@@ -1,4 +1,5 @@
 import ProcessorInterface from "./Interfaces";
+import { TFile } from "obsidian";
 
 export enum ProcessorTypes {
     Function = "function",
@@ -14,4 +15,6 @@ export type FunctionV2ObjArg = {
     title: string;
     // Path to file
     path: string;
+    // TFile
+    file: TFile | null;
 };

src/Components/Processor/ProcessorUtils.ts

@@ -1,3 +1,9 @@
+export enum Plugins {
+    Search = "global-search",
+    FileExplorer = "file-explorer",
+    Backlink = "backlink",
+}
+
 export enum Leaves {
     FE = "file-explorer",
     G = "graph",

src/Enum.ts

@@ -1,6 +1,6 @@
 import { inject, injectable, named } from "inversify";
 import ObsidianFacade from "../../Obsidian/ObsidianFacade";
-import { Feature, Leaves } from "@src/Enum";
+import { Feature, Leaves, Plugins } from "@src/Enum";
 import SI from "../../../config/inversify.types";
 import LoggerInterface from "../../Components/Debug/LoggerInterface";
 import { BacklinkViewExt, MarkdownViewExt } from "obsidian";
@@ -53,7 +53,7 @@ export default class BacklinkFeature extends AbstractFeature<Feature> {
     }
 
     public enable(): void {
-        this.enabled = this.facade.isInternalPluginEnabled(this.getId());
+        this.enabled = this.facade.isInternalPluginEnabled(Plugins.Backlink);
         this.logger.log(`Manager state is ${this.enabled}`);
         if (!this.enabled) {
             return;

src/Feature/Backlink/BacklinkFeature.ts

@@ -1,4 +1,4 @@
-import { BookmarksPluginView, EventRef } from "obsidian";
+import { BookmarksPluginLeaf, BookmarksPluginView, EventRef } from "obsidian";
 import { inject, injectable, named } from "inversify";
 import SI from "@config/inversify.types";
 import ObsidianFacade from "@src/Obsidian/ObsidianFacade";
@@ -11,12 +11,19 @@ import EventDispatcherInterface from "@src/Components/EventDispatcher/Interfaces
 import { AppEvents } from "@src/Types";
 import ListenerRef from "@src/Components/EventDispatcher/Interfaces/ListenerRef";
 
+enum State {
+    Disabled = "disabled",
+    Enabled = "enabled",
+    Awaiting = "awaiting",
+}
+
 @injectable()
 export default class BookmarksManager extends AbstractFeature<Feature> {
-    private enabled = false;
+    private state: State = State.Disabled;
     private view: BookmarksPluginView = null;
     private ref: EventRef = null;
     private metaRef: ListenerRef<"metadata:cache:changed"> = null;
+    private activeLeafChangeRef: ListenerRef<"active:leaf:change"> = null;
     private resolver: ResolverInterface;
     private requestUpdate: () => void;
 
@@ -33,29 +40,27 @@ export default class BookmarksManager extends AbstractFeature<Feature> {
     ) {
         super();
         this.requestUpdate = () => setTimeout(this.onChanged.bind(this), 100);
-        this.metaRef = this.dispatcher.addListener({
-            name: "metadata:cache:changed",
-            cb: this.requestUpdate.bind(this),
-        });
         this.resolver = service.createResolver(this.getId());
     }
 
+    private setState(state: State): void {
+        this.logger.log(`State changed from ${this.state} to ${state}`);
+        this.state = state;
+    }
     static getId(): Feature {
         return Feature.Bookmarks;
     }
 
     enable(): void {
-        if (!this.isEnabled() && this.initView() && this.subscribe()) {
-            this.enabled = true;
-            this.requestUpdate();
-        }
+        this.tryEnable(true);
     }
 
     disable(): void {
+        this.logger.log("disable");
         if (this.isEnabled()) {
             this.unsubscribe();
             this.view = null;
-            this.enabled = false;
+            this.setState(State.Disabled);
         }
     }
 
@@ -64,7 +69,28 @@ export default class BookmarksManager extends AbstractFeature<Feature> {
     }
 
     isEnabled(): boolean {
-        return this.enabled;
+        return this.state !== State.Disabled;
+    }
+
+    private tryEnable(subscribeOnActive = false): void {
+        const leaf = this.facade.getLeavesOfType<BookmarksPluginLeaf>(Leaves.Bookmarks)?.[0];
+
+        if (leaf.isVisible()) {
+            if (this.state !== State.Enabled && this.initView() && this.subscribe()) {
+                this.setState(State.Enabled);
+                this.requestUpdate();
+            }
+            if (this.activeLeafChangeRef) {
+                this.dispatcher.removeListener(this.activeLeafChangeRef);
+                this.activeLeafChangeRef = null;
+            }
+        } else if (subscribeOnActive) {
+            this.setState(State.Awaiting);
+            this.activeLeafChangeRef = this.dispatcher.addListener({
+                name: "active:leaf:change",
+                cb: () => this.tryEnable(),
+            });
+        }
     }
 
     private initView(): boolean {
@@ -87,16 +113,34 @@ export default class BookmarksManager extends AbstractFeature<Feature> {
             this.logger.log("Triggered by plugin event");
             this.requestUpdate();
         });
+        this.metaRef = this.dispatcher.addListener({
+            name: "metadata:cache:changed",
+            cb: this.requestUpdate.bind(this),
+        });
         return true;
     }
 
     private unsubscribe(): void {
-        this.dispatcher.removeListener(this.metaRef);
-        this.view.plugin.offref(this.ref);
-        this.view.plugin.trigger("changed");
+        if (this.metaRef) {
+            this.dispatcher.removeListener(this.metaRef);
+        }
+        if (this.activeLeafChangeRef) {
+            this.dispatcher.removeListener(this.activeLeafChangeRef);
+        }
+        if (this.state === State.Enabled) {
+            this.view.plugin.offref(this.ref);
+            this.view.plugin.trigger("changed");
+        }
     }
 
     private onChanged(path: string = null): { [k: string]: boolean } {
+        if (this.state !== State.Enabled) {
+            this.logger.log(`Called onChanged when is ${this.state} state`);
+            return;
+        }
+        if (!this.view.plugin) {
+            return;
+        }
         const items = this.view.plugin.items;
         const itemDoms = this.view.itemDoms;
         const result: { [k: string]: boolean } = {};