@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/services/base/DatabaseEventService.d.ts

@@ -0,0 +1,38 @@
+import type { IDatabaseEventService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+/**
+ * The DatabaseEventService provides methods for handling database lifecycle events.
+ */
+export declare abstract class DatabaseEventService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IDatabaseEventService {
+    /**
+     * Event triggered when the database is about to be unloaded.
+     */
+    readonly onUnloadDatabase: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(db: import("../../pouchdb/LiveSyncLocalDB.js").LiveSyncLocalDB) => Promise<boolean>>;
+    /**
+     * Event triggered when the database is about to be closed.
+     */
+    readonly onCloseDatabase: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(db: import("../../pouchdb/LiveSyncLocalDB.js").LiveSyncLocalDB) => Promise<boolean>>;
+    /**
+     * Event triggered when the database is being initialized.
+     */
+    readonly onDatabaseInitialisation: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(db: import("../../pouchdb/LiveSyncLocalDB.js").LiveSyncLocalDB) => Promise<boolean>>;
+    /**
+     * Event triggered when the database has been initialized.
+     */
+    readonly onDatabaseInitialised: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showNotice: boolean) => Promise<boolean>>;
+    /**
+     * Event triggered when the database is being reset.
+     */
+    readonly onResetDatabase: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(db: import("../../pouchdb/LiveSyncLocalDB.js").LiveSyncLocalDB) => Promise<boolean>>;
+    /**
+     * Event triggered when the database is ready for use.
+     */
+    readonly onDatabaseHasReady: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Initialize the database.
+     * @param showingNotice Whether to show a notice to the user.
+     * @param reopenDatabase Whether to reopen the database if it is already open.
+     * @param ignoreSuspending Whether to ignore any suspending state.
+     */
+    readonly initialiseDatabase: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean) => Promise<boolean>>;
+}

package/dist/services/base/DatabaseEventService.js

@@ -0,0 +1,38 @@
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+class DatabaseEventService extends ServiceBase {
+  /**
+   * Event triggered when the database is about to be unloaded.
+   */
+  onUnloadDatabase = handlers().all("onUnloadDatabase");
+  /**
+   * Event triggered when the database is about to be closed.
+   */
+  onCloseDatabase = handlers().all("onCloseDatabase");
+  /**
+   * Event triggered when the database is being initialized.
+   */
+  onDatabaseInitialisation = handlers().bailFirstFailure("onDatabaseInitialisation");
+  /**
+   * Event triggered when the database has been initialized.
+   */
+  onDatabaseInitialised = handlers().bailFirstFailure("onDatabaseInitialised");
+  /**
+   * Event triggered when the database is being reset.
+   */
+  onResetDatabase = handlers().bailFirstFailure("onResetDatabase");
+  /**
+   * Event triggered when the database is ready for use.
+   */
+  onDatabaseHasReady = handlers().bailFirstFailure("onDatabaseHasReady");
+  /**
+   * Initialize the database.
+   * @param showingNotice Whether to show a notice to the user.
+   * @param reopenDatabase Whether to reopen the database if it is already open.
+   * @param ignoreSuspending Whether to ignore any suspending state.
+   */
+  initialiseDatabase = handlers().bailFirstFailure("initialiseDatabase");
+}
+export {
+  DatabaseEventService
+};

package/dist/services/base/DatabaseService.d.ts

@@ -0,0 +1,40 @@
+import type { IDatabaseService, IPathService, IVaultService, openDatabaseParameters } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import { LiveSyncLocalDB } from "../../pouchdb/LiveSyncLocalDB.js";
+import type { PouchDBConstructor } from "../../pouchdb/PouchDBConstructor.js";
+import type { SettingService } from "./SettingService.js";
+import type { APIService } from "./APIService.js";
+import type { ObsidianLiveSyncSettings } from "../../common/models/setting.type.js";
+export type DatabaseServiceDependencies = {
+    /** PouchDB with the adapters required by the host runtime already registered. */
+    pouchDB: PouchDBConstructor;
+    path: IPathService;
+    vault: IVaultService;
+    setting: SettingService;
+    API: APIService;
+};
+/**
+ * The DatabaseService provides methods for managing the local database.
+ * Please note that each event of database lifecycle is handled in DatabaseEventService.
+ */
+export declare abstract class DatabaseService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IDatabaseService {
+    _log: (msg: unknown, level?: import("octagonal-wheels/common/logger").LOG_LEVEL, key?: string) => void;
+    constructor(context: T, dependencies: DatabaseServiceDependencies);
+    protected _localDatabase: LiveSyncLocalDB | null;
+    protected services: DatabaseServiceDependencies;
+    onOpenDatabase: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(vaultName: string) => Promise<boolean>>;
+    /**
+     * Called after the local database has been reset.
+     */
+    onDatabaseReset: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    get localDatabase(): LiveSyncLocalDB;
+    get localDatabaseDirect(): LiveSyncLocalDB;
+    protected modifyDatabaseOptions(settings: ObsidianLiveSyncSettings, name: string, options: PouchDB.Configuration.DatabaseConfiguration): {
+        name: string;
+        options: PouchDB.Configuration.DatabaseConfiguration;
+    };
+    createPouchDBInstance<T extends object>(name?: string, options?: PouchDB.Configuration.DatabaseConfiguration): PouchDB.Database<T>;
+    openDatabase(params: openDatabaseParameters): Promise<boolean>;
+    isDatabaseReady(): boolean;
+    resetDatabase(): Promise<boolean>;
+}

package/dist/services/base/DatabaseService.js

@@ -0,0 +1,79 @@
+import { ServiceBase } from "./ServiceBase.js";
+import { LiveSyncLocalDB } from "../../pouchdb/LiveSyncLocalDB.js";
+import { handlers } from "../lib/HandlerUtils.js";
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+import { ExtraSuffixIndexedDB } from "../../common/models/shared.const.js";
+class DatabaseService extends ServiceBase {
+  _log = createInstanceLogFunction("InjectableDatabaseService");
+  constructor(context, dependencies) {
+    super(context);
+    this.services = dependencies;
+  }
+  _localDatabase = null;
+  services;
+  // Additional process when opening database, such as initialising managers or local database instance.
+  onOpenDatabase = handlers().bailFirstFailure("onOpenDatabase");
+  /**
+   * Called after the local database has been reset.
+   */
+  onDatabaseReset = handlers().bailFirstFailure("onDatabaseReset");
+  get localDatabase() {
+    if (!this._localDatabase) {
+      throw new Error("Local database is not ready yet.");
+    }
+    return this._localDatabase;
+  }
+  get localDatabaseDirect() {
+    return this._localDatabase;
+  }
+  modifyDatabaseOptions(settings, name, options) {
+    const optionPass = { ...options };
+    if (settings.useIndexedDBAdapter) {
+      optionPass.adapter = "indexeddb";
+      optionPass.purged_infos_limit = 1;
+      return {
+        name: name + ExtraSuffixIndexedDB,
+        options: optionPass
+      };
+    }
+    return {
+      name,
+      options: optionPass
+    };
+  }
+  createPouchDBInstance(name, options) {
+    const settings = this.services.setting.currentSettings();
+    const optionPass = this.modifyDatabaseOptions(settings, name ?? "", options ?? {});
+    return new this.services.pouchDB(optionPass.name, optionPass.options);
+  }
+  async openDatabase(params) {
+    if (this._localDatabase != null) {
+      await this._localDatabase.close();
+    }
+    const vaultName = this.services.vault.getVaultName();
+    this._log(this.context.translate("moduleLocalDatabase.logWaitingForReady"));
+    const env = {
+      services: {
+        context: this.context,
+        ...this.services,
+        ...params,
+        database: this
+      }
+    };
+    this._localDatabase = new LiveSyncLocalDB(vaultName, env);
+    await this.onOpenDatabase(vaultName);
+    return await this.localDatabase.initializeDatabase();
+  }
+  isDatabaseReady() {
+    return this._localDatabase != null && this._localDatabase.isReady;
+  }
+  async resetDatabase() {
+    if (!this._localDatabase) {
+      return Promise.resolve(true);
+    }
+    return await this._localDatabase.resetDatabase();
+  }
+}
+export {
+  DatabaseService
+};

package/dist/services/base/FileProcessingService.d.ts

@@ -0,0 +1,25 @@
+import type { IFileProcessingService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+/**
+ * File processing service handles file events and processes them accordingly.
+ */
+export declare class FileProcessingService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IFileProcessingService {
+    /**
+     * Process a file event item by the registered handlers.
+     */
+    readonly processFileEvent: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(item: import("../../common/types.js").FileEventItem) => Promise<boolean>>;
+    /**
+     * Process a file event item optionally, if any handler is registered.
+     * i.e., hidden files synchronisation or customisation sync.
+     */
+    readonly processOptionalFileEvent: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(path: import("../../common/types.js").FilePath) => Promise<boolean>>;
+    /**
+     * Commit any pending file events that have been queued for processing.
+     */
+    readonly commitPendingFileEvents: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    batched: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    totalQueued: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    processing: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    totalStorageFileEventCount: number;
+    onStorageFileEvent(): void;
+}

package/dist/services/base/FileProcessingService.js

@@ -0,0 +1,28 @@
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+class FileProcessingService extends ServiceBase {
+  /**
+   * Process a file event item by the registered handlers.
+   */
+  processFileEvent = handlers().anySuccess("processFileEvent");
+  /**
+   * Process a file event item optionally, if any handler is registered.
+   * i.e., hidden files synchronisation or customisation sync.
+   */
+  processOptionalFileEvent = handlers().anySuccess("processOptionalFileEvent");
+  /**
+   * Commit any pending file events that have been queued for processing.
+   */
+  commitPendingFileEvents = handlers().bailFirstFailure("commitPendingFileEvents");
+  batched = reactiveSource(0);
+  totalQueued = reactiveSource(0);
+  processing = reactiveSource(0);
+  totalStorageFileEventCount = 0;
+  onStorageFileEvent() {
+    this.totalStorageFileEventCount++;
+  }
+}
+export {
+  FileProcessingService
+};

package/dist/services/base/IService.d.ts

@@ -0,0 +1,284 @@
+import type { FetchHttpHandler } from "@smithy/fetch-http-handler";
+import { type LOG_LEVEL } from "octagonal-wheels/common/logger";
+import type { AnyEntry, AUTO_MERGED, CouchDBCredentials, diff_result, DocumentID, EntryDoc, EntryHasPath, FileEventItem, FilePath, FilePathWithPrefix, LoadedEntry, MetaEntry, MISSING_OR_ERROR, ObsidianLiveSyncSettings, RemoteDBSettings, TweakValues, UXFileInfo, UXFileInfoStub } from "../../common/types.js";
+import type { LiveSyncLocalDB } from "../../pouchdb/LiveSyncLocalDB.js";
+import type { LiveSyncAbstractReplicator } from "../../replication/LiveSyncAbstractReplicator.js";
+import type { SimpleStore } from "octagonal-wheels/databases/SimpleStoreBase";
+import type { Confirm } from "../../interfaces/Confirm.js";
+import type { ReactiveSource } from "octagonal-wheels/dataobject/reactive";
+import type { ReplicationStatics } from "../../common/models/shared.definition.js";
+import type { ReplicatorService } from "./ReplicatorService.js";
+import type { DatabaseEventService } from "./DatabaseEventService.js";
+import type { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "../../common/models/shared.const.symbols.js";
+import type { AsyncActivityOptions } from "../../interfaces/AsyncActivityRunner.js";
+declare global {
+    interface OPTIONAL_SYNC_FEATURES {
+        DISABLE: "DISABLE";
+    }
+}
+export interface ICommandCompat {
+    id: string;
+    name: string;
+    icon?: string;
+    callback?: () => any;
+    checkCallback?: (checking: boolean) => boolean | void;
+    editorCallback?: (editor: any, ctx: any) => any;
+    editorCheckCallback?: (checking: any, editor: any, ctx: any) => boolean | void;
+}
+export interface IAPIService {
+    getCustomFetchHandler(): FetchHttpHandler;
+    addStatusBarItem(): HTMLElement | undefined;
+    addLog(message: unknown, level: LOG_LEVEL, key?: string): void;
+    isMobile(): boolean;
+    showWindow(type: string): Promise<void>;
+    showWindowOnRight?(type: string): Promise<void>;
+    getAppID(): string;
+    getSystemVaultName(): string;
+    getPlatform(): string;
+    getAppVersion(): string;
+    getPluginVersion(): string;
+    addCommand<TCommand extends ICommandCompat>(command: TCommand): TCommand;
+    registerWindow<T>(type: string, factory: (leaf: T) => unknown): void;
+    addRibbonIcon(icon: string, title: string, callback: (evt: MouseEvent) => unknown): HTMLElement;
+    registerProtocolHandler(action: string, handler: (params: Record<string, string>) => unknown): void;
+    confirm: Confirm;
+    responseCount: ReactiveSource<number>;
+    requestCount: ReactiveSource<number>;
+    isOnline: boolean;
+    webCompatFetch(url: string | Request, opts?: RequestInit): Promise<Response>;
+    nativeFetch(url: string | Request, opts?: RequestInit): Promise<Response>;
+    setInterval(handler: () => void, timeout: number): number;
+    clearInterval(timerId: number): void;
+    getSystemConfigDir(): string;
+}
+export interface IPathService {
+    id2path(id: DocumentID, entry?: EntryHasPath, stripPrefix?: boolean): FilePathWithPrefix;
+    path2id(filename: FilePathWithPrefix | FilePath, prefix?: string): Promise<DocumentID>;
+    getPath(entry: AnyEntry): FilePathWithPrefix;
+    markChangesAreSame(old: UXFileInfo | AnyEntry | FilePathWithPrefix, newMtime: number, oldMtime: number): boolean | undefined;
+    unmarkChanges(file: AnyEntry | FilePathWithPrefix | UXFileInfoStub): void;
+    compareFileFreshness(baseFile: UXFileInfoStub | AnyEntry | undefined, checkTarget: UXFileInfo | AnyEntry | undefined): typeof BASE_IS_NEW | typeof TARGET_IS_NEW | typeof EVEN;
+    isMarkedAsSameChanges(file: UXFileInfoStub | AnyEntry | FilePathWithPrefix, mtimes: number[]): undefined | typeof EVEN;
+}
+export interface openDatabaseParameters {
+    replicator: ReplicatorService;
+    databaseEvents: DatabaseEventService;
+}
+export interface IDatabaseService {
+    localDatabase: LiveSyncLocalDB;
+    createPouchDBInstance<T extends object>(name?: string, options?: PouchDB.Configuration.DatabaseConfiguration): PouchDB.Database<T>;
+    openDatabase(params: openDatabaseParameters): Promise<boolean>;
+    resetDatabase(): Promise<boolean>;
+    onDatabaseReset: () => Promise<boolean>;
+    onOpenDatabase: (vaultName: string) => Promise<boolean>;
+    isDatabaseReady(): boolean;
+}
+export interface IDatabaseEventService {
+    onUnloadDatabase(db: LiveSyncLocalDB): Promise<boolean>;
+    onCloseDatabase(db: LiveSyncLocalDB): Promise<boolean>;
+    onDatabaseInitialisation(db: LiveSyncLocalDB): Promise<boolean>;
+    onDatabaseInitialised(showNotice: boolean): Promise<boolean>;
+    onDatabaseHasReady(): Promise<boolean>;
+    onResetDatabase(db: LiveSyncLocalDB): Promise<boolean>;
+    initialiseDatabase(showingNotice?: boolean, reopenDatabase?: boolean, ignoreSuspending?: boolean): Promise<boolean>;
+}
+export interface IKeyValueDBService {
+    openSimpleStore<T>(kind: string): SimpleStore<T>;
+    simpleStore: SimpleStore<unknown>;
+}
+export interface IFileProcessingService {
+    processFileEvent(item: FileEventItem): Promise<boolean>;
+    processOptionalFileEvent(path: FilePath): Promise<boolean>;
+    commitPendingFileEvents(): Promise<boolean>;
+    batched: ReactiveSource<number>;
+    processing: ReactiveSource<number>;
+    totalQueued: ReactiveSource<number>;
+    totalStorageFileEventCount: number;
+    onStorageFileEvent(): void;
+}
+export interface IReplicatorService {
+    onCloseActiveReplication(): Promise<boolean>;
+    onReplicatorInitialised(): Promise<boolean>;
+    getNewReplicator(settingOverride?: Partial<ObsidianLiveSyncSettings>): Promise<LiveSyncAbstractReplicator | undefined | false>;
+    getActiveReplicator(): LiveSyncAbstractReplicator | undefined;
+    replicationStatics: ReactiveSource<ReplicationStatics>;
+    /** Number of finite remote operations currently in progress. */
+    boundedRemoteActivityCount: ReactiveSource<number>;
+    /** Number of finite replication operations which can still deliver database documents. */
+    finiteReplicationActivityCount: ReactiveSource<number>;
+    /** Runs a finite remote operation within the host activity policy. */
+    runBoundedRemoteActivity<T>(task: () => T | PromiseLike<T>, options?: AsyncActivityOptions): Promise<T>;
+    /** Runs finite replication which may place documents in the local database. */
+    runFiniteReplicationActivity<T>(task: () => T | PromiseLike<T>, options?: AsyncActivityOptions): Promise<T>;
+}
+export interface IReplicationService {
+    processSynchroniseResult(doc: MetaEntry): Promise<boolean>;
+    processOptionalSynchroniseResult(doc: LoadedEntry): Promise<boolean>;
+    processVirtualDocument(docs: PouchDB.Core.ExistingDocument<EntryDoc>): Promise<boolean>;
+    onBeforeReplicate(showMessage: boolean): Promise<boolean>;
+    checkConnectionFailure(): Promise<boolean | "CHECKAGAIN" | undefined>;
+    onCheckReplicationReady(showMessage: boolean): Promise<boolean>;
+    isReplicationReady(showMessage: boolean): Promise<boolean>;
+    performReplication(showMessage?: boolean): Promise<boolean | void>;
+    replicate(showMessage?: boolean): Promise<boolean | void>;
+    replicateByEvent(showMessage?: boolean): Promise<boolean | void>;
+    onReplicationFailed(showMessage?: boolean): Promise<boolean>;
+    parseSynchroniseResult(docs: Array<PouchDB.Core.ExistingDocument<EntryDoc>>): Promise<boolean>;
+    databaseQueueCount: ReactiveSource<number>;
+    storageApplyingCount: ReactiveSource<number>;
+    replicationResultCount: ReactiveSource<number>;
+    replicateAllToRemote(showingNotice?: boolean, sendChunksInBulkDisabled?: boolean): Promise<boolean>;
+    replicateAllFromRemote(showingNotice?: boolean): Promise<boolean>;
+    markLocked(lockByClean?: boolean): Promise<void>;
+    markUnlocked(): Promise<void>;
+    markResolved(): Promise<void>;
+}
+export interface IRemoteService {
+    connect(uri: string, auth: CouchDBCredentials, disableRequestURI: boolean, passphrase: string | false, useDynamicIterationCount: boolean, performSetup: boolean, skipInfo: boolean, compression: boolean, customHeaders: Record<string, string>, useRequestAPI: boolean, getPBKDF2Salt: () => Promise<Uint8Array<ArrayBuffer>>): Promise<string | {
+        db: PouchDB.Database<EntryDoc>;
+        info: PouchDB.Core.DatabaseInfo;
+    }>;
+    /**
+     * State if the last POST request failed due to payload size.
+     */
+    get hadLastPostFailedBySize(): boolean;
+}
+export interface IConflictService {
+    getOptionalConflictCheckMethod(path: FilePathWithPrefix): Promise<boolean | undefined | "newer">;
+    resolveByUserInteraction: (filename: FilePathWithPrefix, conflictCheckResult: diff_result) => Promise<boolean | undefined>;
+    queueCheckForIfOpen(path: FilePathWithPrefix): Promise<void>;
+    queueCheckFor(path: FilePathWithPrefix): Promise<void>;
+    ensureAllProcessed(): Promise<boolean>;
+    resolveByDeletingRevision(path: FilePathWithPrefix, deleteRevision: string, title: string): Promise<typeof MISSING_OR_ERROR | typeof AUTO_MERGED>;
+    resolve(filename: FilePathWithPrefix): Promise<void>;
+    resolveByNewest(filename: FilePathWithPrefix): Promise<boolean>;
+    resolveAllConflictedFilesByNewerOnes(): Promise<void>;
+    conflictProcessQueueCount: ReactiveSource<number>;
+}
+export interface IAppLifecycleService {
+    onLayoutReady(): Promise<boolean>;
+    onFirstInitialise(): Promise<boolean>;
+    onReady(): Promise<boolean>;
+    onWireUpEvents(): Promise<boolean>;
+    onInitialise(): Promise<boolean>;
+    onLoad(): Promise<boolean>;
+    onSettingLoaded(): Promise<boolean>;
+    onLoaded(): Promise<boolean>;
+    onScanningStartupIssues(): Promise<boolean>;
+    onAppUnload(): Promise<undefined[]>;
+    onBeforeUnload(): Promise<boolean>;
+    onUnload(): Promise<boolean>;
+    onSuspending(): Promise<boolean>;
+    onResuming(): Promise<boolean>;
+    onResumed(): Promise<boolean>;
+    getUnresolvedMessages: () => Promise<(string | Error)[][]>;
+    performRestart(): void;
+    askRestart(message?: string): void;
+    scheduleRestart(): void;
+    isSuspended(): boolean;
+    setSuspended(suspend: boolean): void;
+    isReady(): boolean;
+    markIsReady(): void;
+    resetIsReady(): void;
+    isReloadingScheduled(): boolean;
+}
+export interface ISettingService {
+    onBeforeRealiseSetting(): Promise<boolean>;
+    onSettingRealised(): Promise<boolean>;
+    onRealiseSetting(): Promise<boolean>;
+    suspendAllSync(): Promise<boolean>;
+    suspendExtraSync(): Promise<boolean>;
+    suggestOptionalFeatures(opt: {
+        enableFetch?: boolean;
+        enableOverwrite?: boolean;
+    }): Promise<boolean>;
+    enableOptionalFeature(mode: keyof OPTIONAL_SYNC_FEATURES): Promise<boolean>;
+    clearUsedPassphrase(): void;
+    decryptSettings(settings: ObsidianLiveSyncSettings): Promise<ObsidianLiveSyncSettings>;
+    adjustSettings(settings: ObsidianLiveSyncSettings): Promise<ObsidianLiveSyncSettings>;
+    loadSettings(): Promise<void>;
+    getDeviceAndVaultName(): string;
+    setDeviceAndVaultName(name: string): void;
+    saveDeviceAndVaultName(): void;
+    onBeforeSaveSettingData(nextSettings: ObsidianLiveSyncSettings, previousSettings: ObsidianLiveSyncSettings): Promise<(Partial<ObsidianLiveSyncSettings> | void)[]>;
+    saveSettingData(): Promise<void>;
+    currentSettings(): ObsidianLiveSyncSettings;
+    updateSettings(updateFn: (current: ObsidianLiveSyncSettings) => ObsidianLiveSyncSettings, saveImmediately?: boolean): Promise<void>;
+    applyExternalSettings(partial: Partial<ObsidianLiveSyncSettings>, saveImmediately?: boolean): Promise<void>;
+    applyPartial(partial: Partial<ObsidianLiveSyncSettings>, saveImmediately?: boolean): Promise<void>;
+    onSettingLoaded(settings: ObsidianLiveSyncSettings): Promise<boolean>;
+    onSettingChanged(settings: ObsidianLiveSyncSettings): Promise<boolean>;
+    onSettingSaved(settings: ObsidianLiveSyncSettings): Promise<boolean>;
+    getSmallConfig(key: string): string | null;
+    setSmallConfig(key: string, value: string): void;
+    deleteSmallConfig(key: string): void;
+}
+export interface ITweakValueService {
+    fetchRemotePreferred(trialSetting: RemoteDBSettings): Promise<TweakValues | false>;
+    checkAndAskResolvingMismatched(preferred: Partial<TweakValues>): Promise<[TweakValues | boolean, boolean]>;
+    askResolvingMismatched(preferredSource: TweakValues): Promise<"OK" | "CHECKAGAIN" | "IGNORE">;
+    checkAndAskUseRemoteConfiguration(settings: RemoteDBSettings): Promise<{
+        result: false | TweakValues;
+        requireFetch: boolean;
+    }>;
+    askUseRemoteConfiguration(trialSetting: RemoteDBSettings, preferred: TweakValues): Promise<{
+        result: false | TweakValues;
+        requireFetch: boolean;
+    }>;
+}
+export interface IVaultService {
+    vaultName(): string;
+    getVaultName(): string;
+    scanVault(showingNotice?: boolean, ignoreSuspending?: boolean): Promise<boolean>;
+    isIgnoredByIgnoreFile(file: string | UXFileInfoStub): Promise<boolean>;
+    isTargetFile(file: string | UXFileInfoStub): Promise<boolean>;
+    isTargetFileInExtra(file: string | UXFileInfoStub): Promise<boolean>;
+    isFileSizeTooLarge(size: number): boolean;
+    getActiveFilePath(): FilePath | undefined;
+    isStorageInsensitive(): boolean;
+    shouldCheckCaseInsensitively(): boolean;
+    isValidPath(path: string): boolean;
+}
+export interface ITestService {
+    test(): Promise<boolean>;
+    testMultiDevice(): Promise<boolean>;
+    addTestResult(name: string, key: string, result: boolean, summary?: string, message?: string): void;
+}
+export interface IUIService {
+    promptCopyToClipboard(title: string, value: string): Promise<boolean>;
+    showMarkdownDialog<T extends string[]>(title: string, contentMD: string, buttons: T): Promise<(typeof buttons)[number] | false>;
+    get confirm(): Confirm;
+}
+export interface IConfigService {
+    getSmallConfig(key: string): string | null;
+    setSmallConfig(key: string, value: string): void;
+    deleteSmallConfig(key: string): void;
+}
+export interface IServiceHub {
+    API: IAPIService;
+    path: IPathService;
+    database: IDatabaseService;
+    databaseEvents: IDatabaseEventService;
+    replicator: IReplicatorService;
+    fileProcessing: IFileProcessingService;
+    replication: IReplicationService;
+    remote: IRemoteService;
+    conflict: IConflictService;
+    appLifecycle: IAppLifecycleService;
+    setting: ISettingService;
+    tweakValue: ITweakValueService;
+    vault: IVaultService;
+    test: ITestService;
+    UI: IUIService;
+    config: IConfigService;
+    keyValueDB: IKeyValueDBService;
+    control: IControlService;
+}
+export interface IControlService {
+    applySettings(): Promise<void>;
+    onLoad(): Promise<boolean>;
+    onReady(): Promise<boolean>;
+    onUnload(): Promise<void>;
+    hasUnloaded(): boolean;
+    activated: Promise<boolean>;
+}

package/dist/services/base/IService.js

@@ -0,0 +1 @@
+import {} from "octagonal-wheels/common/logger";

package/dist/services/base/KeyValueDBService.d.ts

@@ -0,0 +1,42 @@
+import type { SimpleStore } from "../../common/utils.js";
+import type { IKeyValueDBService, IVaultService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import type { KeyValueDatabase, KeyValueDatabaseFactory } from "../../interfaces/KeyValueDatabase.js";
+import type { InjectableDatabaseEventService } from "../implements/injectable/InjectableDatabaseEventService.js";
+import type { AppLifecycleServiceBase } from "../implements/injectable/InjectableAppLifecycleService.js";
+export interface KeyValueDBDependencies<T extends ServiceContext = ServiceContext> {
+    openKeyValueDatabase: KeyValueDatabaseFactory;
+    databaseEvents: InjectableDatabaseEventService<T>;
+    vault: IVaultService;
+    appLifecycle: AppLifecycleServiceBase<T>;
+}
+/**
+ * The KeyValueDBService provides methods for managing the local key-value database.
+ * Please note that each event of database lifecycle is handled in DatabaseEventService.
+ */
+export declare abstract class KeyValueDBService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IKeyValueDBService {
+    private _kvDB;
+    private _simpleStore;
+    get simpleStore(): SimpleStore<unknown, any>;
+    get kvDB(): KeyValueDatabase;
+    private databaseEvents;
+    private vault;
+    private appLifecycle;
+    private openKeyValueDatabase;
+    private _log;
+    private _everyOnResetDatabase;
+    private tryCloseKvDB;
+    private openKeyValueDB;
+    private _onOtherDatabaseUnload;
+    private _onOtherDatabaseClose;
+    private _everyOnInitializeDatabase;
+    private _everyOnloadAfterLoadSettings;
+    constructor(context: T, dependencies: KeyValueDBDependencies<T>);
+    openSimpleStore<T>(kind: string): {
+        get: (key: string) => Promise<T>;
+        set: (key: string, value: unknown) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        keys: (from: string | undefined, to: string | undefined, count?: number) => Promise<string[]>;
+        db: Promise<KeyValueDatabase>;
+    };
+}