@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/services/base/ReplicationService.js

@@ -0,0 +1,261 @@
+import {
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_VERBOSE
+} from "../../common/types.js";
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+import { createInstanceLogFunction, MARK_LOG_NETWORK_ERROR } from "../lib/logUtils.js";
+import { UnresolvedErrorManager } from "./UnresolvedErrorManager.js";
+import { isLockAcquired, shareRunningResult } from "octagonal-wheels/concurrency/lock";
+const REPLICATION_ON_EVENT_FORECASTED_TIME = 5e3;
+class ReplicationService extends ServiceBase {
+  _unresolvedErrorManager;
+  showError(msg, max_log_level = LOG_LEVEL_NOTICE) {
+    this._unresolvedErrorManager.showError(msg, max_log_level);
+  }
+  clearErrors() {
+    this._unresolvedErrorManager.clearErrors();
+  }
+  _log;
+  settingService;
+  appLifecycleService;
+  replicatorService;
+  APIService;
+  fileProcessing;
+  databaseService;
+  constructor(context, dependencies) {
+    super(context);
+    this.appLifecycleService = dependencies.appLifecycleService;
+    this.settingService = dependencies.settingService;
+    this.replicatorService = dependencies.replicatorService;
+    this.APIService = dependencies.APIService;
+    this.fileProcessing = dependencies.fileProcessingService;
+    this.databaseService = dependencies.databaseService;
+    this._log = createInstanceLogFunction("ReplicationService", dependencies.APIService);
+    this._unresolvedErrorManager = new UnresolvedErrorManager(dependencies.appLifecycleService, this.context.events);
+  }
+  /**
+   * Process a synchronisation result document.
+   */
+  processSynchroniseResult = handlers().anySuccess("processSynchroniseResult");
+  /**
+   * Process a synchronisation result document for optional entries i.e., hidden files.
+   */
+  processOptionalSynchroniseResult = handlers().anySuccess(
+    "processOptionalSynchroniseResult"
+  );
+  /**
+   * Process an array of synchronisation result documents.
+   * @param docs An array of documents to parse and handle.
+   */
+  parseSynchroniseResult = handlers().all("parseSynchroniseResult");
+  /**
+   * Process a virtual document (e.g., for customisation sync).
+   */
+  processVirtualDocument = handlers().anySuccess("processVirtualDocument");
+  /**
+   * An event triggered before starting replication.
+   */
+  onBeforeReplicate = handlers().bailFirstFailure("onBeforeReplicate");
+  /**
+   *
+   */
+  onCheckReplicationReady = handlers().bailFirstFailure("onCheckReplicationReady");
+  /**
+   *  Check if the replication is ready to start.
+   * @param showMessage Whether to show messages to the user.
+   */
+  async isReplicationReady(showMessage = false) {
+    if (!this.appLifecycleService.isReady()) {
+      this._log(`Not ready`);
+      return false;
+    }
+    const currentSettings = this.settingService.currentSettings();
+    if (isLockAcquired("cleanup")) {
+      this._log(this.context.translate("Replicator.Message.Cleaned"), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    if (currentSettings.versionUpFlash != "") {
+      this._log(this.context.translate("Replicator.Message.VersionUpFlash"), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    if (!await this.fileProcessing.commitPendingFileEvents()) {
+      this.showError(this.context.translate("Replicator.Message.Pending"), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    if (!this.APIService.isOnline) {
+      this.showError("Network is offline", showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO);
+      return false;
+    }
+    if (!await this.onBeforeReplicate(showMessage)) {
+      const hasNetworkError = (await this.appLifecycleService.getUnresolvedMessages()).flat().some((e) => typeof e == "string" && e.indexOf(MARK_LOG_NETWORK_ERROR) !== -1);
+      if (!hasNetworkError) {
+        this.showError(this.context.translate("Replicator.Message.SomeModuleFailed"), LOG_LEVEL_NOTICE);
+      } else {
+        this._log(this.context.translate("Replicator.Message.SomeModuleFailed"), LOG_LEVEL_INFO);
+      }
+      return false;
+    }
+    this.clearErrors();
+    return true;
+  }
+  onReplicationFailed = handlers().bailFirstFailure("onReplicationFailed");
+  async performReplicationRequest(showMessage) {
+    const activeReplicator = this.replicatorService.getActiveReplicator();
+    if (!activeReplicator) {
+      this._log(`No active replicator found`, showMessage ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO);
+      return false;
+    }
+    const settings = this.settingService.currentSettings();
+    return await activeReplicator.openReplication(settings, false, !!showMessage, false);
+  }
+  /**
+   * Perform replication and handle a failed result.
+   * @param showMessage Whether to show replication progress messages.
+   */
+  async performReplication(showMessage) {
+    const result = await this.performReplicationRequest(showMessage);
+    if (!result) return await this.onReplicationFailed(showMessage);
+    return result;
+  }
+  /**
+   * Start the replication process.
+   * @param showMessage Whether to show messages to the user.
+   */
+  async replicate(showMessage) {
+    try {
+      const checkBeforeReplicate = await this.isReplicationReady(showMessage);
+      if (!checkBeforeReplicate) return false;
+      const result = await this.replicatorService.runFiniteReplicationActivity(
+        () => this.performReplicationRequest(showMessage),
+        { label: "replication" }
+      );
+      if (!result) return await this.onReplicationFailed(showMessage);
+      return result;
+    } finally {
+      this.previousReplicated = Date.now();
+    }
+  }
+  previousReplicated = 0;
+  /**
+   * Start the replication process triggered by an event (e.g., file change).
+   * @param showMessage Whether to show messages to the user.
+   */
+  replicateByEvent(showMessage) {
+    return shareRunningResult(`replication`, async () => {
+      const currentSettings = this.settingService.currentSettings();
+      const least = currentSettings.syncMinimumInterval;
+      if (least > 0) {
+        const now = Date.now();
+        const elapsed = now - this.previousReplicated;
+        if (elapsed < least) {
+          this._log(
+            `Replication triggered by event is rate limited. Elapsed: ${elapsed}ms, Least interval: ${least}ms`,
+            LOG_LEVEL_VERBOSE
+          );
+          return Promise.resolve(true);
+        }
+        this.previousReplicated = now + REPLICATION_ON_EVENT_FORECASTED_TIME;
+        return await this.replicate();
+      }
+      return this.replicate();
+    });
+  }
+  /**
+   * Check if there is a connection failure with the remote database.
+   */
+  checkConnectionFailure = handlers().firstResult("checkConnectionFailure");
+  databaseQueueCount = reactiveSource(0);
+  storageApplyingCount = reactiveSource(0);
+  replicationResultCount = reactiveSource(0);
+  getActiveReplicatorFor(usage) {
+    const activeReplicator = this.replicatorService.getActiveReplicator();
+    if (!activeReplicator) {
+      this._log(`Active replicator not found during ${usage}`, LOG_LEVEL_NOTICE);
+      return false;
+    }
+    return activeReplicator;
+  }
+  async replicateAllToRemote(showingNotice = false, sendChunksInBulkDisabled = false) {
+    if (!this.appLifecycleService.isReady()) return false;
+    if (!await this.onBeforeReplicate(showingNotice)) {
+      this._log(this.context.translate("Replicator.Message.SomeModuleFailed"), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const currentSettings = this.settingService.currentSettings();
+    const activeReplicator = this.getActiveReplicatorFor("sending data to remote");
+    if (!activeReplicator) {
+      return false;
+    }
+    if (!sendChunksInBulkDisabled) {
+      if (activeReplicator?.isChunkSendingSupported) {
+        if (await this.APIService.confirm.askYesNoDialog(
+          "Do you want to send all chunks before replication?",
+          {
+            defaultOption: "No",
+            timeout: 20
+          }
+        ) == "yes") {
+          await activeReplicator.sendChunks(currentSettings, void 0, true, 0);
+        }
+      }
+    }
+    const ret = await activeReplicator.replicateAllToServer(currentSettings, showingNotice);
+    if (ret) return true;
+    const checkResult = await this.checkConnectionFailure();
+    if (checkResult == "CHECKAGAIN")
+      return await activeReplicator.replicateAllToServer(currentSettings, showingNotice);
+    return !checkResult;
+  }
+  async replicateAllFromRemote(showingNotice = false) {
+    if (!this.appLifecycleService.isReady()) return false;
+    const activeReplicator = this.getActiveReplicatorFor("fetching data from remote");
+    if (!activeReplicator) {
+      return false;
+    }
+    const currentSettings = this.settingService.currentSettings();
+    const ret = await activeReplicator.replicateAllFromServer(currentSettings, showingNotice);
+    if (ret) return true;
+    const checkResult = await this.checkConnectionFailure();
+    if (checkResult == "CHECKAGAIN")
+      return await activeReplicator.replicateAllFromServer(currentSettings, showingNotice);
+    return !checkResult;
+  }
+  _getReplicatorAndPerform(action, perform) {
+    const activeReplicator = this.getActiveReplicatorFor(action);
+    if (!activeReplicator) {
+      return Promise.resolve();
+    }
+    const currentSettings = this.settingService.currentSettings();
+    return perform(currentSettings, activeReplicator);
+  }
+  async markLocked(lockByClean = false) {
+    return await this._getReplicatorAndPerform(
+      "marking remote locked",
+      async (currentSettings, activeReplicator) => {
+        return await activeReplicator.markRemoteLocked(currentSettings, true, lockByClean);
+      }
+    );
+  }
+  async markUnlocked() {
+    return await this._getReplicatorAndPerform(
+      "marking remote unlocked",
+      async (currentSettings, activeReplicator) => {
+        return await activeReplicator.markRemoteLocked(currentSettings, false, false);
+      }
+    );
+  }
+  async markResolved() {
+    return await this._getReplicatorAndPerform(
+      "marking remote resolved",
+      async (currentSettings, activeReplicator) => {
+        return await activeReplicator.markRemoteResolved(currentSettings);
+      }
+    );
+  }
+}
+export {
+  ReplicationService
+};

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

@@ -0,0 +1,66 @@
+import type { LiveSyncAbstractReplicator } from "../../replication/LiveSyncAbstractReplicator.js";
+import type { IReplicatorService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import type { SettingService } from "./SettingService.js";
+import type { AppLifecycleService } from "./AppLifecycleService.js";
+import { UnresolvedErrorManager } from "./UnresolvedErrorManager.js";
+import type { DatabaseEventService } from "./DatabaseEventService.js";
+import { type AsyncActivityOptions, type AsyncActivityRunner } from "../../interfaces/AsyncActivityRunner.js";
+export interface ReplicatorServiceDependencies {
+    settingService: SettingService;
+    appLifecycleService: AppLifecycleService;
+    databaseEventService: DatabaseEventService;
+    activityRunner?: AsyncActivityRunner;
+}
+/**
+ * The ReplicatorService provides methods for managing replication.
+ */
+export declare abstract class ReplicatorService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IReplicatorService {
+    protected dependencies: ReplicatorServiceDependencies;
+    readonly boundedRemoteActivityCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    readonly finiteReplicationActivityCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+    _log: (msg: unknown, level?: import("octagonal-wheels/common/logger").LOG_LEVEL, key?: string) => void;
+    private settingService;
+    private databaseEventService;
+    private _activeReplicator;
+    private _replicatorType;
+    private appLifecycleService;
+    _unresolvedErrorManager: UnresolvedErrorManager;
+    constructor(context: T, dependencies: ReplicatorServiceDependencies);
+    /**
+     * Runs one finite remote operation while exposing its lifetime to host policy and status UI.
+     * Continuous replication must not use this boundary.
+     */
+    runBoundedRemoteActivity<TValue>(task: () => TValue | PromiseLike<TValue>, options?: AsyncActivityOptions): Promise<TValue>;
+    /** Runs one finite replication and exposes its document-delivery lifetime. */
+    runFiniteReplicationActivity<TValue>(task: () => TValue | PromiseLike<TValue>, options?: AsyncActivityOptions): Promise<TValue>;
+    private runRemoteActivity;
+    private suspendReplication;
+    private reinitialiseReplicator;
+    private disposeReplicator;
+    private _initialiseReplicator;
+    /**
+     * Close the active replication if any.
+     * Not used currently.
+     */
+    readonly onCloseActiveReplication: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Get a new replicator instance based on the provided settings.
+     */
+    readonly getNewReplicator: import("../lib/HandlerUtils.js").MultipleHandlerFunction<(settingOverride?: Partial<import("../../common/types.js").ObsidianLiveSyncSettings>) => Promise<LiveSyncAbstractReplicator | undefined | false>, unknown>;
+    readonly onReplicatorInitialised: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Get the currently active replicator instance.
+     * If no active replicator, return undefined but that is the fatal situation (on Obsidian).
+     */
+    getActiveReplicator(): LiveSyncAbstractReplicator | undefined;
+    replicationStatics: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<{
+        sent: number;
+        arrived: number;
+        maxPullSeq: number;
+        maxPushSeq: number;
+        lastSyncPullSeq: number;
+        lastSyncPushSeq: number;
+        syncStatus: import("../../common/types.js").DatabaseConnectingStatus;
+    }>;
+}

package/dist/services/base/ReplicatorService.js

@@ -0,0 +1,164 @@
+import { handlers } from "../lib/HandlerUtils.js";
+import { ServiceBase } from "./ServiceBase.js";
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+import { UnresolvedErrorManager } from "./UnresolvedErrorManager.js";
+import { yieldMicrotask } from "octagonal-wheels/promises";
+import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../common/logger.js";
+import { RemoteTypes } from "../../common/types.js";
+import { DEFAULT_REPLICATION_STATICS } from "../../common/models/shared.definition.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+import {
+  runWithOptionalActivity
+} from "../../interfaces/AsyncActivityRunner.js";
+class ReplicatorService extends ServiceBase {
+  constructor(context, dependencies) {
+    super(context);
+    this.dependencies = dependencies;
+    this.appLifecycleService = dependencies.appLifecycleService;
+    this._unresolvedErrorManager = new UnresolvedErrorManager(dependencies.appLifecycleService, this.context.events);
+    this.settingService = dependencies.settingService;
+    this.settingService.onRealiseSetting.addHandler(this._initialiseReplicator.bind(this));
+    this.databaseEventService = dependencies.databaseEventService;
+    this.databaseEventService.onResetDatabase.addHandler(this.disposeReplicator.bind(this));
+    this.databaseEventService.onDatabaseInitialisation.addHandler(this.disposeReplicator.bind(this));
+    this.databaseEventService.onDatabaseInitialised.addHandler(this.reinitialiseReplicator.bind(this));
+    this.databaseEventService.onDatabaseHasReady.addHandler(this.reinitialiseReplicator.bind(this));
+    this.appLifecycleService.onSuspending.addHandler(this.suspendReplication.bind(this));
+  }
+  dependencies;
+  boundedRemoteActivityCount = reactiveSource(0);
+  finiteReplicationActivityCount = reactiveSource(0);
+  _log = createInstanceLogFunction("ReplicatorService");
+  settingService;
+  databaseEventService;
+  _activeReplicator;
+  _replicatorType;
+  appLifecycleService;
+  _unresolvedErrorManager;
+  /**
+   * Runs one finite remote operation while exposing its lifetime to host policy and status UI.
+   * Continuous replication must not use this boundary.
+   */
+  async runBoundedRemoteActivity(task, options) {
+    return await this.runRemoteActivity(task, options, false);
+  }
+  /** Runs one finite replication and exposes its document-delivery lifetime. */
+  async runFiniteReplicationActivity(task, options) {
+    return await this.runRemoteActivity(task, options, true);
+  }
+  async runRemoteActivity(task, options, isFiniteReplication) {
+    this.boundedRemoteActivityCount.value++;
+    if (isFiniteReplication) {
+      this.finiteReplicationActivityCount.value++;
+    }
+    try {
+      return await runWithOptionalActivity(this.dependencies.activityRunner, task, options);
+    } finally {
+      if (isFiniteReplication) {
+        this.finiteReplicationActivityCount.value--;
+      }
+      this.boundedRemoteActivityCount.value--;
+    }
+  }
+  suspendReplication() {
+    const activeReplicator = this._activeReplicator;
+    if (activeReplicator) {
+      activeReplicator.closeReplication();
+    }
+    return Promise.resolve(true);
+  }
+  async reinitialiseReplicator() {
+    await this.disposeReplicator();
+    await yieldMicrotask();
+    return this._initialiseReplicator();
+  }
+  async disposeReplicator() {
+    this._log("Detect database reset, closing active replicator if exists.");
+    if (this._activeReplicator) {
+      await Promise.resolve(this._activeReplicator.closeReplication());
+    }
+    this._activeReplicator = void 0;
+    this._replicatorType = void 0;
+    return true;
+  }
+  async _initialiseReplicator() {
+    const message = this.context.translate("Replicator.Message.InitialiseFatalError");
+    const setting = this.settingService.currentSettings();
+    if (!setting) {
+      this._activeReplicator = void 0;
+      this._replicatorType = void 0;
+      this._unresolvedErrorManager.clearError(message);
+      return true;
+    }
+    const replicatorType = setting.remoteType;
+    const isCouchDBConfigured = replicatorType === RemoteTypes.REMOTE_COUCHDB && !!setting.couchDB_URI?.trim() && !!setting.couchDB_DBNAME?.trim();
+    const isMinioConfigured = replicatorType === RemoteTypes.REMOTE_MINIO && !!setting.endpoint?.trim() && !!setting.bucket?.trim();
+    const isP2PEnabled = replicatorType === RemoteTypes.REMOTE_P2P && setting.P2P_Enabled;
+    const hasReplicatorConfig = isCouchDBConfigured || isMinioConfigured || isP2PEnabled;
+    if (!hasReplicatorConfig) {
+      this._activeReplicator = void 0;
+      this._replicatorType = void 0;
+      this._unresolvedErrorManager.clearError(message);
+      this._log("No remote replicator configuration found. Skipping replicator initialisation.");
+      return true;
+    }
+    if (replicatorType === this._replicatorType && this._activeReplicator) {
+      this._unresolvedErrorManager.clearError(message);
+      this._log("Active replicator has been kept", LOG_LEVEL_VERBOSE);
+      return true;
+    } else {
+      this._log("Acquiring new replicator");
+      const newReplicator = await this.getNewReplicator();
+      if (!newReplicator) {
+        this._unresolvedErrorManager.showError(message, LOG_LEVEL_NOTICE);
+        return false;
+      }
+      if (this._activeReplicator) {
+        await Promise.resolve(this._activeReplicator.closeReplication());
+        this._log("Active replicator closed", LOG_LEVEL_VERBOSE);
+      }
+      this._activeReplicator = newReplicator;
+      this._replicatorType = replicatorType;
+      this.replicationStatics.value = { ...DEFAULT_REPLICATION_STATICS };
+      await yieldMicrotask();
+      if (!await this.onReplicatorInitialised()) {
+        this._log("Failed to initialise the replicator, onReplicatorInitialised reported some problems.");
+        this._activeReplicator = void 0;
+        this._replicatorType = void 0;
+        this._unresolvedErrorManager.showError(message, LOG_LEVEL_NOTICE);
+        return false;
+      }
+      const remoteTypeDisplay = replicatorType === RemoteTypes.REMOTE_COUCHDB ? "CouchDB" : replicatorType;
+      this._log(`Replicator (${remoteTypeDisplay}) initialised and activated`, LOG_LEVEL_VERBOSE);
+      this._unresolvedErrorManager.clearError(message);
+      return true;
+    }
+  }
+  /**
+   * Close the active replication if any.
+   * Not used currently.
+   */
+  onCloseActiveReplication = handlers().anySuccess("onCloseActiveReplication");
+  /**
+   * Get a new replicator instance based on the provided settings.
+   */
+  getNewReplicator = handlers().firstResult("getNewReplicator");
+  onReplicatorInitialised = handlers().bailFirstFailure("onReplicatorInitialised");
+  /**
+   * Get the currently active replicator instance.
+   * If no active replicator, return undefined but that is the fatal situation (on Obsidian).
+   */
+  getActiveReplicator() {
+    const message = "No replicator has been activated or has not been initialised yet.";
+    if (!this._activeReplicator) {
+      this._unresolvedErrorManager.showError(message, LOG_LEVEL_NOTICE);
+      return void 0;
+    }
+    this._unresolvedErrorManager.clearError(message);
+    return this._activeReplicator;
+  }
+  replicationStatics = reactiveSource({ ...DEFAULT_REPLICATION_STATICS });
+}
+export {
+  ReplicatorService
+};

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

@@ -0,0 +1,33 @@
+import { type LiveSyncEventHub } from "../../hub/hub.js";
+import { type MessageTranslator } from "./MessageTranslator.js";
+/** Capabilities shared by services which belong to one Commonlib client. */
+export interface ServiceContextOptions {
+    /** An isolated event channel. A new channel is created when omitted. */
+    events?: LiveSyncEventHub;
+    /** Host-provided message translation. Keys pass through unchanged when omitted. */
+    translate?: MessageTranslator;
+}
+/**
+ * Minimum host-owned capabilities required by Commonlib service composition.
+ *
+ * Hosts may extend this contract with platform-specific capabilities, but the
+ * event channel and translator remain instance-selected and must be passed
+ * unchanged to every service in one composition.
+ */
+export interface ServiceContextContract {
+    readonly events: LiveSyncEventHub;
+    readonly translate: MessageTranslator;
+}
+/** Instance-owned capabilities shared by a composed set of Commonlib services. */
+export declare class ServiceContext implements ServiceContextContract {
+    readonly events: LiveSyncEventHub;
+    readonly translate: MessageTranslator;
+    constructor(options?: ServiceContextOptions);
+}
+/** Creates a service context without requiring a subclass. */
+export declare function createServiceContext(options?: ServiceContextOptions): ServiceContext;
+export declare abstract class ServiceBase<T extends ServiceContext> {
+    /** Context shared by the services which belong to this composition. */
+    readonly context: T;
+    constructor(context: T);
+}

package/dist/services/base/ServiceBase.js

@@ -0,0 +1,27 @@
+import { createLiveSyncEventHub } from "../../hub/hub.js";
+import {
+  passthroughMessageTranslator
+} from "./MessageTranslator.js";
+class ServiceContext {
+  events;
+  translate;
+  constructor(options = {}) {
+    this.events = options.events ?? createLiveSyncEventHub();
+    this.translate = options.translate ?? passthroughMessageTranslator;
+  }
+}
+function createServiceContext(options = {}) {
+  return new ServiceContext(options);
+}
+class ServiceBase {
+  /** Context shared by the services which belong to this composition. */
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+}
+export {
+  ServiceBase,
+  ServiceContext,
+  createServiceContext
+};

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

@@ -0,0 +1,112 @@
+import { type ObsidianLiveSyncSettings } from "../../common/types.js";
+import type { IAPIService, ISettingService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+export interface SettingServiceDependencies {
+    APIService: IAPIService;
+}
+export declare abstract class SettingService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements ISettingService {
+    deviceAndVaultName: string;
+    protected APIService: IAPIService;
+    protected abstract setItem(key: string, value: string): void;
+    protected abstract getItem(key: string): string;
+    protected abstract deleteItem(key: string): void;
+    _settings: ObsidianLiveSyncSettings;
+    get settings(): ObsidianLiveSyncSettings;
+    set settings(value: ObsidianLiveSyncSettings);
+    protected abstract saveData(setting: ObsidianLiveSyncSettings): Promise<void>;
+    protected abstract loadData(): Promise<ObsidianLiveSyncSettings | undefined>;
+    private _lastPersistedSettings?;
+    _log: ReturnType<typeof createInstanceLogFunction>;
+    constructor(context: T, dependencies: SettingServiceDependencies);
+    /**
+     * Adjust the given settings, e.g., migrate old settings to new format.
+     * @param settings The settings to adjust.
+     */
+    adjustSettings(settings: ObsidianLiveSyncSettings): Promise<ObsidianLiveSyncSettings>;
+    /**
+     * Get the unique name for identify the device.
+     */
+    getDeviceAndVaultName(): string;
+    /**
+     * Set the unique name for identify the device.
+     * @param name The unique name to set.
+     */
+    setDeviceAndVaultName(name: string): void;
+    /**
+     * Save the current device and vault name to settings, aside from the main settings.
+     */
+    saveDeviceAndVaultName(): void;
+    private additionalSuffixOfDatabaseName;
+    private getKey;
+    setSmallConfig(key: string, value: string): void;
+    getSmallConfig(key: string): string;
+    deleteSmallConfig(key: string): void;
+    /**
+     * Save the current settings to storage.
+     */
+    saveSettingData(): Promise<void>;
+    private encryptRemoteConfigurationUris;
+    private decryptRemoteConfigurationUris;
+    /**
+     * Event triggered before realising the settings.
+     * Handlers can return false to abort the realisation process.
+     */
+    readonly onBeforeRealiseSetting: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered after the settings have been realised.
+     */
+    readonly onSettingRealised: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Event triggered to realise the settings.
+     */
+    readonly onRealiseSetting: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Suspend all synchronisation activities and save to the settings.
+     */
+    readonly suspendAllSync: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Suspend extra synchronisation activities, e.g., hidden files sync.
+     */
+    readonly suspendExtraSync: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<() => Promise<boolean>>;
+    /**
+     * Suggest enabling optional features to the user.
+     */
+    readonly suggestOptionalFeatures: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(opt: {
+        enableFetch?: boolean;
+        enableOverwrite?: boolean;
+    }) => Promise<boolean>>;
+    /**
+     * Enable an optional feature and save to the settings.
+     * It may also raised from `handleSuggestOptionalFeatures` if the user agrees.
+     * @param mode The optional feature to enable.
+     */
+    readonly enableOptionalFeature: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(mode: keyof OPTIONAL_SYNC_FEATURES) => Promise<boolean>>;
+    readonly onSettingLoaded: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(settings: ObsidianLiveSyncSettings) => Promise<boolean>>;
+    readonly onSettingChanged: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(settings: ObsidianLiveSyncSettings) => Promise<boolean>>;
+    readonly onSettingSaved: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(settings: ObsidianLiveSyncSettings) => Promise<boolean>>;
+    readonly onBeforeSaveSettingData: import("../lib/HandlerUtils.js").CollectiveHandlerFunction<(nextSettings: ObsidianLiveSyncSettings, previousSettings: ObsidianLiveSyncSettings) => Promise<(Partial<ObsidianLiveSyncSettings> | void)[]>, unknown>;
+    /**
+     * Get the current settings.
+     */
+    currentSettings(): ObsidianLiveSyncSettings;
+    updateSettings(updateFn: (settings: ObsidianLiveSyncSettings) => ObsidianLiveSyncSettings, saveImmediately?: boolean): Promise<void>;
+    applyExternalSettings(partial: Partial<ObsidianLiveSyncSettings>, saveImmediately?: boolean): Promise<void>;
+    applyPartial(partial: Partial<ObsidianLiveSyncSettings>, saveImmediately?: boolean): Promise<void>;
+    getPassphrase(settings: ObsidianLiveSyncSettings): Promise<string | false>;
+    private usedPassphrase;
+    /**
+     * Clear any used passphrase from memory.
+     */
+    clearUsedPassphrase(): void;
+    decryptConfigurationItem(encrypted: string, passphrase: string): Promise<string | false>;
+    encryptConfigurationItem(src: string, settings: ObsidianLiveSyncSettings): Promise<string>;
+    /**
+     * Decrypt the given settings.
+     * @param settings The settings to decrypt.
+     */
+    decryptSettings(settings: ObsidianLiveSyncSettings): Promise<ObsidianLiveSyncSettings>;
+    loadSettings(): Promise<void>;
+    private tryDecodeJson;
+    private cloneSettings;
+}