@vrtmrz/livesync-commonlib 0.1.0-rc.0

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

@@ -0,0 +1,93 @@
+import type { FetchHttpHandler } from "@smithy/fetch-http-handler";
+import type { LOG_LEVEL } from "../../common/logger.js";
+import type { IAPIService, ICommandCompat } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import type { Confirm } from "../../interfaces/Confirm.js";
+/**
+ * The APIService provides methods for interacting with the plug-in's API,
+ */
+export declare abstract class APIService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IAPIService {
+    /**
+     * Get a custom fetch handler for making HTTP requests (e.g., S3 without CORS issues).
+     */
+    abstract getCustomFetchHandler(): FetchHttpHandler;
+    /**
+     * Add a log entry to the log (Now not used).
+     * @param message The log message.
+     * @param level The log level.
+     * @param key The log key.
+     */
+    abstract addLog(message: unknown, level: LOG_LEVEL, key: string): void;
+    /**
+     * Check if the app is running on a mobile device.
+     * @returns true if running on mobile, false otherwise.
+     */
+    abstract isMobile(): boolean;
+    /**
+     * Show a window (or in Obsidian, a leaf).
+     * @param type The type of window to show.
+     */
+    abstract showWindow(type: string): Promise<void>;
+    /**
+     * Show a window on the right sidebar when supported.
+     * Platforms that do not support sidebars can fall back to showWindow.
+     */
+    showWindowOnRight(type: string): Promise<void>;
+    /**
+     * returns App ID. In Obsidian, it is vault ID.
+     */
+    abstract getAppID(): string;
+    /**
+     * Returns the vaultName which system has identified, without any additional suffix.
+     */
+    abstract getSystemVaultName(): string;
+    /**
+     * Check if the last POST request failed due to payload size.
+     */
+    abstract getPlatform(): string;
+    abstract getAppVersion(): string;
+    abstract getPluginVersion(): string;
+    abstract getCrypto(): Crypto;
+    /**
+     * Register a command to the runtime.
+     * @param command
+     */
+    abstract addCommand<TCommand extends ICommandCompat>(command: TCommand): TCommand;
+    /**
+     * Register a window (or leaf) type to the runtime.
+     * @param type
+     * @param factory
+     */
+    abstract registerWindow<T>(type: string, factory: (leaf: T) => unknown): void;
+    /**
+     * Add a ribbon icon to the UI.
+     * @param icon
+     * @param title
+     * @param callback
+     */
+    abstract addRibbonIcon(icon: string, title: string, callback: (evt: MouseEvent) => unknown): HTMLElement;
+    /**
+     * Register a protocol handler.
+     * @param action The action string for the protocol.
+     * @param handler The handler function for the protocol.
+     */
+    abstract registerProtocolHandler(action: string, handler: (params: Record<string, string>) => unknown): void;
+    /**
+     * Get the basic UI component for showing a confirmation dialog to the user.
+     */
+    abstract get confirm(): Confirm;
+    requestCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    responseCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    get isOnline(): boolean;
+    webCompatFetch(req: string | Request, opts?: RequestInit): Promise<Response>;
+    nativeFetch(req: string | Request, opts?: RequestInit): Promise<Response>;
+    abstract addStatusBarItem(): HTMLElement | undefined;
+    setInterval(handler: () => void, timeout: number): number;
+    clearInterval(timerId: number): void;
+    /**
+     * Get the system configuration directory.
+     * This is used for storing configuration files in a consistent location across platforms.
+     * @returns
+     */
+    getSystemConfigDir(): string;
+}

package/dist/services/base/APIService.js

@@ -0,0 +1,44 @@
+import { ServiceBase } from "./ServiceBase.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+import { _fetch, compatGlobal } from "../../common/coreEnvFunctions.js";
+class APIService extends ServiceBase {
+  /**
+   * Show a window on the right sidebar when supported.
+   * Platforms that do not support sidebars can fall back to showWindow.
+   */
+  showWindowOnRight(type) {
+    return this.showWindow(type);
+  }
+  requestCount = reactiveSource(0);
+  responseCount = reactiveSource(0);
+  get isOnline() {
+    if ("navigator" in compatGlobal) {
+      return compatGlobal.navigator.onLine;
+    }
+    return true;
+  }
+  webCompatFetch(req, opts) {
+    return _fetch(req, opts);
+  }
+  // By default, nativeFetch is not implemented. It can be overridden by platforms that support it (e.g., ObsidianAPIService).
+  nativeFetch(req, opts) {
+    throw new Error("nativeFetch is not implemented for this platform");
+  }
+  setInterval(handler, timeout) {
+    return compatGlobal.setInterval(handler, timeout);
+  }
+  clearInterval(timerId) {
+    compatGlobal.clearInterval(timerId);
+  }
+  /**
+   * Get the system configuration directory.
+   * This is used for storing configuration files in a consistent location across platforms.
+   * @returns
+   */
+  getSystemConfigDir() {
+    return ".livesync";
+  }
+}
+export {
+  APIService
+};

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

@@ -0,0 +1,132 @@
+import type { IAppLifecycleService, ISettingService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+export interface AppLifecycleServiceDependencies {
+    settingService: ISettingService;
+}
+/**
+ * The AppLifecycleService provides methods for managing the plug-in's lifecycle events.
+ */
+export declare abstract class AppLifecycleService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IAppLifecycleService {
+    protected readonly settingService: ISettingService;
+    constructor(context: T, dependencies: AppLifecycleServiceDependencies);
+    /**
+     * Event triggered when the plug-in's layout is ready.
+     * In Obsidian, it is after the workspace is ready.
+     */
+    readonly onLayoutReady: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in is being initialized for the first time.
+     * This is only called once per plug-in lifecycle.
+     */
+    readonly onFirstInitialise: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in is fully ready.
+     * This is called after all initialisation processes are complete.
+     */
+    readonly onReady: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered to wire up necessary event listeners.
+     * This is typically called during the initialisation phase.
+     */
+    readonly onWireUpEvents: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in is being initialised.
+     */
+    readonly onInitialise: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in is loading.
+     * This is typically called during the quite early initialisation phase, before everything.
+     * In Obsidian, it is in the onload() method of the plugin.
+     */
+    readonly onLoad: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in's settings have been loaded and applied.
+     */
+    readonly onSettingLoaded: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in has fully loaded.
+     * This is typically called after all initialisation and loading processes are complete.
+     */
+    readonly onLoaded: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Scan for any startup issues that may affect the plug-in's operation.
+     */
+    readonly onScanningStartupIssues: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in is unloading (e.g., during app shutdown or plug-in disable).
+     * This is typically called during the unload() method of the plugin.
+     * Entry point to unload everything.
+     */
+    readonly onAppUnload: import("../lib/HandlerUtils.js").CollectiveHandlerFunction<() => Promise<undefined[]>, unknown>;
+    /**
+     * Event triggered before the plug-in is unloaded.
+     * This is typically used to perform any necessary cleanup or save state before the plug-in is unloaded.
+     */
+    readonly onBeforeUnload: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the plug-in is being unloaded.
+     */
+    readonly onUnload: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Perform an immediate restart of the application.
+     * Note that this is not graceful, and not only the plug-in. APPLICATION (means Obsidian) will be restarted.
+     */
+    abstract performRestart(): void;
+    /**
+     * Ask the user for a restart.
+     * @param message Optional message to display to the user when asking for a restart.
+     */
+    abstract askRestart(message?: string): void;
+    /**
+     * Schedule a restart of the application.
+     * After the current operation is done, the application will be restarted.
+     * Note that this is not graceful, and not only the plug-in. APPLICATION (means Obsidian) will be restarted.
+     */
+    abstract scheduleRestart(): void;
+    /**
+     * Event triggered when the application is being suspended (e.g., system sleep).
+     */
+    readonly onSuspending: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered when the application is resuming from a suspended state.
+     */
+    readonly onResuming: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered after the application has resumed from a suspended state.
+     */
+    readonly onResumed: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    private _isSuspended;
+    /**
+     * Check if the plug-in is currently suspended.
+     * Also consider the plug-in as suspended if it is not configured, to prevent any issues before configuration.
+     */
+    isSuspended(): boolean;
+    /**
+     * Set the suspension state of the plug-in.
+     * @param suspend Set to true to suspend the plug-in, false to resume.
+     */
+    setSuspended(suspend: boolean): void;
+    private _isReady;
+    /**
+     * Check if the plug-in is ready.
+     * A ready plug-in means it has been fully initialised and is operational.
+     * If not ready, most operations will be blocked.
+     */
+    isReady(): boolean;
+    /**
+     * Mark the plug-in as ready.
+     */
+    markIsReady(): void;
+    /**
+     * Reset the ready state of the plug-in.
+     */
+    resetIsReady(): void;
+    /**
+     * Check if a restart has been scheduled.
+     */
+    abstract isReloadingScheduled(): boolean;
+    /**
+     * Get unresolved error messages.
+     */
+    readonly getUnresolvedMessages: import("../lib/HandlerUtils.js").CollectiveHandlerFunction<() => Promise<(string | Error)[][]>, unknown>;
+}

package/dist/services/base/AppLifecycleService.js

@@ -0,0 +1,123 @@
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+class AppLifecycleService extends ServiceBase {
+  settingService;
+  constructor(context, dependencies) {
+    super(context);
+    this.settingService = dependencies.settingService;
+  }
+  /**
+   * Event triggered when the plug-in's layout is ready.
+   * In Obsidian, it is after the workspace is ready.
+   */
+  onLayoutReady = handlers().bailFirstFailure("onLayoutReady");
+  /**
+   * Event triggered when the plug-in is being initialized for the first time.
+   * This is only called once per plug-in lifecycle.
+   */
+  onFirstInitialise = handlers().bailFirstFailure("onFirstInitialise");
+  /**
+   * Event triggered when the plug-in is fully ready.
+   * This is called after all initialisation processes are complete.
+   */
+  onReady = handlers().bailFirstFailure("onReady");
+  /**
+   * Event triggered to wire up necessary event listeners.
+   * This is typically called during the initialisation phase.
+   */
+  onWireUpEvents = handlers().bailFirstFailure("onWireUpEvents");
+  /**
+   * Event triggered when the plug-in is being initialised.
+   */
+  onInitialise = handlers().bailFirstFailure("onInitialise");
+  /**
+   * Event triggered when the plug-in is loading.
+   * This is typically called during the quite early initialisation phase, before everything.
+   * In Obsidian, it is in the onload() method of the plugin.
+   */
+  onLoad = handlers().bailFirstFailure("onLoad");
+  /**
+   * Event triggered when the plug-in's settings have been loaded and applied.
+   */
+  onSettingLoaded = handlers().bailFirstFailure("onSettingLoaded");
+  /**
+   * Event triggered when the plug-in has fully loaded.
+   * This is typically called after all initialisation and loading processes are complete.
+   */
+  onLoaded = handlers().bailFirstFailure("onLoaded");
+  /**
+   * Scan for any startup issues that may affect the plug-in's operation.
+   */
+  onScanningStartupIssues = handlers().all("onScanningStartupIssues");
+  /**
+   * Event triggered when the plug-in is unloading (e.g., during app shutdown or plug-in disable).
+   * This is typically called during the unload() method of the plugin.
+   * Entry point to unload everything.
+   */
+  onAppUnload = handlers().dispatchParallel("onAppUnload");
+  /**
+   * Event triggered before the plug-in is unloaded.
+   * This is typically used to perform any necessary cleanup or save state before the plug-in is unloaded.
+   */
+  onBeforeUnload = handlers().all("onBeforeUnload");
+  /**
+   * Event triggered when the plug-in is being unloaded.
+   */
+  onUnload = handlers().all("onUnload");
+  /**
+   * Event triggered when the application is being suspended (e.g., system sleep).
+   */
+  onSuspending = handlers().bailFirstFailure("onSuspending");
+  /**
+   * Event triggered when the application is resuming from a suspended state.
+   */
+  onResuming = handlers().bailFirstFailure("onResuming");
+  /**
+   * Event triggered after the application has resumed from a suspended state.
+   */
+  onResumed = handlers().bailFirstFailure("onResumed");
+  _isSuspended = false;
+  /**
+   * Check if the plug-in is currently suspended.
+   * Also consider the plug-in as suspended if it is not configured, to prevent any issues before configuration.
+   */
+  isSuspended() {
+    const settings = this.settingService.currentSettings();
+    return this._isSuspended || !settings?.isConfigured;
+  }
+  /**
+   * Set the suspension state of the plug-in.
+   * @param suspend Set to true to suspend the plug-in, false to resume.
+   */
+  setSuspended(suspend) {
+    this._isSuspended = suspend;
+  }
+  _isReady = false;
+  /**
+   * Check if the plug-in is ready.
+   * A ready plug-in means it has been fully initialised and is operational.
+   * If not ready, most operations will be blocked.
+   */
+  isReady() {
+    return this._isReady;
+  }
+  /**
+   * Mark the plug-in as ready.
+   */
+  markIsReady() {
+    this._isReady = true;
+  }
+  /**
+   * Reset the ready state of the plug-in.
+   */
+  resetIsReady() {
+    this._isReady = false;
+  }
+  /**
+   * Get unresolved error messages.
+   */
+  getUnresolvedMessages = handlers().dispatchParallel("getUnresolvedMessages");
+}
+export {
+  AppLifecycleService
+};

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

@@ -0,0 +1,7 @@
+import type { IConfigService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+export declare abstract class ConfigService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IConfigService {
+    abstract getSmallConfig(key: string): string | null;
+    abstract setSmallConfig(key: string, value: string): void;
+    abstract deleteSmallConfig(key: string): void;
+}

package/dist/services/base/ConfigService.js

@@ -0,0 +1,6 @@
+import { ServiceBase } from "./ServiceBase.js";
+class ConfigService extends ServiceBase {
+}
+export {
+  ConfigService
+};

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

@@ -0,0 +1,54 @@
+import type { FilePathWithPrefix, MISSING_OR_ERROR, AUTO_MERGED } from "../../common/types.js";
+import type { IConflictService } from "./IService.js";
+import { ServiceBase } from "./ServiceBase.js";
+import type { ServiceContext } from "./ServiceBase.js";
+/**
+ * The ConflictService provides methods for handling file conflicts.
+ */
+export declare abstract class ConflictService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IConflictService {
+    /**
+     * Get an optional conflict check method for a given file (virtual) path.
+     */
+    readonly getOptionalConflictCheckMethod: import("../lib/HandlerUtils.js").MultipleHandlerFunction<(path: FilePathWithPrefix) => Promise<boolean | undefined | "newer">, unknown>;
+    /**
+     * Queue a check for conflicts if the file is currently open in the editor.
+     * @param path The file (virtual) path to check for conflicts.
+     */
+    abstract queueCheckForIfOpen(path: FilePathWithPrefix): Promise<void>;
+    /**
+     * Queue a check for conflicts for a given file (virtual) path.
+     * @param path The file (virtual) path to check for conflicts.
+     */
+    abstract queueCheckFor(path: FilePathWithPrefix): Promise<void>;
+    /**
+     * Ensure all queued file conflict checks are processed.
+     */
+    abstract ensureAllProcessed(): Promise<boolean>;
+    /**
+     * Resolve a conflict by user interaction (e.g., showing a modal dialog).
+     * @param filename The file (virtual) path with conflict.
+     * @param conflictCheckResult The result of the conflict check.
+     * @returns A promise that resolves to true if the conflict was resolved, false if not, or undefined if no action was taken.
+     */
+    readonly resolveByUserInteraction: import("../lib/HandlerUtils.js").MultipleHandlerFunction<(filename: FilePathWithPrefix, conflictCheckResult: import("../../common/types.js").diff_result) => Promise<boolean | undefined>, unknown>;
+    /**
+     * Resolve a conflict by deleting a specific revision.
+     * @param path The file (virtual) path with conflict.
+     * @param deleteRevision The revision to delete.
+     * @param title The title of the conflict (for user display).
+     */
+    abstract resolveByDeletingRevision(path: FilePathWithPrefix, deleteRevision: string, title: string): Promise<typeof MISSING_OR_ERROR | typeof AUTO_MERGED>;
+    /**
+     * Resolve a conflict as several possible strategies.
+     * It may involve user interaction (means raising resolveByUserInteraction).
+     * @param filename The file (virtual) path to resolve.
+     */
+    abstract resolve(filename: FilePathWithPrefix): Promise<void>;
+    /**
+     *  Resolve a conflict by choosing the newest version.
+     * @param filename The file (virtual) path to resolve.
+     */
+    abstract resolveByNewest(filename: FilePathWithPrefix): Promise<boolean>;
+    abstract resolveAllConflictedFilesByNewerOnes(): Promise<void>;
+    conflictProcessQueueCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+}

package/dist/services/base/ConflictService.js

@@ -0,0 +1,22 @@
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+class ConflictService extends ServiceBase {
+  /**
+   * Get an optional conflict check method for a given file (virtual) path.
+   */
+  getOptionalConflictCheckMethod = handlers().firstResult(
+    "getOptionalConflictCheckMethod"
+  );
+  /**
+   * Resolve a conflict by user interaction (e.g., showing a modal dialog).
+   * @param filename The file (virtual) path with conflict.
+   * @param conflictCheckResult The result of the conflict check.
+   * @returns A promise that resolves to true if the conflict was resolved, false if not, or undefined if no action was taken.
+   */
+  resolveByUserInteraction = handlers().firstResult("resolveByUserInteraction");
+  conflictProcessQueueCount = reactiveSource(0);
+}
+export {
+  ConflictService
+};

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

@@ -0,0 +1,54 @@
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+import type { APIService } from "./APIService.js";
+import type { DatabaseService } from "./DatabaseService.js";
+import type { IControlService, IFileProcessingService, IReplicatorService, ISettingService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import { type PromiseWithResolvers } from "octagonal-wheels/promises";
+import type { AppLifecycleService } from "./AppLifecycleService.js";
+export interface ControlServiceDependencies {
+    appLifecycleService: AppLifecycleService;
+    replicatorService: IReplicatorService;
+    settingService: ISettingService;
+    databaseService: DatabaseService;
+    fileProcessingService: IFileProcessingService;
+    APIService: APIService;
+}
+/**
+ * The ControlService provides methods for controlling the overall behaviour of the plugin, such as applying settings or handling lifecycle events.
+ */
+export declare class ControlService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IControlService {
+    protected services: ControlServiceDependencies;
+    protected _log: ReturnType<typeof createInstanceLogFunction>;
+    protected _unloaded: boolean;
+    protected _activated: PromiseWithResolvers<boolean>;
+    /**
+     * Check if the plug-in has been unloaded.
+     */
+    hasUnloaded(): boolean;
+    constructor(context: T, dependencies: ControlServiceDependencies);
+    get activated(): Promise<boolean>;
+    private onActivated;
+    /**
+     * Apply current settings to reflect the changes immediately.
+     * @returns
+     */
+    applySettings(): Promise<void>;
+    private _onLiveSyncUnload;
+    /**
+     * Called when the plugin is loaded. It will trigger the app lifecycle event onLoad.
+     * Main process should be called in onReady.
+     * @returns
+     */
+    onLoad(): Promise<boolean>;
+    /**
+     * Main entry point of the plugin. It will trigger the app lifecycle event onReady.
+     * Usually it should be called on `app.workspace.onLayoutReady`
+     * @returns
+     */
+    onReady(): Promise<boolean>;
+    /**
+     * On unload event of the plugin. It will trigger the app lifecycle event onUnload.
+     * @returns
+     */
+    onUnload(): Promise<void>;
+}

package/dist/services/base/ControlService.js

@@ -0,0 +1,103 @@
+import { LOG_LEVEL_URGENT } from "octagonal-wheels/common/logger";
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+import { EVENT_PLATFORM_UNLOADED, EVENT_PLUGIN_UNLOADED } from "../../events/coreEvents.js";
+import { cancelAllPeriodicTask, cancelAllTasks } from "octagonal-wheels/concurrency/task";
+import { stopAllRunningProcessors } from "octagonal-wheels/concurrency/processor";
+import { promiseWithResolvers } from "octagonal-wheels/promises";
+class ControlService extends ServiceBase {
+  services;
+  _log;
+  _unloaded = false;
+  _activated;
+  /**
+   * Check if the plug-in has been unloaded.
+   */
+  hasUnloaded() {
+    return this._unloaded;
+  }
+  constructor(context, dependencies) {
+    super(context);
+    this.services = dependencies;
+    this._log = createInstanceLogFunction("ControlService", this.services.APIService);
+    this._activated = promiseWithResolvers();
+    this.services.appLifecycleService.onLoaded.addHandler(() => {
+      this.onActivated();
+      return Promise.resolve(true);
+    });
+  }
+  get activated() {
+    return this._activated.promise;
+  }
+  onActivated() {
+    this._activated.resolve(true);
+  }
+  /**
+   * Apply current settings to reflect the changes immediately.
+   * @returns
+   */
+  async applySettings() {
+    await this.services.appLifecycleService.onSuspending();
+    await this.services.settingService.onBeforeRealiseSetting();
+    this.services.databaseService.localDatabase.refreshSettings();
+    await this.services.fileProcessingService.commitPendingFileEvents();
+    await this.services.settingService.onRealiseSetting();
+    if (this.services.appLifecycleService.isSuspended()) return;
+    await this.services.appLifecycleService.onResuming();
+    await this.services.appLifecycleService.onResumed();
+    await this.services.settingService.onSettingRealised();
+  }
+  async _onLiveSyncUnload() {
+    this.context.events.emitEvent(EVENT_PLUGIN_UNLOADED);
+    await this.services.appLifecycleService.onBeforeUnload();
+    await Promise.resolve(this.services.appLifecycleService.onAppUnload());
+    cancelAllPeriodicTask();
+    cancelAllTasks();
+    stopAllRunningProcessors();
+    await this.services.appLifecycleService.onUnload();
+    this._unloaded = true;
+    const localDatabase = this.services.databaseService.localDatabaseDirect;
+    if (localDatabase != null) {
+      const activeReplicator = this.services.replicatorService.getActiveReplicator();
+      if (activeReplicator) {
+        activeReplicator.closeReplication();
+      }
+      localDatabase.onunload();
+      await localDatabase.close();
+    }
+    this.context.events.emitEvent(EVENT_PLATFORM_UNLOADED);
+    this.context.events.offAll();
+    this._log(this.context.translate("moduleLiveSyncMain.logUnloadingPlugin"));
+    return;
+  }
+  /**
+   * Called when the plugin is loaded. It will trigger the app lifecycle event onLoad.
+   * Main process should be called in onReady.
+   * @returns
+   */
+  async onLoad() {
+    if (!await this.services.appLifecycleService.onLoad()) {
+      this._log("Self-hosted LiveSync cannot be initialised, exiting loading.", LOG_LEVEL_URGENT);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Main entry point of the plugin. It will trigger the app lifecycle event onReady.
+   * Usually it should be called on `app.workspace.onLayoutReady`
+   * @returns
+   */
+  async onReady() {
+    return await this.services.appLifecycleService.onReady();
+  }
+  /**
+   * On unload event of the plugin. It will trigger the app lifecycle event onUnload.
+   * @returns
+   */
+  async onUnload() {
+    return await this._onLiveSyncUnload();
+  }
+}
+export {
+  ControlService
+};