@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/services/implements/browser/BrowserAPIService.js

@@ -0,0 +1,298 @@
+import { InjectableAPIService } from "../injectable/InjectableAPIService.js";
+import { handlers } from "../../lib/HandlerUtils.js";
+import { LOG_LEVEL_VERBOSE } from "../../../common/logger.js";
+import { _activeDocument } from "../../../common/coreEnvFunctions.js";
+class BrowserAPIService extends InjectableAPIService {
+  _confirmInstance;
+  commandBar = null;
+  commandButtons = /* @__PURE__ */ new Map();
+  logPanel = null;
+  logViewport = null;
+  maxLogLines = 300;
+  windowFactories = /* @__PURE__ */ new Map();
+  windowInstances = /* @__PURE__ */ new Map();
+  windowRoot = null;
+  windowTabs = null;
+  windowBody = null;
+  windowPanels = /* @__PURE__ */ new Map();
+  activeWindowType = null;
+  constructor(context, dependencies) {
+    super(context);
+    this._confirmInstance = dependencies.confirm;
+    this.addLog.setHandler((message, level, key) => {
+      if (level >= LOG_LEVEL_VERBOSE) {
+        this.appendLog(message, level, key);
+      }
+    });
+  }
+  get confirm() {
+    return this._confirmInstance;
+  }
+  async showWindow(type) {
+    const factory = this.windowFactories.get(type);
+    if (!factory) {
+      this.appendLog(`Window type is not registered: ${type}`, "warn", "showWindow");
+      return;
+    }
+    this.ensureWindowHost();
+    const panel = this.ensureWindowPanel(type);
+    this.activateWindow(type);
+    if (!this.windowInstances.has(type)) {
+      panel.replaceChildren();
+      const leaf = this.createLeafShim(type, panel);
+      const view = factory(leaf);
+      this.windowInstances.set(type, view);
+      if (view instanceof HTMLElement) {
+        panel.appendChild(view);
+      }
+      if (view && typeof view.onOpen === "function") {
+        await Promise.resolve(view.onOpen());
+      }
+    }
+  }
+  getCustomFetchHandler() {
+    return void 0;
+  }
+  isMobile() {
+    return false;
+  }
+  getAppID() {
+    return "browser-app";
+  }
+  getSystemVaultName = handlers().binder("getSystemVaultName");
+  getAppVersion() {
+    return `${MANIFEST_VERSION ?? "0.0.0."}`;
+  }
+  getPluginVersion() {
+    return `${MANIFEST_VERSION ?? "0.0.0."}`;
+  }
+  getPlatform() {
+    return "browser";
+  }
+  getCrypto() {
+    return globalThis.crypto;
+  }
+  nativeFetch(req, opts) {
+    return fetch(req, opts);
+  }
+  ensureLogPanel() {
+    if (this.logPanel && _activeDocument.body.contains(this.logPanel)) {
+      return this.logPanel;
+    }
+    let panel = _activeDocument.getElementById("livesync-log-panel");
+    let viewport = _activeDocument.getElementById("livesync-log-viewport");
+    if (!panel) {
+      panel = _activeDocument.createElement("div");
+      panel.id = "livesync-log-panel";
+      const header = _activeDocument.createElement("div");
+      header.textContent = "LiveSync Logs";
+      header.className = "livesync-log-header";
+      viewport = _activeDocument.createElement("div");
+      viewport.id = "livesync-log-viewport";
+      panel.appendChild(header);
+      panel.appendChild(viewport);
+      _activeDocument.body.appendChild(panel);
+    }
+    _activeDocument.body.classList.add("livesync-log-visible");
+    this.logPanel = panel;
+    this.logViewport = viewport;
+    return panel;
+  }
+  formatLogLine(message, level, key) {
+    let body;
+    if (typeof message === "string") {
+      body = message;
+    } else if (message instanceof Error) {
+      body = message.stack ?? message.message;
+    } else {
+      try {
+        body = JSON.stringify(message);
+      } catch {
+        body = String(message);
+      }
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    const levelLabel = level === void 0 || level === null ? "LOG" : String(level);
+    const keyLabel = key ? ` [${key}]` : "";
+    return `${timestamp} [${levelLabel}]${keyLabel} ${body}`;
+  }
+  appendLog(message, level, key) {
+    this.ensureLogPanel();
+    if (!this.logViewport) {
+      return;
+    }
+    const line = _activeDocument.createElement("div");
+    line.textContent = this.formatLogLine(message, level, key);
+    line.className = "livesync-log-line";
+    this.logViewport.appendChild(line);
+    while (this.logViewport.childElementCount > this.maxLogLines) {
+      this.logViewport.removeChild(this.logViewport.firstElementChild);
+    }
+    this.logViewport.scrollTop = this.logViewport.scrollHeight;
+  }
+  ensureCommandBar() {
+    if (this.commandBar && _activeDocument.body.contains(this.commandBar)) {
+      return this.commandBar;
+    }
+    let host = _activeDocument.getElementById("livesync-command-bar");
+    if (!host) {
+      host = _activeDocument.createElement("div");
+      host.id = "livesync-command-bar";
+      _activeDocument.body.appendChild(host);
+    }
+    this.commandBar = host;
+    return host;
+  }
+  ensureWindowHost() {
+    if (this.windowRoot && _activeDocument.body.contains(this.windowRoot)) {
+      return this.windowRoot;
+    }
+    let root = _activeDocument.getElementById("livesync-window-root");
+    if (!root) {
+      root = _activeDocument.createElement("div");
+      root.id = "livesync-window-root";
+      const tabs = _activeDocument.createElement("div");
+      tabs.id = "livesync-window-tabs";
+      const body = _activeDocument.createElement("div");
+      body.id = "livesync-window-body";
+      root.appendChild(tabs);
+      root.appendChild(body);
+      _activeDocument.body.appendChild(root);
+    }
+    this.windowRoot = root;
+    this.windowTabs = _activeDocument.getElementById("livesync-window-tabs");
+    this.windowBody = _activeDocument.getElementById("livesync-window-body");
+    return root;
+  }
+  ensureWindowTab(type) {
+    this.ensureWindowHost();
+    const existing = this.windowTabs.querySelector(`[data-window-tab="${type}"]`);
+    if (existing) {
+      return existing;
+    }
+    const tab = _activeDocument.createElement("button");
+    tab.type = "button";
+    tab.dataset.windowTab = type;
+    tab.textContent = type;
+    tab.className = "livesync-window-tab";
+    tab.onclick = () => {
+      void this.showWindow(type);
+    };
+    this.windowTabs.appendChild(tab);
+    return tab;
+  }
+  ensureWindowPanel(type) {
+    this.ensureWindowHost();
+    const existing = this.windowPanels.get(type);
+    if (existing) {
+      return existing;
+    }
+    const panel = _activeDocument.createElement("div");
+    panel.dataset.windowPanel = type;
+    panel.className = "livesync-window-panel";
+    this.windowBody.appendChild(panel);
+    this.windowPanels.set(type, panel);
+    this.ensureWindowTab(type);
+    return panel;
+  }
+  activateWindow(type) {
+    this.activeWindowType = type;
+    for (const [windowType, panel] of this.windowPanels.entries()) {
+      panel.classList.toggle("is-active", windowType === type);
+    }
+    this.windowTabs?.querySelectorAll("button[data-window-tab]").forEach((tab) => {
+      const isActive = tab.dataset.windowTab === type;
+      tab.classList.toggle("is-active", isActive);
+    });
+  }
+  createLeafShim(type, panel) {
+    return {
+      type,
+      containerEl: panel,
+      view: void 0,
+      setViewState: async (state) => {
+        if (state?.type && state.type !== type) {
+          await this.showWindow(state.type);
+        }
+      }
+    };
+  }
+  evaluateEnabled(command) {
+    if (command.checkCallback) {
+      try {
+        return command.checkCallback(true) === true;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+  executeCommand(command) {
+    const enabled = this.evaluateEnabled(command);
+    if (!enabled) {
+      console.warn(`[BrowserAPIService] Command is not enabled: ${command.id}`);
+      return;
+    }
+    try {
+      if (command.checkCallback) {
+        const canRun = command.checkCallback(false);
+        if (canRun === false) {
+          return;
+        }
+      }
+      if (command.callback) {
+        void Promise.resolve(command.callback()).catch((error) => {
+          console.error(`[BrowserAPIService] Command failed: ${command.id}`, error);
+        });
+      }
+    } catch (error) {
+      console.error(`[BrowserAPIService] Command failed: ${command.id}`, error);
+    }
+  }
+  refreshCommandStates() {
+    for (const [id, button] of this.commandButtons.entries()) {
+      const command = button.__command;
+      if (!command) {
+        continue;
+      }
+      const enabled = this.evaluateEnabled(command);
+      button.disabled = !enabled;
+      button.classList.toggle("is-disabled", !enabled);
+      if (!enabled && !button.title) {
+        button.title = id;
+      }
+    }
+  }
+  addCommand(command) {
+    const bar = this.ensureCommandBar();
+    const key = command.id || command.name;
+    let button = this.commandButtons.get(key);
+    if (!button) {
+      button = _activeDocument.createElement("button");
+      button.type = "button";
+      button.className = "livesync-command-button";
+      bar.appendChild(button);
+      this.commandButtons.set(key, button);
+    }
+    button.textContent = command.name || command.id;
+    button.title = command.id;
+    button.__command = command;
+    button.onclick = () => this.executeCommand(command);
+    return command;
+  }
+  addRibbonIcon(icon, title, callback) {
+    return _activeDocument.createElement("div");
+  }
+  registerWindow(type, factory) {
+    this.windowFactories.set(type, factory);
+    this.ensureWindowPanel(type);
+  }
+  registerProtocolHandler(action, handler) {
+  }
+  addStatusBarItem() {
+    return void 0;
+  }
+}
+export {
+  BrowserAPIService
+};

package/dist/services/implements/browser/BrowserDatabaseService.d.ts

@@ -0,0 +1,7 @@
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { KeyValueDBService } from "../../base/KeyValueDBService.js";
+import { DatabaseService } from "../../base/DatabaseService.js";
+export declare class BrowserDatabaseService<T extends ServiceContext> extends DatabaseService<T> {
+}
+export declare class BrowserKeyValueDBService<T extends ServiceContext> extends KeyValueDBService<T> {
+}

package/dist/services/implements/browser/BrowserDatabaseService.js

@@ -0,0 +1,10 @@
+import { KeyValueDBService } from "../../base/KeyValueDBService.js";
+import { DatabaseService } from "../../base/DatabaseService.js";
+class BrowserDatabaseService extends DatabaseService {
+}
+class BrowserKeyValueDBService extends KeyValueDBService {
+}
+export {
+  BrowserDatabaseService,
+  BrowserKeyValueDBService
+};

package/dist/services/implements/browser/ConfigServiceBrowserCompat.d.ts

@@ -0,0 +1,16 @@
+import { ConfigService } from "../../base/ConfigService.js";
+import type { IAPIService, ISettingService } from "../../base/IService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { createInstanceLogFunction } from "../../lib/logUtils.js";
+export interface ConfigServiceBrowserCompatDependencies {
+    settingService: ISettingService;
+    APIService: IAPIService;
+}
+export declare class ConfigServiceBrowserCompat<T extends ServiceContext = ServiceContext> extends ConfigService<T> {
+    private _settingService;
+    _log: ReturnType<typeof createInstanceLogFunction>;
+    constructor(context: T, dependencies: ConfigServiceBrowserCompatDependencies);
+    getSmallConfig(key: string): string;
+    setSmallConfig(key: string, value: string): void;
+    deleteSmallConfig(key: string): void;
+}

package/dist/services/implements/browser/ConfigServiceBrowserCompat.js

@@ -0,0 +1,23 @@
+import { ConfigService } from "../../base/ConfigService.js";
+import { createInstanceLogFunction } from "../../lib/logUtils.js";
+class ConfigServiceBrowserCompat extends ConfigService {
+  _settingService;
+  _log;
+  constructor(context, dependencies) {
+    super(context);
+    this._settingService = dependencies.settingService;
+    this._log = createInstanceLogFunction("ConfigService", dependencies.APIService);
+  }
+  getSmallConfig(key) {
+    return this._settingService.getSmallConfig(key);
+  }
+  setSmallConfig(key, value) {
+    return this._settingService.setSmallConfig(key, value);
+  }
+  deleteSmallConfig(key) {
+    return this._settingService.deleteSmallConfig(key);
+  }
+}
+export {
+  ConfigServiceBrowserCompat
+};

package/dist/services/implements/headless/HeadlessAPIService.d.ts

@@ -0,0 +1,52 @@
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { InjectableAPIService } from "../injectable/InjectableAPIService.js";
+import type { FetchHttpHandler } from "@smithy/fetch-http-handler";
+import type { ICommandCompat } from "../../base/IService.js";
+import type { Confirm } from "../../../interfaces/Confirm.js";
+/**
+ * Headless implementation of Confirm that returns sensible defaults instead
+ * of throwing. Dialogs are logged to stderr so the prompts are visible in
+ * service logs, and the default/conservative action is taken automatically.
+ */
+export declare class HeadlessConfirm implements Confirm {
+    askYesNo(message: string): Promise<"yes" | "no">;
+    askString(title: string, key: string, placeholder: string, isPassword?: boolean): Promise<string | false>;
+    askYesNoDialog(message: string, opt: {
+        title?: string;
+        defaultOption?: "Yes" | "No";
+        timeout?: number;
+    }): Promise<"yes" | "no">;
+    askSelectString(message: string, items: string[]): Promise<string>;
+    askSelectStringDialogue<T extends readonly string[]>(message: string, buttons: T, opt: {
+        title?: string;
+        defaultAction: T[number];
+        timeout?: number;
+    }): Promise<T[number] | false>;
+    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void): void;
+    confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false>;
+}
+export declare class HeadlessAPIService<T extends ServiceContext> extends InjectableAPIService<T> {
+    private _confirmInstance;
+    private _systemVaultName;
+    constructor(context: T);
+    get confirm(): Confirm;
+    showWindow(type: string): Promise<void>;
+    getCustomFetchHandler(): FetchHttpHandler;
+    isMobile(): boolean;
+    getAppID(): string;
+    getAppVersion(): string;
+    getPluginVersion(): string;
+    getPlatform(): string;
+    getCrypto(): Crypto;
+    addCommand<TCommand extends ICommandCompat>(command: TCommand): TCommand;
+    addRibbonIcon(icon: string, title: string, callback: (evt: MouseEvent) => any): HTMLElement;
+    registerWindow(type: string, factory: (leaf: any) => any): void;
+    registerProtocolHandler(action: string, handler: (params: Record<string, string>) => any): void;
+    addStatusBarItem(): HTMLElement | undefined;
+    private toSafeKeyPart;
+    private hash32;
+    private deriveSystemVaultName;
+    getSystemVaultName(): string;
+    get isOnline(): boolean;
+    nativeFetch(req: string | Request, opts?: RequestInit): Promise<Response>;
+}

package/dist/services/implements/headless/HeadlessAPIService.js

@@ -0,0 +1,127 @@
+import { InjectableAPIService } from "../injectable/InjectableAPIService.js";
+import module from "node:crypto";
+import { _activeDocument } from "../../../common/coreEnvFunctions.js";
+class HeadlessConfirm {
+  askYesNo(message) {
+    console.error(`[Headless] ${message} \u2192 no`);
+    return Promise.resolve("no");
+  }
+  askString(title, key, placeholder, isPassword) {
+    console.error(`[Headless] String input required: ${title} \u2192 declined`);
+    return Promise.resolve(false);
+  }
+  askYesNoDialog(message, opt) {
+    const result = opt.defaultOption === "Yes" ? "yes" : "no";
+    console.error(`[Headless] ${opt.title ?? "Confirm"}: ${message} \u2192 ${result}`);
+    return Promise.resolve(result);
+  }
+  askSelectString(message, items) {
+    console.error(`[Headless] ${message} \u2192 ${items[0]}`);
+    return Promise.resolve(items[0]);
+  }
+  askSelectStringDialogue(message, buttons, opt) {
+    console.error(`[Headless] ${opt.title ?? "Confirm"}: ${message} \u2192 ${String(opt.defaultAction)}`);
+    return Promise.resolve(opt.defaultAction);
+  }
+  askInPopup(key, dialogText, anchorCallback) {
+    console.error(`[Headless] Popup (${key}): ${dialogText}`);
+  }
+  confirmWithMessage(title, contentMd, buttons, defaultAction, timeout) {
+    console.error(`[Headless] ${title}: ${contentMd} \u2192 ${defaultAction}`);
+    return Promise.resolve(defaultAction);
+  }
+}
+class HeadlessAPIService extends InjectableAPIService {
+  _confirmInstance;
+  _systemVaultName;
+  constructor(context) {
+    super(context);
+    this._confirmInstance = new HeadlessConfirm();
+  }
+  get confirm() {
+    return this._confirmInstance;
+  }
+  showWindow(type) {
+    return Promise.resolve();
+  }
+  getCustomFetchHandler() {
+    return void 0;
+  }
+  isMobile() {
+    return false;
+  }
+  getAppID() {
+    return "headless-app";
+  }
+  getAppVersion() {
+    return `${MANIFEST_VERSION ?? "0.0.0."}`;
+  }
+  getPluginVersion() {
+    return `${MANIFEST_VERSION ?? "0.0.0."}`;
+  }
+  getPlatform() {
+    return "server";
+  }
+  getCrypto() {
+    const webcrypto = module.webcrypto;
+    return webcrypto;
+  }
+  addCommand(command) {
+    return command;
+  }
+  addRibbonIcon(icon, title, callback) {
+    return _activeDocument?.createElement("div") || {};
+  }
+  registerWindow(type, factory) {
+  }
+  registerProtocolHandler(action, handler) {
+  }
+  addStatusBarItem() {
+    return void 0;
+  }
+  toSafeKeyPart(value) {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return "vault";
+    }
+    return trimmed.replace(/[^a-zA-Z0-9._-]/g, "_");
+  }
+  hash32(value) {
+    let hash = 2166136261;
+    for (let i = 0; i < value.length; i++) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  }
+  deriveSystemVaultName() {
+    const contextLike = this.context;
+    const explicitName = contextLike.vaultName;
+    if (typeof explicitName === "string" && explicitName.trim() !== "") {
+      return this.toSafeKeyPart(explicitName);
+    }
+    const vaultPath = contextLike.vaultPath;
+    if (typeof vaultPath === "string" && vaultPath.trim() !== "") {
+      const normalised = vaultPath.replace(/\\/g, "/").replace(/\/+$/, "");
+      const leaf = normalised.split("/").filter((e) => e !== "").pop() ?? "vault";
+      return `${this.toSafeKeyPart(leaf)}-${this.hash32(normalised)}`;
+    }
+    return "headless-vault";
+  }
+  getSystemVaultName() {
+    if (!this._systemVaultName) {
+      this._systemVaultName = this.deriveSystemVaultName();
+    }
+    return this._systemVaultName;
+  }
+  get isOnline() {
+    return true;
+  }
+  nativeFetch(req, opts) {
+    return fetch(req, opts);
+  }
+}
+export {
+  HeadlessAPIService,
+  HeadlessConfirm
+};

package/dist/services/implements/headless/HeadlessDatabaseService.d.ts

@@ -0,0 +1,7 @@
+import { KeyValueDBService } from "../../base/KeyValueDBService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import { DatabaseService } from "../../base/DatabaseService.js";
+export declare class HeadlessDatabaseService<T extends ServiceContext> extends DatabaseService<T> {
+}
+export declare class HeadlessKeyValueDBService<T extends ServiceContext> extends KeyValueDBService<T> {
+}

package/dist/services/implements/headless/HeadlessDatabaseService.js

@@ -0,0 +1,10 @@
+import { KeyValueDBService } from "../../base/KeyValueDBService.js";
+import { DatabaseService } from "../../base/DatabaseService.js";
+class HeadlessDatabaseService extends DatabaseService {
+}
+class HeadlessKeyValueDBService extends KeyValueDBService {
+}
+export {
+  HeadlessDatabaseService,
+  HeadlessKeyValueDBService
+};

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

@@ -0,0 +1,7 @@
+import { APIService } from "../../base/APIService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+export declare abstract class InjectableAPIService<T extends ServiceContext> extends APIService<T> {
+    addLog: import("../../lib/HandlerUtils.js").HandlerFunction<(message: unknown, level: import("octagonal-wheels/common/logger").LOG_LEVEL, key?: string) => void, unknown>;
+    getPlatform(): string;
+    getCrypto(): Crypto;
+}

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

@@ -0,0 +1,18 @@
+import { APIService } from "../../base/APIService.js";
+import { handlers } from "../../lib/HandlerUtils.js";
+class InjectableAPIService extends APIService {
+  addLog = handlers().binder("addLog");
+  // isLastPostFailedDueToPayloadSize = handlers<IAPIService>().binder("isLastPostFailedDueToPayloadSize");
+  getPlatform() {
+    return "unknown";
+  }
+  getCrypto() {
+    if (typeof crypto !== "undefined") {
+      return crypto;
+    }
+    throw new Error("Crypto API is not available in this environment.");
+  }
+}
+export {
+  InjectableAPIService
+};

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

@@ -0,0 +1,11 @@
+import { AppLifecycleService } from "../../base/AppLifecycleService.js";
+import type { IAppLifecycleService } from "../../base/IService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+export declare abstract class AppLifecycleServiceBase<T extends ServiceContext> extends AppLifecycleService<T> {
+    askRestart: import("../../lib/HandlerUtils.js").HandlerFunction<(message?: string) => void, unknown>;
+    scheduleRestart: import("../../lib/HandlerUtils.js").HandlerFunction<() => void, unknown>;
+    isReloadingScheduled: import("../../lib/HandlerUtils.js").HandlerFunction<() => boolean, unknown>;
+}
+export declare abstract class InjectableAppLifecycleService<T extends ServiceContext = ServiceContext> extends AppLifecycleServiceBase<T> implements IAppLifecycleService {
+    performRestart: import("../../lib/HandlerUtils.js").HandlerFunction<() => void, unknown>;
+}

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

@@ -0,0 +1,14 @@
+import { AppLifecycleService } from "../../base/AppLifecycleService.js";
+import { handlers } from "../../lib/HandlerUtils.js";
+class AppLifecycleServiceBase extends AppLifecycleService {
+  askRestart = handlers().binder("askRestart");
+  scheduleRestart = handlers().binder("scheduleRestart");
+  isReloadingScheduled = handlers().binder("isReloadingScheduled");
+}
+class InjectableAppLifecycleService extends AppLifecycleServiceBase {
+  performRestart = handlers().binder("performRestart");
+}
+export {
+  AppLifecycleServiceBase,
+  InjectableAppLifecycleService
+};

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

@@ -0,0 +1,11 @@
+import { ConflictService } from "../../base/ConflictService.js";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+export declare class InjectableConflictService<T extends ServiceContext> extends ConflictService<T> {
+    queueCheckForIfOpen: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../common/types.js").FilePathWithPrefix) => Promise<void>, unknown>;
+    queueCheckFor: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../common/types.js").FilePathWithPrefix) => Promise<void>, unknown>;
+    ensureAllProcessed: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<boolean>, unknown>;
+    resolveByDeletingRevision: import("../../lib/HandlerUtils.js").HandlerFunction<(path: import("../../../common/types.js").FilePathWithPrefix, deleteRevision: string, title: string) => Promise<typeof import("../../../common/types.js").MISSING_OR_ERROR | typeof import("../../../common/types.js").AUTO_MERGED>, unknown>;
+    resolve: import("../../lib/HandlerUtils.js").HandlerFunction<(filename: import("../../../common/types.js").FilePathWithPrefix) => Promise<void>, unknown>;
+    resolveByNewest: import("../../lib/HandlerUtils.js").HandlerFunction<(filename: import("../../../common/types.js").FilePathWithPrefix) => Promise<boolean>, unknown>;
+    resolveAllConflictedFilesByNewerOnes: import("../../lib/HandlerUtils.js").HandlerFunction<() => Promise<void>, unknown>;
+}

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

@@ -0,0 +1,14 @@
+import { ConflictService } from "../../base/ConflictService.js";
+import { handlers } from "../../lib/HandlerUtils.js";
+class InjectableConflictService extends ConflictService {
+  queueCheckForIfOpen = handlers().binder("queueCheckForIfOpen");
+  queueCheckFor = handlers().binder("queueCheckFor");
+  ensureAllProcessed = handlers().binder("ensureAllProcessed");
+  resolveByDeletingRevision = handlers().binder("resolveByDeletingRevision");
+  resolve = handlers().binder("resolve");
+  resolveByNewest = handlers().binder("resolveByNewest");
+  resolveAllConflictedFilesByNewerOnes = handlers().binder("resolveAllConflictedFilesByNewerOnes");
+}
+export {
+  InjectableConflictService
+};

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

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

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

@@ -0,0 +1,7 @@
+import { DatabaseEventService } from "../../base/DatabaseEventService.js";
+class InjectableDatabaseEventService extends DatabaseEventService {
+  // initialiseDatabase = handlers<IDatabaseEventService>().binder("initialiseDatabase");
+}
+export {
+  InjectableDatabaseEventService
+};

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

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

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

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