@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/common/utils.patch.js

@@ -0,0 +1,178 @@
+const MARK_OPERATOR = `
`;
+const MARK_DELETED = `${MARK_OPERATOR}__DELETED`;
+const MARK_ISARRAY = `${MARK_OPERATOR}__ARRAY`;
+const MARK_SWAPPED = `${MARK_OPERATOR}__SWAP`;
+function unorderedArrayToObject(obj) {
+  return obj.map((e) => ({ [e.id]: e })).reduce((p, c) => ({ ...p, ...c }), {});
+}
+function objectToUnorderedArray(obj) {
+  const entries = Object.entries(obj);
+  if (entries.some((e) => e[0] != e[1]?.id)) throw new Error("Item looks like not unordered array");
+  return entries.map((e) => e[1]);
+}
+function generatePatchUnorderedArray(from, to) {
+  if (from.every((e) => typeof e == "object" && "id" in e) && to.every((e) => typeof e == "object" && "id" in e)) {
+    const fObj = unorderedArrayToObject(from);
+    const tObj = unorderedArrayToObject(to);
+    const diff = generatePatchObj(fObj, tObj);
+    if (Object.keys(diff).length > 0) {
+      return { [MARK_ISARRAY]: diff };
+    } else {
+      return {};
+    }
+  }
+  return { [MARK_SWAPPED]: to };
+}
+function generatePatchObj(from, to) {
+  const entries = Object.entries(from);
+  const tempMap = new Map(entries);
+  const ret = {};
+  const newEntries = Object.entries(to);
+  for (const [key, value] of newEntries) {
+    if (!tempMap.has(key)) {
+      ret[key] = value;
+      tempMap.delete(key);
+    } else {
+      const v = tempMap.get(key);
+      if (typeof v !== typeof value || Array.isArray(v) !== Array.isArray(value)) {
+        ret[key] = { [MARK_SWAPPED]: value };
+      } else {
+        if (v === null && value === null) {
+        } else if (v === null && value !== null) {
+          ret[key] = { [MARK_SWAPPED]: value };
+        } else if (v !== null && value === null) {
+          ret[key] = { [MARK_SWAPPED]: value };
+        } else if (typeof v == "object" && typeof value == "object" && !Array.isArray(v) && !Array.isArray(value)) {
+          const wk = generatePatchObj(
+            v,
+            value
+          );
+          if (Object.keys(wk).length > 0) ret[key] = wk;
+        } else if (typeof v == "object" && typeof value == "object" && Array.isArray(v) && Array.isArray(value)) {
+          const wk = generatePatchUnorderedArray(v, value);
+          if (Object.keys(wk).length > 0) ret[key] = wk;
+        } else if (typeof v != "object" && typeof value != "object") {
+          if (JSON.stringify(tempMap.get(key)) !== JSON.stringify(value)) {
+            ret[key] = value;
+          }
+        } else {
+          if (JSON.stringify(tempMap.get(key)) !== JSON.stringify(value)) {
+            ret[key] = { [MARK_SWAPPED]: value };
+          }
+        }
+      }
+      tempMap.delete(key);
+    }
+  }
+  for (const [key] of tempMap) {
+    ret[key] = MARK_DELETED;
+  }
+  return ret;
+}
+function applyPatch(from, patch) {
+  const ret = from;
+  const patches = Object.entries(patch);
+  for (const [key, value] of patches) {
+    if (value == MARK_DELETED) {
+      delete ret[key];
+      continue;
+    }
+    if (value === null) {
+      ret[key] = null;
+      continue;
+    }
+    if (typeof value == "object") {
+      if (MARK_SWAPPED in value) {
+        ret[key] = value[MARK_SWAPPED];
+        continue;
+      }
+      if (MARK_ISARRAY in value) {
+        if (!(key in ret)) ret[key] = [];
+        if (!Array.isArray(ret[key])) {
+          throw new Error("Patch target type is mismatched (array to something)");
+        }
+        const orgArrayObject = unorderedArrayToObject(ret[key]);
+        const appliedObject = applyPatch(
+          orgArrayObject,
+          value[MARK_ISARRAY]
+        );
+        const appliedArray = objectToUnorderedArray(appliedObject);
+        ret[key] = [...appliedArray];
+      } else {
+        if (!(key in ret)) {
+          ret[key] = value;
+          continue;
+        }
+        ret[key] = applyPatch(
+          ret[key],
+          value
+        );
+      }
+    } else {
+      ret[key] = value;
+    }
+  }
+  return ret;
+}
+function mergeObject(objA, objB) {
+  const newEntries = Object.entries(objB);
+  const ret = { ...objA };
+  if (typeof objA !== typeof objB || Array.isArray(objA) !== Array.isArray(objB)) {
+    return objB;
+  }
+  for (const [key, v] of newEntries) {
+    if (key in ret) {
+      const value = ret[key];
+      if (typeof v !== typeof value || Array.isArray(v) !== Array.isArray(value)) {
+        ret[key] = v;
+      } else {
+        if (typeof v == "object" && typeof value == "object" && !Array.isArray(v) && !Array.isArray(value)) {
+          ret[key] = mergeObject(
+            v,
+            value
+          );
+        } else if (typeof v == "object" && typeof value == "object" && Array.isArray(v) && Array.isArray(value)) {
+          ret[key] = [.../* @__PURE__ */ new Set([...v, ...value])];
+        } else {
+          ret[key] = v;
+        }
+      }
+    } else {
+      ret[key] = v;
+    }
+  }
+  const retSorted = Object.fromEntries(Object.entries(ret).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+  if (Array.isArray(objA) && Array.isArray(objB)) {
+    return Object.values(retSorted);
+  }
+  return retSorted;
+}
+function flattenObject(obj, path = []) {
+  if (typeof obj != "object") return [[path.join("."), obj]];
+  if (obj === null) return [[path.join("."), null]];
+  if (Array.isArray(obj)) return [[path.join("."), JSON.stringify(obj)]];
+  const e = Object.entries(obj);
+  const ret = [];
+  for (const [key, value] of e) {
+    const p = flattenObject(value, [...path, key]);
+    ret.push(...p);
+  }
+  return ret;
+}
+function isSensibleMargeApplicable(path) {
+  if (path.endsWith(".md")) return true;
+  return false;
+}
+function isObjectMargeApplicable(path) {
+  if (path.endsWith(".canvas")) return true;
+  if (path.endsWith(".json")) return true;
+  return false;
+}
+export {
+  applyPatch,
+  flattenObject,
+  generatePatchObj,
+  isObjectMargeApplicable,
+  isSensibleMargeApplicable,
+  mergeObject
+};

package/dist/common/utils.type.d.ts

@@ -0,0 +1 @@
+export type Constructor<T> = new (...args: any[]) => T;

package/dist/context.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Instance-owned event and translation capabilities for Commonlib service composition.
+ *
+ * @packageDocumentation
+ */
+export { ServiceContext, createServiceContext, type ServiceContextContract, type ServiceContextOptions, } from "./services/base/ServiceBase.js";
+export { createLiveSyncEventHub, type LiveSyncEventHub } from "./hub/hub.js";
+export { passthroughMessageTranslator, type MessageTranslator, type TranslationParameters, } from "./services/base/MessageTranslator.js";

package/dist/context.js

@@ -0,0 +1,14 @@
+import {
+  ServiceContext,
+  createServiceContext
+} from "./services/base/ServiceBase.js";
+import { createLiveSyncEventHub } from "./hub/hub.js";
+import {
+  passthroughMessageTranslator
+} from "./services/base/MessageTranslator.js";
+export {
+  ServiceContext,
+  createLiveSyncEventHub,
+  createServiceContext,
+  passthroughMessageTranslator
+};

package/dist/databases/IndexedDBKeyValueDatabase.d.ts

@@ -0,0 +1,26 @@
+import { type IDBPDatabase } from "idb";
+import type { KeyValueDatabase, KeyValueDatabaseFactory } from "../interfaces/KeyValueDatabase.js";
+/** Creates an IndexedDB factory with a cache owned by the caller. */
+export declare function createIndexedDBKeyValueDatabaseFactory(): KeyValueDatabaseFactory;
+/** Key-value adapter backed by one IndexedDB object store. */
+export declare class IndexedDBKeyValueDatabase implements KeyValueDatabase {
+    protected databasePromise: Promise<IDBPDatabase<unknown>> | null;
+    protected readonly databaseKey: string;
+    protected readonly storeKey: string;
+    protected destroyed: boolean;
+    protected destroyedPromise: Promise<void> | null;
+    constructor(databaseKey: string);
+    get isDestroyed(): boolean;
+    get ensuredDestroyed(): Promise<void>;
+    getIsReady(): Promise<boolean>;
+    protected ensureDatabase(): Promise<IDBPDatabase<unknown>>;
+    protected closeDatabase(setDestroyed?: boolean): Promise<void>;
+    protected get database(): Promise<IDBPDatabase<unknown>>;
+    get<T>(key: IDBValidKey): Promise<T>;
+    set<T>(key: IDBValidKey, value: T): Promise<IDBValidKey>;
+    del(key: IDBValidKey): Promise<void>;
+    clear(): Promise<void>;
+    keys(query?: IDBValidKey | IDBKeyRange, count?: number): Promise<IDBValidKey[]>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/databases/IndexedDBKeyValueDatabase.js

@@ -0,0 +1,130 @@
+import { deleteDB, openDB } from "idb";
+import { serialized } from "octagonal-wheels/concurrency/lock";
+import { LOG_LEVEL_VERBOSE, Logger } from "../common/logger.js";
+function createIndexedDBKeyValueDatabaseFactory() {
+  const databaseCache = /* @__PURE__ */ new Map();
+  return async (databaseKey) => await serialized(`OpenKeyValueDatabase-${databaseKey}`, async () => {
+    const cachedDatabase = databaseCache.get(databaseKey);
+    if (cachedDatabase) {
+      if (!cachedDatabase.isDestroyed) return cachedDatabase;
+      await cachedDatabase.ensuredDestroyed;
+      databaseCache.delete(databaseKey);
+    }
+    const database = new IndexedDBKeyValueDatabase(databaseKey);
+    try {
+      await database.getIsReady();
+      databaseCache.set(databaseKey, database);
+      return database;
+    } catch (error) {
+      databaseCache.delete(databaseKey);
+      throw error;
+    }
+  });
+}
+class IndexedDBKeyValueDatabase {
+  databasePromise = null;
+  databaseKey;
+  storeKey;
+  destroyed = false;
+  destroyedPromise = null;
+  constructor(databaseKey) {
+    this.databaseKey = databaseKey;
+    this.storeKey = databaseKey;
+  }
+  get isDestroyed() {
+    return this.destroyed;
+  }
+  get ensuredDestroyed() {
+    return this.destroyedPromise ?? Promise.resolve();
+  }
+  async getIsReady() {
+    await this.ensureDatabase();
+    return !this.destroyed;
+  }
+  ensureDatabase() {
+    if (this.destroyed) throw new Error("Database is destroyed");
+    if (this.databasePromise) return this.databasePromise;
+    this.databasePromise = openDB(this.databaseKey, void 0, {
+      upgrade: (database) => {
+        if (!database.objectStoreNames.contains(this.storeKey)) {
+          return database.createObjectStore(this.storeKey);
+        }
+      },
+      blocking: (currentVersion, blockedVersion) => {
+        Logger(
+          `Blocking database open for ${this.databaseKey}: currentVersion=${currentVersion}, blockedVersion=${blockedVersion}`,
+          LOG_LEVEL_VERBOSE
+        );
+        void this.closeDatabase(true);
+      },
+      blocked: (currentVersion, blockedVersion) => {
+        Logger(
+          `Database open blocked for ${this.databaseKey}: currentVersion=${currentVersion}, blockedVersion=${blockedVersion}`,
+          LOG_LEVEL_VERBOSE
+        );
+      },
+      terminated: () => {
+        Logger(`Database connection terminated for ${this.databaseKey}`, LOG_LEVEL_VERBOSE);
+        this.databasePromise = null;
+      }
+    }).catch((error) => {
+      this.databasePromise = null;
+      throw error;
+    });
+    return this.databasePromise;
+  }
+  async closeDatabase(setDestroyed = false) {
+    if (this.databasePromise) {
+      const databasePromise = this.databasePromise;
+      this.databasePromise = null;
+      try {
+        const database = await databasePromise;
+        database.close();
+      } catch (error) {
+        Logger("Error closing database");
+        Logger(error, LOG_LEVEL_VERBOSE);
+      }
+    }
+    if (setDestroyed) {
+      this.destroyed = true;
+      this.destroyedPromise = Promise.resolve();
+    }
+  }
+  get database() {
+    if (this.destroyed) return Promise.reject(new Error("Database is destroyed"));
+    return this.ensureDatabase();
+  }
+  async get(key) {
+    return await (await this.database).get(this.storeKey, key);
+  }
+  async set(key, value) {
+    await (await this.database).put(this.storeKey, value, key);
+    return key;
+  }
+  async del(key) {
+    await (await this.database).delete(this.storeKey, key);
+  }
+  async clear() {
+    await (await this.database).clear(this.storeKey);
+  }
+  async keys(query, count) {
+    return await (await this.database).getAllKeys(this.storeKey, query, count);
+  }
+  async close() {
+    await this.closeDatabase();
+  }
+  async destroy() {
+    this.destroyed = true;
+    this.destroyedPromise = (async () => {
+      await this.closeDatabase();
+      await deleteDB(this.databaseKey, {
+        blocked: () => Logger(`Database delete blocked for ${this.databaseKey}`)
+      });
+    })();
+    await this.destroyedPromise;
+  }
+}
+export {
+  IndexedDBKeyValueDatabase,
+  createIndexedDBKeyValueDatabaseFactory
+};

package/dist/dataobject/StoredMap.d.ts

@@ -0,0 +1,12 @@
+import type { SimpleStore } from "octagonal-wheels/databases/SimpleStoreBase";
+export declare class StoredMapLike<U> {
+    _store: SimpleStore<U>;
+    _cache: Map<string, U>;
+    _prefix: string;
+    constructor(store: SimpleStore<Awaited<U>>, prefix?: string);
+    addPrefix(key: string): string;
+    get(key: string): Promise<U | undefined>;
+    set(key: string, value: U): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
+}

package/dist/dataobject/StoredMap.js

@@ -0,0 +1,47 @@
+class StoredMapLike {
+  _store;
+  _cache = /* @__PURE__ */ new Map();
+  _prefix = "";
+  constructor(store, prefix = "") {
+    this._store = store;
+  }
+  addPrefix(key) {
+    return `${this._prefix}-${key}`;
+  }
+  async get(key) {
+    if (this._cache.has(key)) return this._cache.get(key);
+    const value = await this._store.get(this.addPrefix(key));
+    if (value !== void 0) {
+      this._cache.set(key, value);
+    }
+    return value;
+  }
+  async set(key, value) {
+    try {
+      const ret = await this._store.set(this.addPrefix(key), value);
+      this._cache.set(key, value);
+      return ret;
+    } catch (e) {
+      this._cache.delete(key);
+      throw e;
+    }
+  }
+  async delete(key) {
+    try {
+      const ret = await this._store.delete(this.addPrefix(key));
+      this._cache.delete(key);
+      return ret;
+    } catch (e) {
+      this._cache.delete(key);
+      throw e;
+    }
+  }
+  async has(key) {
+    if (this._cache.has(key)) return true;
+    const e = await this._store.keys(this.addPrefix(key), key);
+    return e.length > 0;
+  }
+}
+export {
+  StoredMapLike
+};

package/dist/dev/checks.d.ts

@@ -0,0 +1,5 @@
+interface InstanceHaveOnBindFunction<T> {
+    onBindFunction: (...params: T[]) => void;
+}
+export declare function __$checkInstanceBinding<T extends InstanceHaveOnBindFunction<any>>(instance: T): void;
+export {};

package/dist/dev/checks.js

@@ -0,0 +1,38 @@
+import { LOG_LEVEL_DEBUG, Logger } from "octagonal-wheels/common/logger";
+function __$checkInstanceBinding(instance) {
+  const thisName = instance.constructor.name;
+  const functions = [];
+  for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(instance))) {
+    if (key.startsWith("_") && !key.startsWith("__")) {
+      const method = instance[key];
+      if (typeof method === "function") {
+        functions.push(`${thisName}.${key}`);
+      }
+    }
+  }
+  const onBindFunctionStr = instance.onBindFunction.toString();
+  const functionsOnBindFunction = [];
+  const functionsOnBindFunctionMatch = onBindFunctionStr.match(/this\.(_[a-zA-Z0-9_]+)/g);
+  if (functionsOnBindFunctionMatch) {
+    functionsOnBindFunction.push(
+      ...functionsOnBindFunctionMatch.map((f) => `${thisName}.${f.replace(/this\./, "")}`)
+    );
+  }
+  const setOfThisFunctions = new Set(functions);
+  const setOfOnBindFunctions = new Set(functionsOnBindFunction);
+  const setAll = /* @__PURE__ */ new Set([...setOfThisFunctions, ...setOfOnBindFunctions]);
+  const missingInThis = [...setAll].filter((e) => !setOfThisFunctions.has(e));
+  const missingInOnBind = [...setAll].filter((e) => !setOfOnBindFunctions.has(e));
+  if (missingInThis.length > 0) {
+    Logger(`[${thisName}] \u26A0\uFE0F Missing functions in this: ${missingInThis.join(", ")}`);
+  }
+  if (missingInOnBind.length > 0) {
+    Logger(`[${thisName}] \u26A0\uFE0F Missing functions in onBindFunction: ${missingInOnBind.join(", ")}`);
+  }
+  if (missingInThis.length == 0 && missingInOnBind.length == 0) {
+    Logger(`[${thisName}] All functions are properly bound`, LOG_LEVEL_DEBUG);
+  }
+}
+export {
+  __$checkInstanceBinding
+};

package/dist/encryption/encryptHKDF.d.ts

@@ -0,0 +1,3 @@
+import { encryptHKDFWorker, decryptHKDFWorker } from "#worker";
+export declare const encryptHKDF: typeof encryptHKDFWorker;
+export declare const decryptHKDF: typeof decryptHKDFWorker;

package/dist/encryption/encryptHKDF.js

@@ -0,0 +1,7 @@
+import { encryptHKDFWorker, decryptHKDFWorker } from "#worker";
+const encryptHKDF = encryptHKDFWorker;
+const decryptHKDF = decryptHKDFWorker;
+export {
+  decryptHKDF,
+  encryptHKDF
+};

package/dist/encryption/stringEncryption.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Encrypts a string using a passphrase, unless the string is already encrypted.
+ *
+ * If the input string begins with `ENCRYPT_V2_PREFIX` or `HKDF_SALTED_ENCRYPTED_PREFIX`,
+ * we assume it is already encrypted and return it unchanged.
+ * Otherwise, we encrypt the string using an ephemeral salt and the provided passphrase.
+ *
+ * @param source - The plaintext string to encrypt, or an already encrypted string.
+ * @param passphrase - The passphrase used for encryption.
+ * @returns A promise resolving to the encrypted string, or the original string if it is already encrypted.
+ */
+export declare function encryptString(source: string, passphrase: string): Promise<string>;
+/**
+ * Decrypts an encrypted string using the provided passphrase.
+ *
+ * This function determines the encryption format by inspecting the string prefix, then applies
+ * the appropriate decryption method. It supports several encryption formats, including
+ * HKDF salted encryption and legacy formats (V1, V2, V3). If the format is not supported,
+ * an error is thrown.
+ *
+ * @param encrypted - The encrypted string to decrypt.
+ * @param passphrase - The passphrase used for decryption.
+ * @returns A promise resolving to the decrypted string.
+ * @throws {Error} If the encryption format is unsupported.
+ */
+export declare function decryptString(encrypted: string, passphrase: string): Promise<string>;
+export declare function tryDecryptString(encrypted: string, passphrase: string | false): Promise<string | false>;

package/dist/encryption/stringEncryption.js

@@ -0,0 +1,59 @@
+import {
+  decrypt,
+  ENCRYPT_V2_PREFIX,
+  ENCRYPT_V3_PREFIX,
+  ENCRYPT_V1_PREFIX_PROBABLY
+} from "octagonal-wheels/encryption/encryption";
+import {
+  encryptWithEphemeralSalt,
+  decryptWithEphemeralSalt,
+  HKDF_SALTED_ENCRYPTED_PREFIX
+} from "octagonal-wheels/encryption/hkdf";
+import { LOG_LEVEL_VERBOSE, Logger } from "../common/logger.js";
+async function encryptString(source, passphrase) {
+  if (source.startsWith(ENCRYPT_V2_PREFIX)) {
+    return source;
+  } else if (source.startsWith(HKDF_SALTED_ENCRYPTED_PREFIX)) {
+    return source;
+  } else {
+    return await encryptWithEphemeralSalt(source, passphrase);
+  }
+}
+async function tryDecryption(trials) {
+  for (const trial of trials) {
+    try {
+      return await trial();
+    } catch (error) {
+      Logger(`Decryption trial failed!`, LOG_LEVEL_VERBOSE);
+      Logger(error, LOG_LEVEL_VERBOSE);
+    }
+  }
+  throw new Error("All decryption trials failed");
+}
+async function decryptString(encrypted, passphrase) {
+  if (encrypted.startsWith(HKDF_SALTED_ENCRYPTED_PREFIX)) {
+    return decryptWithEphemeralSalt(encrypted, passphrase);
+  } else if (encrypted.startsWith(ENCRYPT_V2_PREFIX) || encrypted.startsWith(ENCRYPT_V3_PREFIX) || encrypted.startsWith(ENCRYPT_V1_PREFIX_PROBABLY)) {
+    return await tryDecryption([
+      async () => await decrypt(encrypted, passphrase, false),
+      async () => await decrypt(encrypted, passphrase, true)
+      // Try with legacy support
+    ]);
+  } else {
+    throw new Error("Unsupported encryption format");
+  }
+}
+async function tryDecryptString(encrypted, passphrase) {
+  try {
+    return await decryptString(encrypted, passphrase);
+  } catch (error) {
+    Logger(`Decryption failed!`, LOG_LEVEL_VERBOSE);
+    Logger(error, LOG_LEVEL_VERBOSE);
+    return false;
+  }
+}
+export {
+  decryptString,
+  encryptString,
+  tryDecryptString
+};

package/dist/events/coreEvents.d.ts

@@ -0,0 +1,54 @@
+import type { FilePathWithPrefix, ObsidianLiveSyncSettings } from "../common/types.js";
+export declare const EVENT_LAYOUT_READY = "layout-ready";
+export declare const EVENT_PLUGIN_LOADED = "plugin-loaded";
+export declare const EVENT_PLUGIN_UNLOADED = "plugin-unloaded";
+export declare const EVENT_SETTING_SAVED = "setting-saved";
+export declare const EVENT_FILE_RENAMED = "file-renamed";
+export declare const EVENT_FILE_SAVED = "file-saved";
+export declare const EVENT_LEAF_ACTIVE_CHANGED = "leaf-active-changed";
+export declare const EVENT_DATABASE_REBUILT = "database-rebuilt";
+export declare const EVENT_LOG_ADDED = "log-added";
+export declare const EVENT_REQUEST_OPEN_SETUP_URI = "request-open-setup-uri";
+export declare const EVENT_REQUEST_COPY_SETUP_URI = "request-copy-setup-uri";
+export declare const EVENT_REQUEST_SHOW_SETUP_QR = "request-show-setup-qr";
+export declare const EVENT_REQUEST_RELOAD_SETTING_TAB = "reload-setting-tab";
+export declare const EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG = "request-open-plugin-sync-dialog";
+export declare const EVENT_FILE_CHANGED = "event-file-changed";
+export declare const EVENT_REQUEST_OPEN_P2P_SETTINGS = "request-open-p2p-settings";
+export declare const EVENT_REQUEST_OPEN_P2P = "request-open-p2p";
+export declare const EVENT_REQUEST_CLOSE_P2P = "request-close-p2p";
+export declare const EVENT_PLATFORM_UNLOADED = "platform-unloaded";
+export declare const EVENT_ON_UNRESOLVED_ERROR = "on-unresolved-error";
+export declare const EVENT_REQUEST_CHECK_REMOTE_SIZE = "request-check-remote-size";
+export declare const EVENT_CONFLICT_CANCELLED = "conflict-cancelled";
+declare global {
+    interface LSEvents {
+        [EVENT_PLUGIN_LOADED]: undefined;
+        [EVENT_PLUGIN_UNLOADED]: undefined;
+        [EVENT_FILE_SAVED]: undefined;
+        [EVENT_SETTING_SAVED]: ObsidianLiveSyncSettings;
+        [EVENT_LAYOUT_READY]: undefined;
+        [EVENT_FILE_CHANGED]: {
+            file: FilePathWithPrefix;
+            automated: boolean;
+        };
+        [EVENT_FILE_RENAMED]: {
+            newPath: FilePathWithPrefix;
+            old: FilePathWithPrefix;
+        };
+        [EVENT_DATABASE_REBUILT]: undefined;
+        [EVENT_REQUEST_OPEN_P2P_SETTINGS]: undefined;
+        [EVENT_LEAF_ACTIVE_CHANGED]: undefined;
+        [EVENT_REQUEST_OPEN_SETUP_URI]: undefined;
+        [EVENT_REQUEST_COPY_SETUP_URI]: undefined;
+        [EVENT_REQUEST_RELOAD_SETTING_TAB]: undefined;
+        [EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG]: undefined;
+        [EVENT_REQUEST_SHOW_SETUP_QR]: undefined;
+        [EVENT_REQUEST_OPEN_P2P]: undefined;
+        [EVENT_REQUEST_CLOSE_P2P]: undefined;
+        [EVENT_PLATFORM_UNLOADED]: undefined;
+        [EVENT_ON_UNRESOLVED_ERROR]: undefined;
+        [EVENT_REQUEST_CHECK_REMOTE_SIZE]: undefined;
+        [EVENT_CONFLICT_CANCELLED]: FilePathWithPrefix;
+    }
+}

package/dist/events/coreEvents.js

@@ -0,0 +1,46 @@
+const EVENT_LAYOUT_READY = "layout-ready";
+const EVENT_PLUGIN_LOADED = "plugin-loaded";
+const EVENT_PLUGIN_UNLOADED = "plugin-unloaded";
+const EVENT_SETTING_SAVED = "setting-saved";
+const EVENT_FILE_RENAMED = "file-renamed";
+const EVENT_FILE_SAVED = "file-saved";
+const EVENT_LEAF_ACTIVE_CHANGED = "leaf-active-changed";
+const EVENT_DATABASE_REBUILT = "database-rebuilt";
+const EVENT_LOG_ADDED = "log-added";
+const EVENT_REQUEST_OPEN_SETUP_URI = "request-open-setup-uri";
+const EVENT_REQUEST_COPY_SETUP_URI = "request-copy-setup-uri";
+const EVENT_REQUEST_SHOW_SETUP_QR = "request-show-setup-qr";
+const EVENT_REQUEST_RELOAD_SETTING_TAB = "reload-setting-tab";
+const EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG = "request-open-plugin-sync-dialog";
+const EVENT_FILE_CHANGED = "event-file-changed";
+const EVENT_REQUEST_OPEN_P2P_SETTINGS = "request-open-p2p-settings";
+const EVENT_REQUEST_OPEN_P2P = "request-open-p2p";
+const EVENT_REQUEST_CLOSE_P2P = "request-close-p2p";
+const EVENT_PLATFORM_UNLOADED = "platform-unloaded";
+const EVENT_ON_UNRESOLVED_ERROR = "on-unresolved-error";
+const EVENT_REQUEST_CHECK_REMOTE_SIZE = "request-check-remote-size";
+const EVENT_CONFLICT_CANCELLED = "conflict-cancelled";
+export {
+  EVENT_CONFLICT_CANCELLED,
+  EVENT_DATABASE_REBUILT,
+  EVENT_FILE_CHANGED,
+  EVENT_FILE_RENAMED,
+  EVENT_FILE_SAVED,
+  EVENT_LAYOUT_READY,
+  EVENT_LEAF_ACTIVE_CHANGED,
+  EVENT_LOG_ADDED,
+  EVENT_ON_UNRESOLVED_ERROR,
+  EVENT_PLATFORM_UNLOADED,
+  EVENT_PLUGIN_LOADED,
+  EVENT_PLUGIN_UNLOADED,
+  EVENT_REQUEST_CHECK_REMOTE_SIZE,
+  EVENT_REQUEST_CLOSE_P2P,
+  EVENT_REQUEST_COPY_SETUP_URI,
+  EVENT_REQUEST_OPEN_P2P,
+  EVENT_REQUEST_OPEN_P2P_SETTINGS,
+  EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG,
+  EVENT_REQUEST_OPEN_SETUP_URI,
+  EVENT_REQUEST_RELOAD_SETTING_TAB,
+  EVENT_REQUEST_SHOW_SETUP_QR,
+  EVENT_SETTING_SAVED
+};