@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/serviceModules/adapters/IStorageAdapter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Focused compatibility views of the existing storage adapter.
+ *
+ * These interfaces allow internal consumers to depend on fewer operations while
+ * retaining the existing `UXStat`, `UXDataWriteOptions`, and method semantics.
+ * They are not a neutral or extraction-ready storage API. Their names, shared
+ * types, and behavioural contracts may change when the cross-platform contract
+ * is designed and stabilised.
+ *
+ * @packageDocumentation
+ */
+import type { UXDataWriteOptions, UXStat } from "../../common/types.js";
+/** File and directory existence and metadata operations. */
+export interface IStorageMetadataAccess<TStat extends UXStat = UXStat> {
+    exists(path: string): Promise<boolean>;
+    trystat(path: string): Promise<TStat | null>;
+    stat(path: string): Promise<TStat | null>;
+}
+/** Text-file read operation. */
+export interface IStorageTextReadAccess {
+    read(path: string): Promise<string>;
+}
+/** Binary-file read operation. */
+export interface IStorageBinaryReadAccess {
+    readBinary(path: string): Promise<ArrayBuffer>;
+}
+/** Text-file write operation. */
+export interface IStorageTextWriteAccess {
+    write(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+}
+/** Binary-file write operation. */
+export interface IStorageBinaryWriteAccess {
+    writeBinary(path: string, data: ArrayBuffer, options?: UXDataWriteOptions): Promise<void>;
+}
+/** Text-file append operation. */
+export interface IStorageTextAppendAccess {
+    append(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+}
+/** Directory creation and direct-child listing operations. */
+export interface IStorageDirectoryAccess {
+    mkdir(path: string): Promise<void>;
+    list(basePath: string): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+}
+/** File or directory removal operation. */
+export interface IStorageRemoveAccess {
+    remove(path: string): Promise<void>;
+}
+/**
+ * Storage adapter interface
+ * Backwards-compatible aggregate of the focused storage capability views.
+ */
+export interface IStorageAdapter<TStat extends UXStat = UXStat> extends IStorageMetadataAccess<TStat>, IStorageTextReadAccess, IStorageBinaryReadAccess, IStorageTextWriteAccess, IStorageBinaryWriteAccess, IStorageTextAppendAccess, IStorageDirectoryAccess, IStorageRemoveAccess {
+}

package/dist/serviceModules/adapters/ITypeGuardAdapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type guard adapter interface
+ * Provides runtime type checking for native file system objects
+ */
+export interface ITypeGuardAdapter<TNativeFile = unknown, TNativeFolder = unknown> {
+    /**
+     * Check if the given object is a file
+     */
+    isFile(file: unknown): file is TNativeFile;
+    /**
+     * Check if the given object is a folder
+     */
+    isFolder(item: unknown): item is TNativeFolder;
+}

package/dist/serviceModules/adapters/IVaultAdapter.d.ts

@@ -0,0 +1,51 @@
+import type { UXDataWriteOptions } from "../../common/types.js";
+/**
+ * Vault adapter interface
+ * High-level file operations that interact with the vault layer
+ */
+export interface IVaultAdapter<TNativeFile = unknown, TNativeFolder = unknown> {
+    /**
+     * Read a file as text
+     */
+    read(file: TNativeFile): Promise<string>;
+    /**
+     * Read a file using cached content if available
+     */
+    cachedRead(file: TNativeFile): Promise<string>;
+    /**
+     * Read a file as binary
+     */
+    readBinary(file: TNativeFile): Promise<ArrayBuffer>;
+    /**
+     * Modify an existing file with text content
+     */
+    modify(file: TNativeFile, data: string, options?: UXDataWriteOptions): Promise<void>;
+    /**
+     * Modify an existing file with binary content
+     */
+    modifyBinary(file: TNativeFile, data: ArrayBuffer, options?: UXDataWriteOptions): Promise<void>;
+    /**
+     * Create a new file with text content
+     */
+    create(path: string, data: string, options?: UXDataWriteOptions): Promise<TNativeFile>;
+    /**
+     * Create a new file with binary content
+     */
+    createBinary(path: string, data: ArrayBuffer, options?: UXDataWriteOptions): Promise<TNativeFile>;
+    /**
+     * Rename or move an existing file
+     */
+    rename(file: TNativeFile, newPath: string): Promise<void>;
+    /**
+     * Delete a file or folder
+     */
+    delete(file: TNativeFile | TNativeFolder, force?: boolean): Promise<void>;
+    /**
+     * Move a file or folder to trash
+     */
+    trash(file: TNativeFile | TNativeFolder, force?: boolean): Promise<void>;
+    /**
+     * Trigger an event in the vault
+     */
+    trigger(name: string, ...data: unknown[]): void;
+}

package/dist/serviceModules/adapters/index.d.ts

@@ -0,0 +1,6 @@
+export type { IPathAdapter } from "./IPathAdapter.js";
+export type { ITypeGuardAdapter } from "./ITypeGuardAdapter.js";
+export type { IConversionAdapter } from "./IConversionAdapter.js";
+export type { IStorageAdapter, IStorageBinaryReadAccess, IStorageBinaryWriteAccess, IStorageDirectoryAccess, IStorageMetadataAccess, IStorageRemoveAccess, IStorageTextAppendAccess, IStorageTextReadAccess, IStorageTextWriteAccess, } from "./IStorageAdapter.js";
+export type { IVaultAdapter } from "./IVaultAdapter.js";
+export type { IFileSystemAdapter } from "./IFileSystemAdapter.js";

package/dist/services/BrowserServices.d.ts

@@ -0,0 +1,36 @@
+import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
+import { ServiceContext } from "./base/ServiceBase.js";
+import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
+import { ControlService } from "./base/ControlService.js";
+import type { AppLifecycleService } from "./base/AppLifecycleService.js";
+import type { ConfigService } from "./base/ConfigService.js";
+import type { ReplicatorService } from "./base/ReplicatorService.js";
+import type { UIService } from "./implements/base/UIService.js";
+import type { InjectableAPIService } from "./implements/injectable/InjectableAPIService.js";
+import type { KeyValueDatabaseFactory } from "../interfaces/KeyValueDatabase.js";
+export type BrowserServiceHostDependencies<T extends ServiceContext> = {
+    API: InjectableAPIService<T>;
+    appLifecycle: AppLifecycleService<T>;
+    config: ConfigService<T>;
+    control: ControlService<T>;
+    replicator: ReplicatorService<T>;
+};
+/**
+ * Host-owned presentation services used by the browser composition.
+ *
+ * Commonlib owns the data and replication composition, while the application
+ * chooses its confirmation, dialogue, and other presentation behaviour.
+ */
+export interface BrowserServiceHost<T extends ServiceContext> {
+    createAPI(context: T): InjectableAPIService<T>;
+    createUI(context: T, dependencies: BrowserServiceHostDependencies<T>): UIService<T>;
+}
+export type BrowserServiceHubOptions<T extends ServiceContext> = {
+    context?: T;
+    host: BrowserServiceHost<T>;
+    openKeyValueDatabase?: KeyValueDatabaseFactory;
+};
+export declare class BrowserServiceHub<T extends ServiceContext> extends InjectableServiceHub<T> {
+    get vault(): InjectableVaultServiceCompat<T>;
+    constructor(options: BrowserServiceHubOptions<T>);
+}

package/dist/services/BrowserServices.js

@@ -0,0 +1,123 @@
+import { InjectableAppLifecycleService } from "./implements/injectable/InjectableAppLifecycleService.js";
+import { InjectableConflictService } from "./implements/injectable/InjectableConflictService.js";
+import { InjectableDatabaseEventService } from "./implements/injectable/InjectableDatabaseEventService.js";
+import { InjectableFileProcessingService } from "./implements/injectable/InjectableFileProcessingService.js";
+import { PathServiceCompat } from "./implements/injectable/InjectablePathService.js";
+import { InjectableRemoteService } from "./implements/injectable/InjectableRemoteService.js";
+import { InjectableReplicationService } from "./implements/injectable/InjectableReplicationService.js";
+import { InjectableReplicatorService } from "./implements/injectable/InjectableReplicatorService.js";
+import { InjectableSettingService } from "./implements/injectable/InjectableSettingService.js";
+import { InjectableTestService } from "./implements/injectable/InjectableTestService.js";
+import { InjectableTweakValueService } from "./implements/injectable/InjectableTweakValueService.js";
+import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
+import { ServiceContext } from "./base/ServiceBase.js";
+import { ConfigServiceBrowserCompat } from "./implements/browser/ConfigServiceBrowserCompat.js";
+import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
+import { BrowserDatabaseService, BrowserKeyValueDBService } from "./implements/browser/BrowserDatabaseService.js";
+import { ControlService } from "./base/ControlService.js";
+import { createIndexedDBKeyValueDatabaseFactory } from "../databases/IndexedDBKeyValueDatabase.js";
+import { PouchDB } from "../pouchdb/pouchdb-browser.js";
+class BrowserAppLifecycleService extends InjectableAppLifecycleService {
+  constructor(context, dependencies) {
+    super(context, dependencies);
+  }
+}
+class BrowserServiceHub extends InjectableServiceHub {
+  //  get vault():InjectableVaultServiceCompat<T>;
+  get vault() {
+    return this._vault;
+  }
+  constructor(options) {
+    const context = options.context ?? new ServiceContext();
+    const API = options.host.createAPI(context);
+    const conflict = new InjectableConflictService(context);
+    const fileProcessing = new InjectableFileProcessingService(context);
+    const setting = new InjectableSettingService(context, { APIService: API });
+    const appLifecycle = new BrowserAppLifecycleService(context, { settingService: setting });
+    const remote = new InjectableRemoteService(context, {
+      pouchDB: PouchDB,
+      APIService: API,
+      appLifecycle,
+      setting
+    });
+    const tweakValue = new InjectableTweakValueService(context);
+    const vault = new InjectableVaultServiceCompat(context, {
+      settingService: setting,
+      APIService: API
+    });
+    const test = new InjectableTestService(context);
+    const databaseEvents = new InjectableDatabaseEventService(context);
+    const path = new PathServiceCompat(context, {
+      settingService: setting
+    });
+    const database = new BrowserDatabaseService(context, {
+      pouchDB: PouchDB,
+      path,
+      vault,
+      setting,
+      API
+    });
+    const config = new ConfigServiceBrowserCompat(context, {
+      settingService: setting,
+      APIService: API
+    });
+    const replicator = new InjectableReplicatorService(context, {
+      settingService: setting,
+      appLifecycleService: appLifecycle,
+      databaseEventService: databaseEvents
+    });
+    const replication = new InjectableReplicationService(context, {
+      APIService: API,
+      appLifecycleService: appLifecycle,
+      replicatorService: replicator,
+      settingService: setting,
+      fileProcessingService: fileProcessing,
+      databaseService: database
+    });
+    const keyValueDB = new BrowserKeyValueDBService(context, {
+      openKeyValueDatabase: options.openKeyValueDatabase ?? createIndexedDBKeyValueDatabaseFactory(),
+      appLifecycle,
+      databaseEvents,
+      vault
+    });
+    const control = new ControlService(context, {
+      appLifecycleService: appLifecycle,
+      databaseService: database,
+      fileProcessingService: fileProcessing,
+      settingService: setting,
+      APIService: API,
+      replicatorService: replicator
+    });
+    const ui = options.host.createUI(context, {
+      API,
+      appLifecycle,
+      config,
+      control,
+      replicator
+    });
+    const serviceInstancesToInit = {
+      appLifecycle,
+      conflict,
+      database,
+      databaseEvents,
+      fileProcessing,
+      replication,
+      replicator,
+      remote,
+      setting,
+      tweakValue,
+      vault,
+      test,
+      ui,
+      path,
+      API,
+      config,
+      keyValueDB,
+      control
+    };
+    super(context, serviceInstancesToInit);
+  }
+}
+export {
+  BrowserServiceHub
+};

package/dist/services/HeadlessServices.d.ts

@@ -0,0 +1,14 @@
+import { ServiceContext } from "./base/ServiceBase.js";
+import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
+import type { DatabaseService } from "./base/DatabaseService.js";
+import type { Constructor } from "../common/utils.type.js";
+import type { KeyValueDatabaseFactory } from "../interfaces/KeyValueDatabase.js";
+import type { PouchDBConstructor } from "../pouchdb/PouchDBConstructor.js";
+export declare class HeadlessServiceHub<T extends ServiceContext> extends InjectableServiceHub<T> {
+    constructor(_context: T | undefined, overrideServiceConstructor: {
+        /** PouchDB with the adapters required by this headless runtime. */
+        pouchDB: PouchDBConstructor;
+        database?: Constructor<DatabaseService<T>>;
+        openKeyValueDatabase?: KeyValueDatabaseFactory;
+    });
+}

package/dist/services/HeadlessServices.js

@@ -0,0 +1,144 @@
+import {} from "./base/AppLifecycleService.js";
+import { InjectableAppLifecycleService } from "./implements/injectable/InjectableAppLifecycleService.js";
+import { InjectableConflictService } from "./implements/injectable/InjectableConflictService.js";
+import { InjectableDatabaseEventService } from "./implements/injectable/InjectableDatabaseEventService.js";
+import { InjectableFileProcessingService } from "./implements/injectable/InjectableFileProcessingService.js";
+import { PathServiceCompat } from "./implements/injectable/InjectablePathService.js";
+import { InjectableRemoteService } from "./implements/injectable/InjectableRemoteService.js";
+import { InjectableReplicationService } from "./implements/injectable/InjectableReplicationService.js";
+import { InjectableReplicatorService } from "./implements/injectable/InjectableReplicatorService.js";
+import { InjectableTestService } from "./implements/injectable/InjectableTestService.js";
+import { InjectableTweakValueService } from "./implements/injectable/InjectableTweakValueService.js";
+import { InjectableVaultServiceCompat } from "./implements/injectable/InjectableVaultService.js";
+import { ServiceContext } from "./base/ServiceBase.js";
+import { ConfigServiceBrowserCompat } from "./implements/browser/ConfigServiceBrowserCompat.js";
+import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
+import { UIService } from "./implements/base/UIService.js";
+import { HeadlessAPIService } from "./implements/headless/HeadlessAPIService.js";
+import { HeadlessDatabaseService, HeadlessKeyValueDBService } from "./implements/headless/HeadlessDatabaseService.js";
+import { ControlService } from "./base/ControlService.js";
+import { InjectableSettingService } from "./implements/injectable/InjectableSettingService.js";
+import { createIndexedDBKeyValueDatabaseFactory } from "../databases/IndexedDBKeyValueDatabase.js";
+class HeadlessAppLifecycleService extends InjectableAppLifecycleService {
+  constructor(context, dependencies) {
+    super(context, dependencies);
+  }
+}
+class HeadlessSvelteDialogManager {
+  openSvelteDialog(component, initialData) {
+    throw new Error("Method not implemented.");
+  }
+  open(component, initialData) {
+    return this.openSvelteDialog(component, initialData);
+  }
+  openWithExplicitCancel(component, initialData) {
+    throw new Error("Method not implemented.");
+  }
+}
+class HeadlessUIService extends UIService {
+  get dialogToCopy() {
+    throw new Error("Method not implemented.");
+  }
+  constructor(context, dependents) {
+    const headlessSvelteDialogManager = new HeadlessSvelteDialogManager();
+    super(context, {
+      dialogManager: headlessSvelteDialogManager,
+      APIService: dependents.APIService
+    });
+  }
+}
+class HeadlessServiceHub extends InjectableServiceHub {
+  constructor(_context, overrideServiceConstructor) {
+    const context = _context ?? new ServiceContext();
+    const API = new HeadlessAPIService(context);
+    const conflict = new InjectableConflictService(context);
+    const fileProcessing = new InjectableFileProcessingService(context);
+    const setting = new InjectableSettingService(context, {
+      APIService: API
+    });
+    const appLifecycle = new HeadlessAppLifecycleService(context, {
+      settingService: setting
+    });
+    const remote = new InjectableRemoteService(context, {
+      pouchDB: overrideServiceConstructor.pouchDB,
+      APIService: API,
+      appLifecycle,
+      setting
+    });
+    const tweakValue = new InjectableTweakValueService(context);
+    const vault = new InjectableVaultServiceCompat(context, {
+      settingService: setting,
+      APIService: API
+    });
+    const test = new InjectableTestService(context);
+    const databaseEvents = new InjectableDatabaseEventService(context);
+    const path = new PathServiceCompat(context, {
+      settingService: setting
+    });
+    const database = new (overrideServiceConstructor.database ?? HeadlessDatabaseService)(context, {
+      pouchDB: overrideServiceConstructor.pouchDB,
+      API,
+      path,
+      vault,
+      setting
+    });
+    const config = new ConfigServiceBrowserCompat(context, {
+      settingService: setting,
+      APIService: API
+    });
+    const replicator = new InjectableReplicatorService(context, {
+      settingService: setting,
+      appLifecycleService: appLifecycle,
+      databaseEventService: databaseEvents
+    });
+    const replication = new InjectableReplicationService(context, {
+      APIService: API,
+      appLifecycleService: appLifecycle,
+      replicatorService: replicator,
+      settingService: setting,
+      fileProcessingService: fileProcessing,
+      databaseService: database
+    });
+    const keyValueDB = new HeadlessKeyValueDBService(context, {
+      openKeyValueDatabase: overrideServiceConstructor.openKeyValueDatabase ?? createIndexedDBKeyValueDatabaseFactory(),
+      appLifecycle,
+      databaseEvents,
+      vault
+    });
+    const control = new ControlService(context, {
+      appLifecycleService: appLifecycle,
+      settingService: setting,
+      databaseService: database,
+      fileProcessingService: fileProcessing,
+      APIService: API,
+      replicatorService: replicator
+    });
+    const ui = new HeadlessUIService(context, {
+      APIService: API
+    });
+    const serviceInstancesToInit = {
+      appLifecycle,
+      conflict,
+      database,
+      databaseEvents,
+      fileProcessing,
+      replication,
+      replicator,
+      remote,
+      setting,
+      tweakValue,
+      vault,
+      test,
+      ui,
+      path,
+      API,
+      config,
+      keyValueDB,
+      control
+    };
+    super(context, serviceInstancesToInit);
+  }
+}
+export {
+  HeadlessServiceHub
+};

package/dist/services/InjectableServices.d.ts

@@ -0,0 +1 @@
+export { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";

package/dist/services/InjectableServices.js

@@ -0,0 +1,4 @@
+import { InjectableServiceHub } from "./implements/injectable/InjectableServiceHub.js";
+export {
+  InjectableServiceHub
+};

package/dist/services/ServiceHub.d.ts

@@ -0,0 +1,82 @@
+import type { UIService } from "./implements/base/UIService.js";
+import type { ConfigService } from "./base/ConfigService.js";
+import type { TestService } from "./base/TestService.js";
+import type { VaultService } from "./base/VaultService.js";
+import type { TweakValueService } from "./base/TweakValueService.js";
+import type { SettingService } from "./base/SettingService.js";
+import type { AppLifecycleService } from "./base/AppLifecycleService.js";
+import type { ConflictService } from "./base/ConflictService.js";
+import type { RemoteService } from "./base/RemoteService.js";
+import type { ReplicationService } from "./base/ReplicationService.js";
+import type { ReplicatorService } from "./base/ReplicatorService.js";
+import type { FileProcessingService } from "./base/FileProcessingService.js";
+import type { DatabaseEventService } from "./base/DatabaseEventService.js";
+import type { DatabaseService } from "./base/DatabaseService.js";
+import type { PathService } from "./base/PathService.js";
+import type { APIService } from "./base/APIService.js";
+import type { ServiceContext } from "./base/ServiceBase.js";
+import type { IServiceHub } from "./base/IService.js";
+import type { KeyValueDBService } from "./base/KeyValueDBService.js";
+import type { ControlService } from "./base/ControlService.js";
+export type ServiceInstances<T extends ServiceContext = ServiceContext> = {
+    API?: APIService<T>;
+    path?: PathService<T>;
+    database?: DatabaseService<T>;
+    databaseEvents?: DatabaseEventService<T>;
+    replicator?: ReplicatorService<T>;
+    fileProcessing?: FileProcessingService<T>;
+    replication?: ReplicationService<T>;
+    remote?: RemoteService<T>;
+    conflict?: ConflictService<T>;
+    appLifecycle?: AppLifecycleService<T>;
+    setting?: SettingService<T>;
+    tweakValue?: TweakValueService<T>;
+    vault?: VaultService<T>;
+    test?: TestService<T>;
+    ui?: UIService<T>;
+    config?: ConfigService<T>;
+    keyValueDB?: KeyValueDBService<T>;
+    control?: ControlService<T>;
+};
+export declare abstract class ServiceHub<T extends ServiceContext = ServiceContext> implements IServiceHub {
+    /** Context shared by every service exposed by this hub. */
+    readonly context: T;
+    protected abstract _api: APIService<T>;
+    protected abstract _path: PathService<T>;
+    protected abstract _database: DatabaseService<T>;
+    protected abstract _databaseEvents: DatabaseEventService<T>;
+    protected abstract _replicator: ReplicatorService<T>;
+    protected abstract _fileProcessing: FileProcessingService<T>;
+    protected abstract _replication: ReplicationService<T>;
+    protected abstract _remote: RemoteService<T>;
+    protected abstract _conflict: ConflictService<T>;
+    protected abstract _appLifecycle: AppLifecycleService<T>;
+    protected abstract _setting: SettingService<T>;
+    protected abstract _tweakValue: TweakValueService<T>;
+    protected abstract _vault: VaultService<T>;
+    protected abstract _test: TestService<T>;
+    protected abstract _ui: UIService<T>;
+    protected abstract _config: ConfigService<T>;
+    protected abstract _keyValueDB: KeyValueDBService<T>;
+    protected abstract _control: ControlService<T>;
+    protected _injected: ServiceInstances<T>;
+    constructor(context: T, services?: ServiceInstances<T>);
+    get API(): APIService<T>;
+    get path(): PathService<T>;
+    get database(): DatabaseService<T>;
+    get databaseEvents(): DatabaseEventService<T>;
+    get replicator(): ReplicatorService<T>;
+    get fileProcessing(): FileProcessingService<T>;
+    get replication(): ReplicationService<T>;
+    get remote(): RemoteService<T>;
+    get conflict(): ConflictService<T>;
+    get appLifecycle(): AppLifecycleService<T>;
+    get setting(): SettingService<T>;
+    get tweakValue(): TweakValueService<T>;
+    get vault(): VaultService<T>;
+    get test(): TestService<T>;
+    get UI(): UIService<T>;
+    get config(): ConfigService<T>;
+    get keyValueDB(): KeyValueDBService<T>;
+    get control(): ControlService<T>;
+}

package/dist/services/ServiceHub.js

@@ -0,0 +1,66 @@
+class ServiceHub {
+  /** Context shared by every service exposed by this hub. */
+  context;
+  _injected = {};
+  constructor(context, services = {}) {
+    this.context = context;
+    this._injected = services;
+  }
+  get API() {
+    return this._injected.API || this._api;
+  }
+  get path() {
+    return this._injected.path || this._path;
+  }
+  get database() {
+    return this._injected.database || this._database;
+  }
+  get databaseEvents() {
+    return this._injected.databaseEvents || this._databaseEvents;
+  }
+  get replicator() {
+    return this._injected.replicator || this._replicator;
+  }
+  get fileProcessing() {
+    return this._injected.fileProcessing || this._fileProcessing;
+  }
+  get replication() {
+    return this._injected.replication || this._replication;
+  }
+  get remote() {
+    return this._injected.remote || this._remote;
+  }
+  get conflict() {
+    return this._injected.conflict || this._conflict;
+  }
+  get appLifecycle() {
+    return this._injected.appLifecycle || this._appLifecycle;
+  }
+  get setting() {
+    return this._injected.setting || this._setting;
+  }
+  get tweakValue() {
+    return this._injected.tweakValue || this._tweakValue;
+  }
+  get vault() {
+    return this._injected.vault || this._vault;
+  }
+  get test() {
+    return this._injected.test || this._test;
+  }
+  get UI() {
+    return this._injected.ui || this._ui;
+  }
+  get config() {
+    return this._injected.config || this._config;
+  }
+  get keyValueDB() {
+    return this._injected.keyValueDB || this._keyValueDB;
+  }
+  get control() {
+    return this._injected.control || this._control;
+  }
+}
+export {
+  ServiceHub
+};