@vrtmrz/livesync-commonlib 0.1.0-rc.0

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

@@ -0,0 +1,12 @@
+import type { UXFileInfo, AnyEntry, UXFileInfoStub, FilePathWithPrefix } from "../../../common/types.js";
+import { PathService } from "../../base/PathService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "../../../common/models/shared.const.symbols.js";
+export declare function compareFileFreshnessGeneric(baseFile: UXFileInfoStub | AnyEntry | undefined, checkTarget: UXFileInfo | AnyEntry | undefined): typeof BASE_IS_NEW | typeof TARGET_IS_NEW | typeof EVEN;
+export declare class PathServiceCompat<T extends ServiceContext> extends PathService<T> {
+    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;
+    normalizePath(path: string): string;
+}

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

@@ -0,0 +1,36 @@
+import { PathService } from "../../base/PathService.js";
+import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "../../../common/models/shared.const.symbols.js";
+import { compareMTime } from "../../../common/utils.js";
+function compareFileFreshnessGeneric(baseFile, checkTarget) {
+  if (baseFile === void 0 && checkTarget == void 0) return EVEN;
+  if (baseFile == void 0) return TARGET_IS_NEW;
+  if (checkTarget == void 0) return BASE_IS_NEW;
+  const modifiedBase = "stat" in baseFile ? baseFile?.stat?.mtime ?? 0 : baseFile?.mtime ?? 0;
+  const modifiedTarget = "stat" in checkTarget ? checkTarget?.stat?.mtime ?? 0 : checkTarget?.mtime ?? 0;
+  if (!modifiedBase && !modifiedTarget) {
+    return EVEN;
+  }
+  return compareMTime(modifiedBase, modifiedTarget);
+}
+class PathServiceCompat extends PathService {
+  markChangesAreSame(old, newMtime, oldMtime) {
+    return void 0;
+  }
+  unmarkChanges(file) {
+    return;
+  }
+  compareFileFreshness(baseFile, checkTarget) {
+    return compareFileFreshnessGeneric(baseFile, checkTarget);
+  }
+  isMarkedAsSameChanges(file, mtimes) {
+    return void 0;
+  }
+  normalizePath(path) {
+    const fPath = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+    return fPath;
+  }
+}
+export {
+  PathServiceCompat,
+  compareFileFreshnessGeneric
+};

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

@@ -0,0 +1,4 @@
+import { RemoteService } from "../../base/RemoteService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+export declare class InjectableRemoteService<T extends ServiceContext> extends RemoteService<T> {
+}

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

@@ -0,0 +1,7 @@
+import { RemoteService } from "../../base/RemoteService.js";
+class InjectableRemoteService extends RemoteService {
+  // connect = handlers<IRemoteService>().binder("connect");
+}
+export {
+  InjectableRemoteService
+};

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

@@ -0,0 +1,4 @@
+import { ReplicationService } from "../../base/ReplicationService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+export declare class InjectableReplicationService<T extends ServiceContext> extends ReplicationService<T> {
+}

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

@@ -0,0 +1,6 @@
+import { ReplicationService } from "../../base/ReplicationService.js";
+class InjectableReplicationService extends ReplicationService {
+}
+export {
+  InjectableReplicationService
+};

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

@@ -0,0 +1,4 @@
+import { ReplicatorService } from "../../base/ReplicatorService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+export declare class InjectableReplicatorService<T extends ServiceContext> extends ReplicatorService<T> {
+}

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

@@ -0,0 +1,7 @@
+import { ReplicatorService } from "../../base/ReplicatorService.js";
+class InjectableReplicatorService extends ReplicatorService {
+  // getActiveReplicator = handlers<IReplicatorService>().binder("getActiveReplicator");
+}
+export {
+  InjectableReplicatorService
+};

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

@@ -0,0 +1,72 @@
+import type { ConfigService } from "../../base/ConfigService.js";
+import { ControlService } from "../../base/ControlService.js";
+import type { KeyValueDBService } from "../../base/KeyValueDBService.js";
+import { PathService } from "../../base/PathService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import type { SettingService } from "../../base/SettingService.js";
+import { ServiceHub } from "../../ServiceHub.js";
+import type { UIService } from "../base/UIService.js";
+import { InjectableAPIService } from "./InjectableAPIService.js";
+import { type AppLifecycleServiceBase } from "./InjectableAppLifecycleService.js";
+import { InjectableConflictService } from "./InjectableConflictService.js";
+import { InjectableDatabaseEventService } from "./InjectableDatabaseEventService.js";
+import { InjectableFileProcessingService } from "./InjectableFileProcessingService.js";
+import type { InjectableRemoteService } from "./InjectableRemoteService.js";
+import { InjectableReplicationService } from "./InjectableReplicationService.js";
+import { InjectableReplicatorService } from "./InjectableReplicatorService.js";
+import type { InjectableServiceInstances } from "./InjectableServices.js";
+import { InjectableTestService } from "./InjectableTestService.js";
+import { InjectableTweakValueService } from "./InjectableTweakValueService.js";
+import { InjectableVaultService } from "./InjectableVaultService.js";
+import type { DatabaseService } from "../../base/DatabaseService.js";
+export declare class InjectableServiceHub<T extends ServiceContext = ServiceContext> extends ServiceHub<T> {
+    protected readonly _api: InjectableAPIService<T>;
+    protected readonly _path: PathService<T>;
+    protected readonly _database: DatabaseService<T>;
+    protected readonly _databaseEvents: InjectableDatabaseEventService<T>;
+    protected readonly _replicator: InjectableReplicatorService<T>;
+    protected readonly _fileProcessing: InjectableFileProcessingService<T>;
+    protected readonly _replication: InjectableReplicationService<T>;
+    protected readonly _remote: InjectableRemoteService<T>;
+    protected readonly _conflict: InjectableConflictService<T>;
+    protected readonly _appLifecycle: AppLifecycleServiceBase<T>;
+    protected readonly _setting: SettingService<T>;
+    protected readonly _tweakValue: InjectableTweakValueService<T>;
+    protected readonly _vault: InjectableVaultService<T>;
+    protected readonly _test: InjectableTestService<T>;
+    protected readonly _ui: UIService<T>;
+    protected readonly _config: ConfigService<T>;
+    protected readonly _keyValueDB: KeyValueDBService<T>;
+    protected readonly _control: ControlService<T>;
+    get API(): InjectableAPIService<T>;
+    get path(): PathService<T>;
+    get database(): DatabaseService<T>;
+    get databaseEvents(): InjectableDatabaseEventService<T>;
+    get replicator(): InjectableReplicatorService<T>;
+    get fileProcessing(): InjectableFileProcessingService<T>;
+    get replication(): InjectableReplicationService<T>;
+    get remote(): InjectableRemoteService<T>;
+    get conflict(): InjectableConflictService<T>;
+    get appLifecycle(): AppLifecycleServiceBase<T>;
+    get setting(): SettingService<T>;
+    get tweakValue(): InjectableTweakValueService<T>;
+    get vault(): InjectableVaultService<T>;
+    get test(): InjectableTestService<T>;
+    get control(): ControlService<T>;
+    get keyValueDB(): KeyValueDBService<T>;
+    get UI(): UIService<T>;
+    get config(): ConfigService<T>;
+    constructor(context: T, services: InjectableServiceInstances<T> & {
+        setting: SettingService<T>;
+        appLifecycle: AppLifecycleServiceBase<T>;
+        path: PathService<T>;
+        API: InjectableAPIService<T>;
+        ui: UIService<T>;
+        config: ConfigService<T>;
+        database: DatabaseService<T>;
+        remote: InjectableRemoteService<T>;
+        vault: InjectableVaultService<T>;
+        keyValueDB: KeyValueDBService<T>;
+        replicator: InjectableReplicatorService<T>;
+    });
+}

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

@@ -0,0 +1,125 @@
+import { ControlService } from "../../base/ControlService.js";
+import { PathService } from "../../base/PathService.js";
+import { ServiceHub } from "../../ServiceHub.js";
+import { InjectableAPIService } from "./InjectableAPIService.js";
+import {} from "./InjectableAppLifecycleService.js";
+import { InjectableConflictService } from "./InjectableConflictService.js";
+import { InjectableDatabaseEventService } from "./InjectableDatabaseEventService.js";
+import { InjectableFileProcessingService } from "./InjectableFileProcessingService.js";
+import { InjectableReplicationService } from "./InjectableReplicationService.js";
+import { InjectableReplicatorService } from "./InjectableReplicatorService.js";
+import { InjectableTestService } from "./InjectableTestService.js";
+import { InjectableTweakValueService } from "./InjectableTweakValueService.js";
+import { InjectableVaultService } from "./InjectableVaultService.js";
+class InjectableServiceHub extends ServiceHub {
+  _api;
+  _path;
+  _database;
+  _databaseEvents;
+  _replicator;
+  _fileProcessing;
+  _replication;
+  _remote;
+  _conflict;
+  _appLifecycle;
+  _setting;
+  _tweakValue;
+  _vault;
+  _test;
+  _ui;
+  _config;
+  _keyValueDB;
+  _control;
+  get API() {
+    return this._api;
+  }
+  get path() {
+    return this._path;
+  }
+  get database() {
+    return this._database;
+  }
+  get databaseEvents() {
+    return this._databaseEvents;
+  }
+  get replicator() {
+    return this._replicator;
+  }
+  get fileProcessing() {
+    return this._fileProcessing;
+  }
+  get replication() {
+    return this._replication;
+  }
+  get remote() {
+    return this._remote;
+  }
+  get conflict() {
+    return this._conflict;
+  }
+  get appLifecycle() {
+    return this._appLifecycle;
+  }
+  get setting() {
+    return this._setting;
+  }
+  get tweakValue() {
+    return this._tweakValue;
+  }
+  get vault() {
+    return this._vault;
+  }
+  get test() {
+    return this._test;
+  }
+  get control() {
+    return this._control;
+  }
+  get keyValueDB() {
+    return this._keyValueDB;
+  }
+  get UI() {
+    return this._ui;
+  }
+  get config() {
+    return this._config;
+  }
+  constructor(context, services) {
+    super(context, services);
+    this._api = services.API;
+    this._path = services.path;
+    this._database = services.database;
+    this._databaseEvents = services.databaseEvents ?? new InjectableDatabaseEventService(context);
+    this._replicator = services.replicator;
+    this._fileProcessing = services.fileProcessing ?? new InjectableFileProcessingService(context);
+    this._conflict = services.conflict ?? new InjectableConflictService(context);
+    this._appLifecycle = services.appLifecycle;
+    this._setting = services.setting;
+    this._remote = services.remote;
+    this._tweakValue = services.tweakValue ?? new InjectableTweakValueService(context);
+    this._replication = services.replication ?? new InjectableReplicationService(context, {
+      APIService: this._api,
+      appLifecycleService: this._appLifecycle,
+      replicatorService: this._replicator,
+      settingService: this._setting,
+      databaseService: this._database,
+      fileProcessingService: this._fileProcessing
+    });
+    this._vault = services.vault;
+    this._test = services.test ?? new InjectableTestService(context);
+    this._ui = services.ui;
+    this._config = services.config;
+    this._keyValueDB = services.keyValueDB;
+    this._control = services.control ?? new ControlService(context, {
+      appLifecycleService: this._appLifecycle,
+      databaseService: this._database,
+      fileProcessingService: this._fileProcessing,
+      settingService: this._setting,
+      APIService: this._api,
+      replicatorService: this._replicator
+    });
+  }
+}
+export {
+  InjectableServiceHub
+};

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

@@ -0,0 +1,36 @@
+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";
+import type { InjectableReplicatorService } from "./InjectableReplicatorService.js";
+import type { InjectableFileProcessingService } from "./InjectableFileProcessingService.js";
+import type { InjectableReplicationService } from "./InjectableReplicationService.js";
+import type { InjectableRemoteService } from "./InjectableRemoteService.js";
+import type { InjectableConflictService } from "./InjectableConflictService.js";
+import type { AppLifecycleServiceBase } from "./InjectableAppLifecycleService.js";
+import type { InjectableTweakValueService } from "./InjectableTweakValueService.js";
+import type { InjectableVaultService } from "./InjectableVaultService.js";
+import type { InjectableTestService } from "./InjectableTestService.js";
+import type { PathService } from "../../base/PathService.js";
+import type { DatabaseService } from "../../base/DatabaseService.js";
+import type { SettingService } from "../../base/SettingService.js";
+export type InjectableServiceInstances<T extends ServiceContext> = ServiceInstances<T> & {
+    API?: InjectableAPIService<T>;
+    path?: PathService<T>;
+    database?: DatabaseService<T>;
+    databaseEvents?: InjectableDatabaseEventService<T>;
+    replicator?: InjectableReplicatorService<T>;
+    fileProcessing?: InjectableFileProcessingService<T>;
+    replication?: InjectableReplicationService<T>;
+    remote?: InjectableRemoteService<T>;
+    conflict?: InjectableConflictService<T>;
+    appLifecycle?: AppLifecycleServiceBase<T>;
+    setting?: SettingService<T>;
+    tweakValue?: InjectableTweakValueService<T>;
+    vault?: InjectableVaultService<T>;
+    test?: InjectableTestService<T>;
+    ui?: UIService<T>;
+    config?: ConfigService<T>;
+};

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

@@ -0,0 +1 @@
+import {} from "../../ServiceHub.js";

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

@@ -0,0 +1,11 @@
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { SettingService, type SettingServiceDependencies } from "../../base/SettingService.js";
+import type { ObsidianLiveSyncSettings } from "../../../common/types.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: ObsidianLiveSyncSettings) => Promise<void>, unknown>;
+    loadData: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<ObsidianLiveSyncSettings | undefined>, unknown>;
+}

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

@@ -0,0 +1,33 @@
+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);
+    this.onSettingSaved.addHandler((settings) => {
+      this.context.events.emitEvent(EVENT_SETTING_SAVED, settings);
+      return Promise.resolve(true);
+    });
+    this.onSettingLoaded.addHandler((settings) => {
+      this.context.events.emitEvent(EVENT_REQUEST_RELOAD_SETTING_TAB);
+      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");
+}
+export {
+  InjectableSettingService
+};

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

@@ -0,0 +1,5 @@
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { TestService } from "../../base/TestService.js";
+export declare class InjectableTestService<T extends ServiceContext> extends TestService<T> {
+    addTestResult: import("../../lib/HandlerUtils.js").HandlerFunction<(name: string, key: string, result: boolean, summary?: string, message?: string) => void, unknown>;
+}

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

@@ -0,0 +1,8 @@
+import { TestService } from "../../base/TestService.js";
+import { handlers } from "../../lib/HandlerUtils.js";
+class InjectableTestService extends TestService {
+  addTestResult = handlers().binder("addTestResult");
+}
+export {
+  InjectableTestService
+};

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

@@ -0,0 +1,15 @@
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { TweakValueService } from "../../base/TweakValueService.js";
+export declare class InjectableTweakValueService<T extends ServiceContext> extends TweakValueService<T> {
+    fetchRemotePreferred: import("../../lib/HandlerUtils.js").HandlerFunction<(trialSetting: import("../../../common/types.js").RemoteDBSettings) => Promise<import("../../../common/types.js").TweakValues | false>, unknown>;
+    checkAndAskResolvingMismatched: import("../../lib/HandlerUtils.js").HandlerFunction<(preferred: Partial<import("../../../common/types.js").TweakValues>) => Promise<[import("../../../common/types.js").TweakValues | boolean, boolean]>, unknown>;
+    askResolvingMismatched: import("../../lib/HandlerUtils.js").HandlerFunction<(preferredSource: import("../../../common/types.js").TweakValues) => Promise<"OK" | "CHECKAGAIN" | "IGNORE">, unknown>;
+    checkAndAskUseRemoteConfiguration: import("../../lib/HandlerUtils.js").HandlerFunction<(settings: import("../../../common/types.js").RemoteDBSettings) => Promise<{
+        result: false | import("../../../common/types.js").TweakValues;
+        requireFetch: boolean;
+    }>, unknown>;
+    askUseRemoteConfiguration: import("../../lib/HandlerUtils.js").HandlerFunction<(trialSetting: import("../../../common/types.js").RemoteDBSettings, preferred: import("../../../common/types.js").TweakValues) => Promise<{
+        result: false | import("../../../common/types.js").TweakValues;
+        requireFetch: boolean;
+    }>, unknown>;
+}

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

@@ -0,0 +1,12 @@
+import { TweakValueService } from "../../base/TweakValueService.js";
+import { handlers } from "../../lib/HandlerUtils.js";
+class InjectableTweakValueService extends TweakValueService {
+  fetchRemotePreferred = handlers().binder("fetchRemotePreferred");
+  checkAndAskResolvingMismatched = handlers().binder("checkAndAskResolvingMismatched");
+  askResolvingMismatched = handlers().binder("askResolvingMismatched");
+  checkAndAskUseRemoteConfiguration = handlers().binder("checkAndAskUseRemoteConfiguration");
+  askUseRemoteConfiguration = handlers().binder("askUseRemoteConfiguration");
+}
+export {
+  InjectableTweakValueService
+};

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

@@ -0,0 +1,9 @@
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { VaultService } from "../../base/VaultService.js";
+export declare abstract class InjectableVaultService<T extends ServiceContext> extends VaultService<T> {
+}
+export declare class InjectableVaultServiceCompat<T extends ServiceContext> extends InjectableVaultService<T> {
+    isStorageInsensitive: import("../../lib/HandlerUtils.js").HandlerFunction<() => boolean, unknown>;
+    getActiveFilePath: import("../../lib/HandlerUtils.js").HandlerFunction<() => import("../../../common/types.js").FilePath | undefined, unknown>;
+    isValidPath(path: string): boolean;
+}

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

@@ -0,0 +1,20 @@
+import { isValidFilenameInWidows } from "../../../string_and_binary/path.js";
+import { VaultService } from "../../base/VaultService.js";
+import { handlers } from "../../lib/HandlerUtils.js";
+class InjectableVaultService extends VaultService {
+  // scanVault = handlers<IVaultService>().binder("scanVault");
+  // isIgnoredByIgnoreFile = handlers<IVaultService>().binder("isIgnoredByIgnoreFile");
+  // isTargetFile = handlers<IVaultService>().bailFirstFailure("isTargetFile");
+  // markFileListPossiblyChanged = handlers<IVaultService>().binder("markFileListPossiblyChanged");
+}
+class InjectableVaultServiceCompat extends InjectableVaultService {
+  isStorageInsensitive = handlers().binder("isStorageInsensitive");
+  getActiveFilePath = handlers().binder("getActiveFilePath");
+  isValidPath(path) {
+    return isValidFilenameInWidows(path);
+  }
+}
+export {
+  InjectableVaultService,
+  InjectableVaultServiceCompat
+};