@vrtmrz/livesync-commonlib 0.1.43 → 0.2.0

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

@@ -1,3 +1,4 @@
+import { type ValueStore, type ValueDeleter } from "@vrtmrz/value-store";
 import { type ConfigPassphraseStore, type ObsidianLiveSyncSettings, type SettingsMigrationState } from "../../common/types.js";
 import type { IAPIService, ISettingService } from "./IService.js";
 import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
@@ -5,6 +6,8 @@ import { createInstanceLogFunction } from "../lib/logUtils.js";
 import { type PersistedSettings } from "../../common/models/setting.policy.js";
 export interface SettingServiceDependencies {
     APIService: IAPIService;
+    /** Host-owned exact-key storage, created once for this application instance. */
+    deviceValues: ValueStore & ValueDeleter;
     /** Optional host hook for applying the loaded display language to its catalogue. */
     onDisplayLanguageChanged?: (language: ObsidianLiveSyncSettings["displayLanguage"]) => void;
 }
@@ -12,9 +15,10 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
     deviceAndVaultName: string;
     protected APIService: IAPIService;
     private readonly onDisplayLanguageChanged?;
-    protected abstract setItem(key: string, value: string): void;
-    protected abstract getItem(key: string): string;
-    protected abstract deleteItem(key: string): void;
+    /** Exact-key device values, including legacy keys outside the Vault namespace. */
+    readonly deviceValues: ValueStore & ValueDeleter;
+    /** Device values scoped by the current Vault name and database suffix. */
+    readonly config: ValueStore & ValueDeleter;
     _settings: ObsidianLiveSyncSettings;
     get settings(): ObsidianLiveSyncSettings;
     set settings(value: ObsidianLiveSyncSettings);
@@ -43,23 +47,9 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
     /**
      * Save the current device and vault name to settings, aside from the main settings.
      */
-    saveDeviceAndVaultName(): void;
-    /**
-     * Read an exact key from the host's device-local configuration store.
-     *
-     * Unlike the main settings document, this state is not synchronised. Callers
-     * which need Vault namespacing should normally use {@link getSmallConfig}.
-     */
-    getDeviceLocalConfig(key: string): string | null;
-    /** Store an exact key in the host's non-synchronised configuration store. */
-    setDeviceLocalConfig(key: string, value: string): void;
-    /** Delete an exact key from the host's non-synchronised configuration store. */
-    deleteDeviceLocalConfig(key: string): void;
+    saveDeviceAndVaultName(): Promise<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.
      */

package/dist/services/base/SettingService.js

@@ -1,3 +1,4 @@
+import { createDeletableValueStore } from "@vrtmrz/value-store";
 import {
   ChunkAlgorithmNames,
   LOG_LEVEL_NOTICE,
@@ -42,6 +43,10 @@ class SettingService extends ServiceBase {
   deviceAndVaultName = "";
   APIService;
   onDisplayLanguageChanged;
+  /** Exact-key device values, including legacy keys outside the Vault namespace. */
+  deviceValues;
+  /** Device values scoped by the current Vault name and database suffix. */
+  config;
   _settings;
   get settings() {
     return this._settings;
@@ -59,6 +64,12 @@ class SettingService extends ServiceBase {
   constructor(context, dependencies) {
     super(context);
     this.APIService = dependencies.APIService;
+    this.deviceValues = dependencies.deviceValues;
+    this.config = createDeletableValueStore({
+      get: (key) => this.deviceValues.getValue(this.getKey(key)),
+      set: (key, value) => this.deviceValues.setValue(this.getKey(key), value),
+      delete: (key) => this.deviceValues.delete(this.getKey(key))
+    });
     this.onDisplayLanguageChanged = dependencies.onDisplayLanguageChanged;
     this._log = createInstanceLogFunction("SettingService", this.APIService);
   }
@@ -111,26 +122,9 @@ class SettingService extends ServiceBase {
   /**
    * Save the current device and vault name to settings, aside from the main settings.
    */
-  saveDeviceAndVaultName() {
+  async saveDeviceAndVaultName() {
     const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
-    this.setDeviceLocalConfig(lsKey, this.deviceAndVaultName);
-  }
-  /**
-   * Read an exact key from the host's device-local configuration store.
-   *
-   * Unlike the main settings document, this state is not synchronised. Callers
-   * which need Vault namespacing should normally use {@link getSmallConfig}.
-   */
-  getDeviceLocalConfig(key) {
-    return this.getItem(key);
-  }
-  /** Store an exact key in the host's non-synchronised configuration store. */
-  setDeviceLocalConfig(key, value) {
-    this.setItem(key, value);
-  }
-  /** Delete an exact key from the host's non-synchronised configuration store. */
-  deleteDeviceLocalConfig(key) {
-    this.deleteItem(key);
+    await this.deviceValues.setValue(lsKey, this.deviceAndVaultName);
   }
   additionalSuffixOfDatabaseName() {
     const suffix = this.settings?.additionalSuffixOfDatabaseName;
@@ -145,18 +139,6 @@ class SettingService extends ServiceBase {
     const addSuffix = this.additionalSuffixOfDatabaseName();
     return `${keyMain}${addSuffix}-${key}`;
   }
-  setSmallConfig(key, value) {
-    const dbKey = this.getKey(key);
-    this.setDeviceLocalConfig(dbKey, value);
-  }
-  getSmallConfig(key) {
-    const dbKey = this.getKey(key);
-    return this.getDeviceLocalConfig(dbKey) ?? "";
-  }
-  deleteSmallConfig(key) {
-    const dbKey = this.getKey(key);
-    this.deleteDeviceLocalConfig(dbKey);
-  }
   /**
    * Save the current settings to storage.
    */
@@ -178,7 +160,7 @@ class SettingService extends ServiceBase {
       if (store !== "" && store !== "LOCALSTORAGE" && store !== "ASK_AT_LAUNCH") {
         throw new Error("The configuration passphrase storage mode is unsupported.");
       }
-      const oldLocalKey = this.getDeviceLocalConfig("ls-setting-passphrase");
+      const oldLocalKey = await this.deviceValues.getValue("ls-setting-passphrase");
       const settings = this.cloneSettings(this.settings);
       let targetKey;
       if (store === "LOCALSTORAGE") {
@@ -196,10 +178,10 @@ class SettingService extends ServiceBase {
       const prepared = await this.prepareSettingSave(settings, targetKey);
       const changesLocalKey = store === "LOCALSTORAGE" && targetKey !== oldLocalKey;
       try {
-        if (changesLocalKey) this.setDeviceLocalConfig("ls-setting-passphrase", targetKey);
+        if (changesLocalKey) await this.deviceValues.setValue("ls-setting-passphrase", targetKey);
         await this.writePreparedSettings(prepared);
       } catch (error) {
-        if (changesLocalKey) this.restoreConfigurationPassphrase(oldLocalKey, error);
+        if (changesLocalKey) await this.restoreConfigurationPassphrase(oldLocalKey, error);
         throw error;
       }
       this.settings.configPassphraseStore = store;
@@ -210,10 +192,10 @@ class SettingService extends ServiceBase {
       throw error;
     });
   }
-  restoreConfigurationPassphrase(previous, cause) {
+  async restoreConfigurationPassphrase(previous, cause) {
     try {
-      if (previous) this.setDeviceLocalConfig("ls-setting-passphrase", previous);
-      else this.deleteDeviceLocalConfig("ls-setting-passphrase");
+      if (previous) await this.deviceValues.setValue("ls-setting-passphrase", previous);
+      else await this.deviceValues.delete("ls-setting-passphrase");
     } catch {
       const message = this.context.translate("SettingService.ConfigurationPassphraseRollbackFailed");
       this._log(message, LOG_LEVEL_URGENT);
@@ -344,9 +326,9 @@ class SettingService extends ServiceBase {
     return { persisted, runtime, patch: savedPatch, passphrase: configurationPassphrase };
   }
   async writePreparedSettings(prepared) {
-    this.saveDeviceAndVaultName();
+    await this.saveDeviceAndVaultName();
     if (prepared.runtime.P2P_DevicePeerName?.trim()) {
-      this.setSmallConfig(SETTING_KEY_P2P_DEVICE_NAME, prepared.runtime.P2P_DevicePeerName.trim());
+      await this.config.setValue(SETTING_KEY_P2P_DEVICE_NAME, prepared.runtime.P2P_DevicePeerName.trim());
     }
     await this.saveData(prepared.persisted);
   }
@@ -528,7 +510,7 @@ class SettingService extends ServiceBase {
   getPassphrase(settings) {
     const methods = {
       "": () => Promise.resolve("*"),
-      LOCALSTORAGE: () => Promise.resolve(this.getDeviceLocalConfig("ls-setting-passphrase") ?? false),
+      LOCALSTORAGE: () => this.deviceValues.getValue("ls-setting-passphrase", ""),
       ASK_AT_LAUNCH: () => this.APIService.confirm.askString(
         this.context.translate("SettingService.ConfigurationPassphraseTitle"),
         "passphrase",
@@ -700,7 +682,7 @@ class SettingService extends ServiceBase {
     } else {
       configuredIdKey(settings);
     }
-    const previous = this.getDeviceLocalConfig("ls-setting-passphrase");
+    const previous = await this.deviceValues.getValue("ls-setting-passphrase");
     let candidate = previous || false;
     let retry = false;
     while (true) {
@@ -710,9 +692,9 @@ class SettingService extends ServiceBase {
           if (result.verified) {
             if (candidate !== previous) {
               try {
-                this.setDeviceLocalConfig("ls-setting-passphrase", candidate);
+                await this.deviceValues.setValue("ls-setting-passphrase", candidate);
               } catch (error) {
-                this.restoreConfigurationPassphrase(previous, error);
+                await this.restoreConfigurationPassphrase(previous, error);
                 throw error;
               }
             }
@@ -788,9 +770,9 @@ class SettingService extends ServiceBase {
     }
     const lsKey = "obsidian-live-sync-vaultanddevicename-" + this.APIService.getSystemVaultName() + this.additionalSuffixOfDatabaseName();
     if (this.settings.deviceAndVaultName != "") {
-      if (!this.getDeviceLocalConfig(lsKey)) {
+      if (!await this.deviceValues.getValue(lsKey)) {
         this.setDeviceAndVaultName(this.settings.deviceAndVaultName);
-        this.saveDeviceAndVaultName();
+        await this.saveDeviceAndVaultName();
         this.settings.deviceAndVaultName = "";
       }
     }
@@ -801,7 +783,7 @@ class SettingService extends ServiceBase {
       );
       this.settings.customChunkSize = 0;
     }
-    this.setDeviceAndVaultName(this.getDeviceLocalConfig(lsKey) || "");
+    this.setDeviceAndVaultName(await this.deviceValues.getValue(lsKey) || "");
     if (this.getDeviceAndVaultName() == "") {
       if (this.settings.usePluginSync) {
         this._log("Device name missing. Disabling plug-in sync.", LOG_LEVEL_NOTICE);

package/dist/services/implements/base/SvelteDialog.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigService } from "../../base/ConfigService.js";
+import type { IConfigService } from "../../base/IService.js";
 import type { AppLifecycleService } from "../../base/AppLifecycleService.js";
 import type { ReplicatorService } from "../../base/ReplicatorService.js";
 import type { Confirm } from "../../../interfaces/Confirm.js";
@@ -9,7 +9,7 @@ import type { Constructor } from "../../../common/utils.type.js";
 export type SvelteDialogManagerDependencies<T extends ServiceContext = ServiceContext> = {
     appLifecycle: AppLifecycleService<T>;
     replicator: ReplicatorService<T>;
-    config: ConfigService<T>;
+    config: IConfigService;
     confirm: Confirm;
     control: IControlService;
 };

package/dist/services/implements/base/UIService.d.ts

@@ -1,4 +1,5 @@
 import type { Confirm } from "../../../interfaces/Confirm.js";
+import { UICommandRegistry } from "../../../uiCommands.js";
 import type { ComponentHasResult, SvelteDialogManager } from "./SvelteDialog.js";
 import type { IAPIService, IUIService } from "../../base/IService.js";
 import { ServiceBase, type ServiceContext } from "../../base/ServiceBase.js";
@@ -12,6 +13,7 @@ type DialogParams = {
     dataToCopy: string;
 };
 export declare abstract class UIService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IUIService {
+    readonly commands: UICommandRegistry;
     private _dialogManager;
     protected _APIService: IAPIService;
     abstract get dialogToCopy(): ComponentHasResult<DialogResult, DialogParams>;

package/dist/services/implements/base/UIService.js

@@ -1,9 +1,14 @@
+import { EVENT_PLUGIN_UNLOADED } from "../../../events/coreEvents.js";
+import { UICommandRegistry } from "../../../uiCommands.js";
 import { ServiceBase } from "../../base/ServiceBase.js";
 class UIService extends ServiceBase {
+  commands;
   _dialogManager;
   _APIService;
   constructor(context, dependents) {
     super(context);
+    this.commands = new UICommandRegistry();
+    this.context.events.once(EVENT_PLUGIN_UNLOADED, () => this.commands.dispose());
     this._dialogManager = dependents.dialogManager;
     this._APIService = dependents.APIService;
   }

package/dist/services/implements/injectable/InjectableServiceHub.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigService } from "../../base/ConfigService.js";
+import type { IConfigService } from "../../base/IService.js";
 import { ControlService } from "../../base/ControlService.js";
 import type { KeyValueDBService } from "../../base/KeyValueDBService.js";
 import { PathService } from "../../base/PathService.js";
@@ -35,7 +35,7 @@ export declare class InjectableServiceHub<T extends ServiceContext = ServiceCont
     protected readonly _vault: InjectableVaultService<T>;
     protected readonly _test: InjectableTestService<T>;
     protected readonly _ui: UIService<T>;
-    protected readonly _config: ConfigService<T>;
+    protected readonly _config: IConfigService;
     protected readonly _keyValueDB: KeyValueDBService<T>;
     protected readonly _control: ControlService<T>;
     get API(): InjectableAPIService<T>;
@@ -55,14 +55,14 @@ export declare class InjectableServiceHub<T extends ServiceContext = ServiceCont
     get control(): ControlService<T>;
     get keyValueDB(): KeyValueDBService<T>;
     get UI(): UIService<T>;
-    get config(): ConfigService<T>;
+    get config(): IConfigService;
     constructor(context: T, services: InjectableServiceInstances<T> & {
         setting: SettingService<T>;
         appLifecycle: AppLifecycleServiceBase<T>;
         path: PathService<T>;
         API: InjectableAPIService<T>;
         ui: UIService<T>;
-        config: ConfigService<T>;
+        config: IConfigService;
         database: DatabaseService<T>;
         remote: InjectableRemoteService<T>;
         vault: InjectableVaultService<T>;

package/dist/services/implements/injectable/InjectableServices.d.ts

@@ -1,6 +1,6 @@
+import type { IConfigService } from "../../base/IService.js";
 import { type ServiceInstances } from "../../ServiceHub.js";
 import type { UIService } from "../base/UIService.js";
-import type { ConfigService } from "../../base/ConfigService.js";
 import type { ServiceContext } from "../../base/ServiceBase.js";
 import type { InjectableAPIService } from "./InjectableAPIService.js";
 import type { InjectableDatabaseEventService } from "./InjectableDatabaseEventService.js";
@@ -32,5 +32,5 @@ export type InjectableServiceInstances<T extends ServiceContext> = ServiceInstan
     vault?: InjectableVaultService<T>;
     test?: InjectableTestService<T>;
     ui?: UIService<T>;
-    config?: ConfigService<T>;
+    config?: IConfigService;
 };

package/dist/services/implements/injectable/InjectableSettingService.d.ts

@@ -4,9 +4,6 @@ import type { ObsidianLiveSyncSettings } from "../../../common/types.js";
 import type { PersistedSettings } from "../../../common/models/setting.policy.js";
 export declare class InjectableSettingService<T extends ServiceContext> extends SettingService<T> {
     constructor(context: T, dependencies: SettingServiceDependencies);
-    protected setItem(key: string, value: string): void;
-    protected getItem(key: string): string;
-    protected deleteItem(key: string): void;
     saveData: import("../../lib/HandlerUtils.js").HandlerFunction<(data: PersistedSettings) => Promise<void>, unknown>;
     loadData: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<ObsidianLiveSyncSettings | undefined>, unknown>;
 }

package/dist/services/implements/injectable/InjectableSettingService.js

@@ -2,7 +2,6 @@ import { EVENT_SETTING_SAVED } from "../../../events/coreEvents.js";
 import { SettingService } from "../../base/SettingService.js";
 import { EVENT_REQUEST_RELOAD_SETTING_TAB } from "../../../events/coreEvents.js";
 import { handlers } from "../../lib/HandlerUtils.js";
-import { compatGlobal } from "../../../common/coreEnvFunctions.js";
 class InjectableSettingService extends SettingService {
   constructor(context, dependencies) {
     super(context, dependencies);
@@ -15,16 +14,6 @@ class InjectableSettingService extends SettingService {
       return Promise.resolve(true);
     });
   }
-  setItem(key, value) {
-    return compatGlobal.localStorage.setItem(key, value);
-  }
-  getItem(key) {
-    return compatGlobal.localStorage.getItem(key) ?? "";
-  }
-  deleteItem(key) {
-    compatGlobal.localStorage.removeItem(key);
-  }
-  // override currentSettings = handlers<SettingService<T>>().binder("currentSettings");
   saveData = handlers().binder("saveData");
   loadData = handlers().binder("loadData");
 }

package/dist/string_and_binary/chunks.js

@@ -404,14 +404,16 @@ async function splitPiecesRabinKarp(dataSrc, absoluteMaxPieceSize, doPlainSplit,
     }
   }
   const chunkUnitBinary = 256 * 1024;
-  const fixedAvgChunkSize = plainSplit ? chunkUnitPlain * 4 : chunkUnitBinary * 4;
   const fixedMaxChunkSize = plainSplit ? chunkUnitPlain * 16 : chunkUnitBinary * 16;
-  const fixedMinChunkSize = plainSplit ? chunkUnitPlain * 2 : chunkUnitBinary;
   const rkAbsoluteMaxPieceSizeFloor = 30 * 1024;
   const effectiveAbsoluteMaxPieceSize = Math.max(absoluteMaxPieceSize, rkAbsoluteMaxPieceSizeFloor);
   const maxChunkSize = Math.min(fixedMaxChunkSize, effectiveAbsoluteMaxPieceSize);
-  const minChunkSize = Math.min(Math.max(fixedMinChunkSize, minimumChunkSize), maxChunkSize);
-  const avgChunkSize = Math.min(Math.max(fixedAvgChunkSize, minChunkSize), maxChunkSize);
+  const proportionalGap = Math.max(1, Math.floor(maxChunkSize / 4));
+  const minChunkSize = Math.min(
+    Math.max(plainSplit ? chunkUnitPlain * 2 : proportionalGap, minimumChunkSize),
+    maxChunkSize
+  );
+  const avgChunkSize = plainSplit ? Math.min(Math.max(chunkUnitPlain * 4, minChunkSize), maxChunkSize) : proportionalGap;
   const windowSize = 48;
   const hashModulus = avgChunkSize;
   const boundaryPattern = 1;
@@ -429,7 +431,7 @@ async function splitPiecesRabinKarp(dataSrc, absoluteMaxPieceSize, doPlainSplit,
   return async function* piecesBlob() {
     while (pos < length) {
       const byte = buffer[pos];
-      if (pos >= start + windowSize) {
+      if (pos >= windowSize) {
         const oldByte = buffer[pos - windowSize];
         const oldByteTerm = Math.imul(oldByte, P_pow_w);
         hash = hash - oldByteTerm | 0;

package/dist/uiCommands.d.ts

@@ -0,0 +1,26 @@
+declare const commandTypes: unique symbol;
+/** An immutable declaration which associates a stable name with request and result types. */
+export interface UICommand<Request, Result> {
+    readonly id: string;
+    readonly [commandTypes]?: {
+        readonly request: (value: Request) => Request;
+        readonly result: (value: Result) => Result;
+    };
+}
+/** Declare a command without registering it in any global state. */
+export declare function declareUICommand<Request, Result>(id: string): UICommand<Request, Result>;
+/** Instance-owned command handlers for one host or service composition. */
+export declare class UICommandRegistry {
+    private readonly definitions;
+    private readonly handlers;
+    private disposed;
+    register<Request, Result>(command: UICommand<Request, Result>, handler: (request: NoInfer<Request>) => NoInfer<Result> | Promise<NoInfer<Result>>): () => void;
+    invoke<Request, Result>(command: UICommand<Request, Result>, input: NoInfer<Request>): Promise<{
+        status: "handled";
+        value: Result;
+    } | {
+        status: "unavailable";
+    }>;
+    dispose(): void;
+}
+export {};

package/dist/uiCommands.js

@@ -0,0 +1,57 @@
+function declareUICommand(id) {
+  return Object.freeze({ id });
+}
+class UICommandRegistry {
+  definitions = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  disposed = false;
+  register(command, handler) {
+    if (this.disposed) {
+      throw new Error("Cannot register a UI command on a disposed registry");
+    }
+    const knownDefinition = this.definitions.get(command.id);
+    if (knownDefinition !== void 0 && knownDefinition !== command) {
+      throw new Error(`A conflicting command definition is already known for '${command.id}'`);
+    }
+    if (this.handlers.has(command.id)) {
+      throw new Error(`A handler is already registered for '${command.id}'`);
+    }
+    this.definitions.set(command.id, command);
+    const entry = {
+      command,
+      handler: (input) => handler(input)
+    };
+    this.handlers.set(command.id, entry);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      if (this.handlers.get(command.id) === entry) {
+        this.handlers.delete(command.id);
+      }
+    };
+  }
+  async invoke(command, input) {
+    if (this.disposed) {
+      return { status: "unavailable" };
+    }
+    const entry = this.handlers.get(command.id);
+    if (entry === void 0 || entry.command !== command) {
+      return { status: "unavailable" };
+    }
+    return {
+      status: "handled",
+      value: await entry.handler(input)
+    };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.handlers.clear();
+    this.definitions.clear();
+  }
+}
+export {
+  UICommandRegistry,
+  declareUICommand
+};