obsidian-livesync/src/features/LiveSyncCommands.ts

import { LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
import {
    LOG_LEVEL_INFO,
    LOG_LEVEL_NOTICE,
    type AnyEntry,
    type DocumentID,
    type FilePath,
    type FilePathWithPrefix,
    type LOG_LEVEL,
} from "../lib/src/common/types.ts";
import type ObsidianLiveSyncPlugin from "../main.ts";
import { MARK_DONE } from "../modules/features/ModuleLog.ts";
import type { LiveSyncCore } from "../main.ts";
import { __$checkInstanceBinding } from "../lib/src/dev/checks.ts";
import { createInstanceLogFunction } from "@/lib/src/services/lib/logUtils.ts";

let noticeIndex = 0;
export abstract class LiveSyncCommands {
    plugin: ObsidianLiveSyncPlugin;
    get app() {
        return this.plugin.app;
    }
    get settings() {
        return this.plugin.settings;
    }
    get localDatabase() {
        return this.plugin.localDatabase;
    }
    get services() {
        return this.plugin.services;
    }

    // id2path(id: DocumentID, entry?: EntryHasPath, stripPrefix?: boolean): FilePathWithPrefix {
    //     return this.plugin.$$id2path(id, entry, stripPrefix);
    // }
    async path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID> {
        return await this.services.path.path2id(filename, prefix);
    }

    getPath(entry: AnyEntry): FilePathWithPrefix {
        return this.services.path.getPath(entry);
    }

    constructor(plugin: ObsidianLiveSyncPlugin) {
        this.plugin = plugin;
        this.onBindFunction(plugin, plugin.services);
        this._log = createInstanceLogFunction(this.constructor.name, this.services.API);
        __$checkInstanceBinding(this);
    }
    abstract onunload(): void;
    abstract onload(): void | Promise<void>;

    _isMainReady() {
        return this.plugin.services.appLifecycle.isReady();
    }
    _isMainSuspended() {
        return this.services.appLifecycle.isSuspended();
    }
    _isDatabaseReady() {
        return this.services.database.isDatabaseReady();
    }

    _log: ReturnType<typeof createInstanceLogFunction>;

    _verbose = (msg: any, key?: string) => {
        this._log(msg, LOG_LEVEL_VERBOSE, key);
    };

    _info = (msg: any, key?: string) => {
        this._log(msg, LOG_LEVEL_INFO, key);
    };

    _notice = (msg: any, key?: string) => {
        this._log(msg, LOG_LEVEL_NOTICE, key);
    };
    _progress = (prefix: string = "", level: LOG_LEVEL = LOG_LEVEL_NOTICE) => {
        const key = `keepalive-progress-${noticeIndex++}`;
        return {
            log: (msg: any) => {
                this._log(prefix + msg, level, key);
            },
            once: (msg: any) => {
                this._log(prefix + msg, level);
            },
            done: (msg: string = "Done") => {
                this._log(prefix + msg + MARK_DONE, level, key);
            },
        };
    };

    _debug = (msg: any, key?: string) => {
        this._log(msg, LOG_LEVEL_VERBOSE, key);
    };

    onBindFunction(core: LiveSyncCore, services: typeof core.services) {
        // Override if needed.
    }
}