@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/services/base/UnresolvedErrorManager.js

@@ -0,0 +1,44 @@
+import { EVENT_ON_UNRESOLVED_ERROR } from "../../events/coreEvents.js";
+import { LEVEL_NOTICE, LEVEL_INFO } from "octagonal-wheels/common/logger";
+import { createInstanceLogFunction } from "../lib/logUtils.js";
+class UnresolvedErrorManager {
+  constructor(appLifecycleService, events) {
+    this.events = events;
+    this.appLifecycleService = appLifecycleService;
+    this.appLifecycleService.getUnresolvedMessages.addHandler(this._reportUnresolvedMessages.bind(this));
+  }
+  events;
+  _log = createInstanceLogFunction("UnresolvedErrorManager");
+  appLifecycleService;
+  _occurredErrors = /* @__PURE__ */ new Set();
+  showError(msg, max_log_level = LEVEL_NOTICE) {
+    const level = this._occurredErrors.has(msg) ? LEVEL_INFO : max_log_level;
+    this._log(msg, level);
+    if (!this._occurredErrors.has(msg)) {
+      this._occurredErrors.add(msg);
+      this.events.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+    }
+  }
+  clearError(msg) {
+    if (!this._occurredErrors.has(msg)) {
+      return;
+    }
+    this._occurredErrors.delete(msg);
+    this.events.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+  }
+  clearErrors() {
+    this._occurredErrors.clear();
+    this.events.emitEvent(EVENT_ON_UNRESOLVED_ERROR);
+  }
+  countErrors(needle) {
+    return Array.from(this._occurredErrors).filter(
+      (error) => typeof error === "string" && error.indexOf(needle) !== -1
+    ).length;
+  }
+  _reportUnresolvedMessages() {
+    return Promise.resolve(Array.from(this._occurredErrors));
+  }
+}
+export {
+  UnresolvedErrorManager
+};

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

@@ -0,0 +1,69 @@
+import type { FilePath } from "../../common/types.js";
+import type { IAPIService, ISettingService, IVaultService } from "./IService.js";
+import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
+export interface VaultServiceDependencies {
+    settingService: ISettingService;
+    APIService: IAPIService;
+}
+/**
+ * The VaultService provides methods for interacting with the vault (local file system).
+ */
+export declare abstract class VaultService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IVaultService {
+    protected settingService: ISettingService;
+    protected APIService: IAPIService;
+    get settings(): import("../../common/types.js").ObsidianLiveSyncSettings;
+    constructor(context: T, dependencies: VaultServiceDependencies);
+    /**
+     * Get the vault name only.
+     */
+    vaultName(): string;
+    /**
+     * Get the vault name with additional suffixes.
+     */
+    getVaultName(): string;
+    /**
+     * Scan the vault for changes (especially for changes during the plug-in were not running).
+     * @param showingNotice Whether to show a notice to the user.
+     * @param ignoreSuspending Whether to ignore any suspending state.
+     */
+    readonly scanVault: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(showingNotice?: boolean, ignoreSuspending?: boolean) => Promise<boolean>>;
+    /**
+     * Check if a file is ignored by the ignore file (e.g., .gitignore, .obsidianignore).
+     * @param file The file path or file info stub to check.
+     */
+    readonly isIgnoredByIgnoreFile: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(file: string | import("../../common/types.js").UXFileInfoStub) => Promise<boolean>>;
+    /**
+     * Check if a file is a target file for synchronisation.
+     * @param file The file path or file info stub to check.
+     * @param keepFileCheckList Whether to keep the file in the check list.
+     */
+    readonly isTargetFile: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(file: string | import("../../common/types.js").UXFileInfoStub) => Promise<boolean>>;
+    /**
+     * Check if a file is a target file for some extra feature
+     */
+    readonly isTargetFileInExtra: import("../lib/HandlerUtils.js").BooleanMultipleHandlerFunction<(file: string | import("../../common/types.js").UXFileInfoStub) => Promise<boolean>>;
+    /**
+     * Check if a filesize is too large against the current settings.
+     * @param size The file size to check.
+     */
+    isFileSizeTooLarge(size: number): boolean;
+    /**
+     * Get the currently active file path in the editor, if any.
+     */
+    abstract getActiveFilePath(): FilePath | undefined;
+    /**
+     * Check if the vault is on a case-insensitive file system.
+     * This is important for certain operating systems like Windows and macOS.
+     */
+    abstract isStorageInsensitive(): boolean;
+    /**
+     * Check if the file system should be treated case-insensitively.
+     * This is important for certain operating systems like Windows and macOS.
+     */
+    shouldCheckCaseInsensitively(): boolean;
+    /**
+     * Check if a given path is valid in the vault.
+     * @param path The file path to check.
+     */
+    abstract isValidPath(path: string): boolean;
+}

package/dist/services/base/VaultService.js

@@ -0,0 +1,70 @@
+import { ServiceBase } from "./ServiceBase.js";
+import { handlers } from "../lib/HandlerUtils.js";
+class VaultService extends ServiceBase {
+  settingService;
+  APIService;
+  get settings() {
+    return this.settingService.currentSettings();
+  }
+  constructor(context, dependencies) {
+    super(context);
+    this.settingService = dependencies.settingService;
+    this.APIService = dependencies.APIService;
+  }
+  /**
+   * Get the vault name only.
+   */
+  vaultName() {
+    return this.APIService.getSystemVaultName();
+  }
+  /**
+   * Get the vault name with additional suffixes.
+   */
+  getVaultName() {
+    return this.vaultName() + (this.settings.additionalSuffixOfDatabaseName ? "-" + this.settings.additionalSuffixOfDatabaseName : "");
+  }
+  /**
+   * Scan the vault for changes (especially for changes during the plug-in were not running).
+   * @param showingNotice Whether to show a notice to the user.
+   * @param ignoreSuspending Whether to ignore any suspending state.
+   */
+  scanVault = handlers().bailFirstFailure("scanVault");
+  /**
+   * Check if a file is ignored by the ignore file (e.g., .gitignore, .obsidianignore).
+   * @param file The file path or file info stub to check.
+   */
+  isIgnoredByIgnoreFile = handlers().anySuccess("isIgnoredByIgnoreFile");
+  /**
+   * Check if a file is a target file for synchronisation.
+   * @param file The file path or file info stub to check.
+   * @param keepFileCheckList Whether to keep the file in the check list.
+   */
+  isTargetFile = handlers().bailFirstFailure("isTargetFile");
+  /**
+   * Check if a file is a target file for some extra feature
+   */
+  isTargetFileInExtra = handlers().anySuccess("isTargetFileInExtra");
+  /**
+   * Check if a filesize is too large against the current settings.
+   * @param size The file size to check.
+   */
+  isFileSizeTooLarge(size) {
+    const maxSize = this.settings.syncMaxSizeInMB;
+    if (maxSize > 0 && size > 0) {
+      if (maxSize * 1024 * 1024 < size) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if the file system should be treated case-insensitively.
+   * This is important for certain operating systems like Windows and macOS.
+   */
+  shouldCheckCaseInsensitively() {
+    return !this.settings.handleFilenameCaseSensitive;
+  }
+}
+export {
+  VaultService
+};

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

@@ -0,0 +1,79 @@
+import type { ConfigService } from "../../base/ConfigService.js";
+import type { AppLifecycleService } from "../../base/AppLifecycleService.js";
+import type { ReplicatorService } from "../../base/ReplicatorService.js";
+import type { Confirm } from "../../../interfaces/Confirm.js";
+import { type Component } from "svelte";
+import type { ServiceContext } from "../../base/ServiceBase.js";
+import type { IControlService } from "../../base/IService.js";
+import type { Constructor } from "../../../common/utils.type.js";
+export type SvelteDialogManagerDependencies<T extends ServiceContext = ServiceContext> = {
+    appLifecycle: AppLifecycleService<T>;
+    replicator: ReplicatorService<T>;
+    config: ConfigService<T>;
+    confirm: Confirm;
+    control: IControlService;
+};
+export type HasSetResult<T> = {
+    setResult: (result: T) => void;
+};
+export type HasGetInitialData<T> = {
+    getInitialData?: () => T | undefined;
+};
+export type ComponentHasResult<T, U> = Component<HasSetResult<T> & HasGetInitialData<U>>;
+export type GuestDialogProps<T, U> = HasSetResult<T> & HasGetInitialData<U>;
+export type DialogSvelteComponentBaseProps<T, U> = {
+    setTitle: (title: string) => void;
+    closeDialog: () => void;
+} & HasSetResult<T> & HasGetInitialData<U>;
+export type DialogControlBase<T, U> = {
+    setTitle: (title: string) => void;
+    closeDialog: () => void;
+} & HasSetResult<T> & HasGetInitialData<U>;
+export type DialogHostProps<T = any, U = any> = DialogSvelteComponentBaseProps<T, U> & {
+    /**
+     * The Svelte component to mount inside the dialog host
+     */
+    mountComponent: ComponentHasResult<T, U>;
+    /**
+     * Callback function to setup the dialog context
+     * @param props
+     */
+    onSetupContext?(props: DialogSvelteComponentBaseProps<T, U>): void;
+};
+export type DialogContext<C extends ServiceContext = ServiceContext, T = any, U = any> = DialogControlBase<T, U> & {
+    context: C;
+    services: SvelteDialogManagerDependencies<C>;
+};
+export interface SvelteDialogManager<T extends ServiceContext> {
+    open<TResult, TInitial = TResult>(component: ComponentHasResult<TResult, TInitial>, initialData?: TInitial): Promise<TResult | undefined>;
+    openWithExplicitCancel<TResult, TInitial = TResult>(component: ComponentHasResult<TResult, TInitial>, initialData?: TInitial): Promise<TResult>;
+}
+export declare const CONTEXT_DIALOG_CONTROLS = "svelte-dialog-controls";
+export declare function setupDialogContext<T extends DialogContext>(controls: T): void;
+export declare function getDialogContext<T = unknown, U = unknown>(): DialogContext<ServiceContext, T, U>;
+export interface IModalBase {
+    contentEl: HTMLElement;
+    close(): void;
+    setTitle(title: string): void;
+    onOpen(): void;
+    onClose(): void;
+    open(): void;
+}
+export interface SvelteDialogInstance<T, U, C extends ServiceContext = ServiceContext> extends IModalBase {
+    initDialog(context: C, dependents: SvelteDialogManagerDependencies<C>, component: ComponentHasResult<T, U>, initialData?: U): void;
+    waitForClose(): Promise<T | undefined>;
+}
+export type SvelteDialogClass<TBase extends Constructor<IModalBase>> = {
+    new <T, U, C extends ServiceContext = ServiceContext>(...args: ConstructorParameters<TBase>): SvelteDialogInstance<T, U, C>;
+};
+export declare function SvelteDialogMixIn<TBase extends Constructor<IModalBase>>(TBase: TBase, d: Component<DialogHostProps>): SvelteDialogClass<TBase>;
+export declare abstract class SvelteDialogManagerBase<T extends ServiceContext> implements SvelteDialogManager<T> {
+    abstract openSvelteDialog<T, U = T>(component: ComponentHasResult<T, U>, initialData?: U): Promise<T | undefined>;
+    protected _context: T;
+    protected _dependents: SvelteDialogManagerDependencies<T>;
+    get context(): T;
+    get dependents(): SvelteDialogManagerDependencies<T>;
+    constructor(c: T, dependents: SvelteDialogManagerDependencies<T>);
+    open<T, U = T>(component: ComponentHasResult<T, U>, initialData?: U): Promise<T | undefined>;
+    openWithExplicitCancel<T, U = T>(component: ComponentHasResult<T, U>, initialData?: U): Promise<T>;
+}

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

@@ -0,0 +1,134 @@
+import { getContext, mount, setContext, unmount } from "svelte";
+import { LOG_LEVEL_NOTICE, Logger } from "../../../common/logger.js";
+import { fireAndForget, promiseWithResolvers } from "octagonal-wheels/promises";
+import { EVENT_PLUGIN_UNLOADED } from "../../../events/coreEvents.js";
+const CONTEXT_DIALOG_CONTROLS = "svelte-dialog-controls";
+function setupDialogContext(controls) {
+  setContext(CONTEXT_DIALOG_CONTROLS, controls);
+}
+function getDialogContext() {
+  return getContext(CONTEXT_DIALOG_CONTROLS);
+}
+function SvelteDialogMixIn(TBase, d) {
+  const SvelteDialog = class SvelteDialog extends TBase {
+    constructor(...args) {
+      super(...args);
+    }
+    // plugin: ObsidianLiveSyncPlugin;
+    _context;
+    get context() {
+      return this._context;
+    }
+    dependents;
+    mountedComponent;
+    component;
+    result;
+    initialData;
+    title = "Self-hosted LiveSync - Setup Wizard";
+    initDialog(context, dependents, component, initialData) {
+      this._context = context;
+      this.dependents = dependents;
+      this.component = component;
+      this.initialData = initialData;
+    }
+    resolveResult() {
+      this.resultPromiseWithResolvers?.resolve(this.result);
+      this.resultPromiseWithResolvers = void 0;
+    }
+    resultPromiseWithResolvers;
+    onOpen() {
+      const { contentEl } = this;
+      contentEl.replaceChildren();
+      const dialog = this;
+      if (this.resultPromiseWithResolvers) {
+        this.resultPromiseWithResolvers.reject("Dialog opened again");
+      }
+      const pr = promiseWithResolvers();
+      this.context.events.once(EVENT_PLUGIN_UNLOADED, () => {
+        if (this.resultPromiseWithResolvers === pr) {
+          pr.reject("Plugin unloaded");
+          this.close();
+        }
+      });
+      this.resultPromiseWithResolvers = pr;
+      this.mountedComponent = mount(d, {
+        target: contentEl,
+        props: {
+          onSetupContext: (props) => {
+            setupDialogContext({
+              ...props,
+              context: this.context,
+              services: this.dependents
+            });
+          },
+          setTitle: (title) => {
+            dialog.setTitle(title);
+          },
+          closeDialog: () => {
+            dialog.close();
+          },
+          setResult: (result) => {
+            this.result = result;
+          },
+          getInitialData: () => this.initialData,
+          mountComponent: this.component
+        }
+      });
+    }
+    waitForClose() {
+      if (!this.resultPromiseWithResolvers) {
+        throw new Error("Dialog not opened yet");
+      }
+      return this.resultPromiseWithResolvers.promise;
+    }
+    onClose() {
+      this.resolveResult();
+      fireAndForget(async () => {
+        if (this.mountedComponent) {
+          await unmount(this.mountedComponent);
+        }
+      });
+    }
+  };
+  return SvelteDialog;
+}
+class SvelteDialogManagerBase {
+  _context;
+  _dependents;
+  get context() {
+    return this._context;
+  }
+  get dependents() {
+    return this._dependents;
+  }
+  constructor(c, dependents) {
+    this._context = c;
+    this._dependents = dependents;
+  }
+  async open(component, initialData) {
+    return await this.openSvelteDialog(component, initialData);
+  }
+  async openWithExplicitCancel(component, initialData) {
+    for (let i = 0; i < 10; i++) {
+      const ret = await this.openSvelteDialog(component, initialData);
+      if (ret !== void 0) {
+        return ret;
+      }
+      if (this.dependents.control.hasUnloaded()) {
+        throw new Error("Operation cancelled due to app shutdown.");
+      }
+      Logger(
+        this.context.translate("Please select 'Cancel' explicitly to cancel this operation."),
+        LOG_LEVEL_NOTICE
+      );
+    }
+    throw new Error("Operation Forcibly cancelled by user.");
+  }
+}
+export {
+  CONTEXT_DIALOG_CONTROLS,
+  SvelteDialogManagerBase,
+  SvelteDialogMixIn,
+  getDialogContext,
+  setupDialogContext
+};

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

@@ -0,0 +1,24 @@
+import type { Confirm } from "../../../interfaces/Confirm.js";
+import type { ComponentHasResult, SvelteDialogManager } from "./SvelteDialog.js";
+import type { IAPIService, IUIService } from "../../base/IService.js";
+import { ServiceBase, type ServiceContext } from "../../base/ServiceBase.js";
+export type UIServiceDependencies<T extends ServiceContext = ServiceContext> = {
+    dialogManager: SvelteDialogManager<T>;
+    APIService: IAPIService;
+};
+type DialogResult = "ok" | "cancel";
+type DialogParams = {
+    title: string;
+    dataToCopy: string;
+};
+export declare abstract class UIService<T extends ServiceContext = ServiceContext> extends ServiceBase<T> implements IUIService {
+    private _dialogManager;
+    protected _APIService: IAPIService;
+    abstract get dialogToCopy(): ComponentHasResult<DialogResult, DialogParams>;
+    constructor(context: T, dependents: UIServiceDependencies<T>);
+    get dialogManager(): SvelteDialogManager<T>;
+    promptCopyToClipboard(title: string, value: string): Promise<boolean>;
+    showMarkdownDialog<T extends string[]>(title: string, contentMD: string, buttons: T, defaultAction?: (typeof buttons)[number]): Promise<(typeof buttons)[number] | false>;
+    get confirm(): Confirm;
+}
+export {};

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

@@ -0,0 +1,37 @@
+import { ServiceBase } from "../../base/ServiceBase.js";
+class UIService extends ServiceBase {
+  _dialogManager;
+  _APIService;
+  constructor(context, dependents) {
+    super(context);
+    this._dialogManager = dependents.dialogManager;
+    this._APIService = dependents.APIService;
+  }
+  get dialogManager() {
+    return this._dialogManager;
+  }
+  async promptCopyToClipboard(title, value) {
+    const param = {
+      title,
+      dataToCopy: value
+    };
+    const result = await this._dialogManager.open(this.dialogToCopy, param);
+    if (result !== "ok") {
+      return false;
+    }
+    return true;
+  }
+  showMarkdownDialog(title, contentMD, buttons, defaultAction) {
+    return this._APIService.confirm.askSelectStringDialogue(contentMD, buttons, {
+      title,
+      defaultAction: defaultAction ?? buttons[0],
+      timeout: 0
+    });
+  }
+  get confirm() {
+    return this._APIService.confirm;
+  }
+}
+export {
+  UIService
+};

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

@@ -0,0 +1,54 @@
+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";
+export declare const PACKAGE_VERSION: string;
+export declare const MANIFEST_VERSION: string;
+export type BrowserAPIServiceDependencies = {
+    confirm: Confirm;
+};
+export declare class BrowserAPIService<T extends ServiceContext> extends InjectableAPIService<T> {
+    _confirmInstance: Confirm;
+    private commandBar;
+    private commandButtons;
+    private logPanel;
+    private logViewport;
+    private readonly maxLogLines;
+    private windowFactories;
+    private windowInstances;
+    private windowRoot;
+    private windowTabs;
+    private windowBody;
+    private windowPanels;
+    private activeWindowType;
+    constructor(context: T, dependencies: BrowserAPIServiceDependencies);
+    get confirm(): Confirm;
+    showWindow(type: string): Promise<void>;
+    getCustomFetchHandler(): FetchHttpHandler;
+    isMobile(): boolean;
+    getAppID(): string;
+    getSystemVaultName: import("../../lib/HandlerUtils.js").HandlerFunction<() => string, unknown>;
+    getAppVersion(): string;
+    getPluginVersion(): string;
+    getPlatform(): string;
+    getCrypto(): Crypto;
+    nativeFetch(req: string | Request, opts?: RequestInit): Promise<Response>;
+    private ensureLogPanel;
+    private formatLogLine;
+    private appendLog;
+    private ensureCommandBar;
+    private ensureWindowHost;
+    private ensureWindowTab;
+    private ensureWindowPanel;
+    private activateWindow;
+    private createLeafShim;
+    private evaluateEnabled;
+    private executeCommand;
+    private refreshCommandStates;
+    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;
+}