@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/managers/ChunkFetcher.d.ts

@@ -0,0 +1,44 @@
+import { type DocumentID } from "../common/types.js";
+import { type ChunkManager } from "./ChunkManager.js";
+import type { IReplicatorService, ISettingService } from "../services/base/IService.js";
+export declare const EVENT_MISSING_CHUNKS = "missingChunks";
+export declare const EVENT_MISSING_CHUNK_REMOTE = "missingChunkRemote";
+export declare const EVENT_CHUNK_FETCHED = "chunkFetched";
+export type ChunkFetcherOptions = {
+    settingService: ISettingService;
+    chunkManager: ChunkManager;
+    replicatorService: IReplicatorService;
+    deliveryStallTimeoutMs?: number;
+};
+export declare class ChunkFetcher {
+    options: ChunkFetcherOptions;
+    get chunkManager(): ChunkManager;
+    queue: DocumentID[];
+    private readonly pendingClaims;
+    private destroyed;
+    get interval(): number;
+    get concurrency(): number;
+    abort: AbortController;
+    constructor(options: ChunkFetcherOptions);
+    destroy(): void;
+    onEventHandler: (ids: DocumentID[]) => void;
+    onEvent(ids: DocumentID[]): void;
+    private ensureClaims;
+    private removePendingDelivery;
+    private onClaimStalled;
+    private settleClaim;
+    private touchClaims;
+    private waitForActivityBoundary;
+    /**
+     * Processing requests
+     */
+    currentProcessing: number;
+    /**
+     * Time of the last request to the remote server.
+     * This is used to manage the interval between requests.
+     * Even if concurrency allows, every start of a request will ensure that the interval is respected.
+     */
+    previousRequestTime: number;
+    canRequestMore(): boolean;
+    requestMissingChunks(): Promise<void>;
+}

package/dist/managers/ChunkFetcher.js

@@ -0,0 +1,251 @@
+import { delay, promiseWithResolvers } from "octagonal-wheels/promises";
+import { unique } from "octagonal-wheels/collection";
+import { LOG_LEVEL_VERBOSE, Logger } from "../common/logger.js";
+import { DEFAULT_SETTINGS } from "../common/types.js";
+import {} from "./ChunkManager.js";
+import { compatGlobal } from "../common/coreEnvFunctions.js";
+import { DEFAULT_CHUNK_DELIVERY_STALL_TIMEOUT_MS } from "./ChunkDeliveryCoordinator.js";
+const EVENT_MISSING_CHUNKS = "missingChunks";
+const EVENT_MISSING_CHUNK_REMOTE = "missingChunkRemote";
+const EVENT_CHUNK_FETCHED = "chunkFetched";
+const BATCH_SIZE = 100;
+class ChunkFetcher {
+  options;
+  get chunkManager() {
+    return this.options.chunkManager;
+  }
+  queue = [];
+  pendingClaims = /* @__PURE__ */ new Map();
+  destroyed = false;
+  get interval() {
+    const settings = this.options.settingService.currentSettings();
+    return settings.minimumIntervalOfReadChunksOnline || DEFAULT_SETTINGS.minimumIntervalOfReadChunksOnline;
+  }
+  get concurrency() {
+    const settings = this.options.settingService.currentSettings();
+    return settings.concurrencyOfReadChunksOnline || DEFAULT_SETTINGS.concurrencyOfReadChunksOnline;
+  }
+  abort = new AbortController();
+  constructor(options) {
+    this.options = options;
+    this.chunkManager.addListener(EVENT_MISSING_CHUNKS, this.onEventHandler, {
+      signal: this.abort.signal
+    });
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.abort.abort();
+    this.queue = [];
+    const pendingDeliveries = new Set(this.pendingClaims.values());
+    this.pendingClaims.clear();
+    for (const pending of pendingDeliveries) {
+      pending.resolveActivityBoundary(false);
+      pending.claim.release();
+    }
+  }
+  onEventHandler = this.onEvent.bind(this);
+  onEvent(ids) {
+    if (this.destroyed) return;
+    const claimedIds = this.ensureClaims(ids);
+    this.queue = unique([...this.queue, ...claimedIds]);
+    if (this.canRequestMore()) {
+      compatGlobal.setTimeout(() => void this.requestMissingChunks(), 1);
+    }
+  }
+  ensureClaims(ids) {
+    const unclaimedIds = unique(ids.filter((id) => !this.pendingClaims.has(id)));
+    if (unclaimedIds.length === 0) return [];
+    let pending;
+    const activityBoundary = promiseWithResolvers();
+    const claim = this.chunkManager.deliveryCoordinator.claim(unclaimedIds, {
+      stallTimeoutMs: this.options.deliveryStallTimeoutMs ?? DEFAULT_CHUNK_DELIVERY_STALL_TIMEOUT_MS,
+      onStalled: (stalledIds) => this.onClaimStalled(pending, stalledIds)
+    });
+    pending = {
+      activityBoundaryEntered: activityBoundary.promise,
+      claim,
+      resolveActivityBoundary: activityBoundary.resolve
+    };
+    for (const id of unclaimedIds) {
+      this.pendingClaims.set(id, pending);
+    }
+    void this.options.replicatorService.runBoundedRemoteActivity(
+      () => {
+        pending.claim.touch();
+        pending.resolveActivityBoundary(true);
+        return claim.done;
+      },
+      { label: "chunk-fetch" }
+    ).catch((error) => {
+      const abandonedIds = claim.pendingIds;
+      pending.resolveActivityBoundary(false);
+      this.removePendingDelivery(pending, abandonedIds);
+      claim.release();
+      Logger("The chunk-delivery activity runner rejected before the claim settled.", LOG_LEVEL_VERBOSE);
+      Logger(error, LOG_LEVEL_VERBOSE);
+    });
+    return unclaimedIds;
+  }
+  removePendingDelivery(pending, ids) {
+    for (const id of ids) {
+      if (this.pendingClaims.get(id) === pending) {
+        this.pendingClaims.delete(id);
+      }
+    }
+    const removed = new Set(ids);
+    this.queue = this.queue.filter((id) => !(removed.has(id) && !this.pendingClaims.has(id)));
+  }
+  onClaimStalled(pending, stalledIds) {
+    pending.resolveActivityBoundary(false);
+    this.removePendingDelivery(pending, stalledIds);
+    Logger(`Chunk delivery stalled for the following IDs: ${stalledIds.join(", ")}`, LOG_LEVEL_VERBOSE);
+  }
+  settleClaim(id) {
+    const pending = this.pendingClaims.get(id);
+    if (!pending) return;
+    this.pendingClaims.delete(id);
+    pending.claim.settle(id);
+  }
+  touchClaims(ids) {
+    const pendingDeliveries = new Set(
+      ids.map((id) => this.pendingClaims.get(id)).filter((pending) => pending !== void 0)
+    );
+    for (const pending of pendingDeliveries) {
+      pending.claim.touch();
+    }
+  }
+  async waitForActivityBoundary(ids) {
+    const pendingDeliveries = new Set(
+      ids.map((id) => this.pendingClaims.get(id)).filter((pending) => pending !== void 0)
+    );
+    const entered = new Map(
+      await Promise.all(
+        [...pendingDeliveries].map(async (pending) => [pending, await pending.activityBoundaryEntered])
+      )
+    );
+    return ids.filter((id) => {
+      const pending = this.pendingClaims.get(id);
+      return pending !== void 0 && entered.get(pending) === true;
+    });
+  }
+  /**
+   * Processing requests
+   */
+  currentProcessing = 0;
+  /**
+   * Time of the last request to the remote server.
+   * This is used to manage the interval between requests.
+   * Even if concurrency allows, every start of a request will ensure that the interval is respected.
+   */
+  previousRequestTime = 0;
+  canRequestMore() {
+    return this.currentProcessing < this.concurrency && this.queue.length > 0;
+  }
+  async requestMissingChunks() {
+    if (this.destroyed || !this.canRequestMore()) {
+      return;
+    }
+    let requestIDs = [];
+    try {
+      let isValidChunk2 = function(chunk) {
+        return chunk && typeof chunk?._id === "string" && typeof chunk?.data === "string";
+      };
+      var isValidChunk = isValidChunk2;
+      this.currentProcessing++;
+      requestIDs = this.queue.splice(0, BATCH_SIZE);
+      this.ensureClaims(requestIDs);
+      requestIDs = await this.waitForActivityBoundary(requestIDs);
+      if (requestIDs.length === 0) return;
+      this.touchClaims(requestIDs);
+      const now = Date.now();
+      const timeSinceLastRequest = now - this.previousRequestTime;
+      this.previousRequestTime = now;
+      const timeToWait = Math.max(this.interval - timeSinceLastRequest, 0);
+      if (timeToWait > 0) await delay(timeToWait);
+      this.touchClaims(requestIDs);
+      const replicator = this.options.replicatorService.getActiveReplicator();
+      if (!replicator) {
+        Logger("No active replicator was found to request missing chunks.");
+        return;
+      }
+      const fetched = await replicator.fetchRemoteChunks(requestIDs, false);
+      this.touchClaims(requestIDs);
+      if (!fetched) {
+        Logger(`No chunks were found for the following IDs: ${requestIDs.join(", ")}`);
+        for (const chunkID of requestIDs) {
+          this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+        }
+        return;
+      }
+      const chunks = fetched.filter((chunk) => isValidChunk2(chunk));
+      if (chunks.length !== fetched.length) {
+        Logger(
+          `Some fetched chunks are invalid and will be ignored: (${fetched.length - chunks.length} / ${fetched.length}).`,
+          LOG_LEVEL_VERBOSE
+        );
+        for (const chunk of fetched) {
+          if (!isValidChunk2(chunk)) {
+            Logger(`Invalid chunk: ${JSON.stringify(chunk)}`, LOG_LEVEL_VERBOSE);
+          }
+        }
+      }
+      if (chunks.length === 0) {
+        Logger(`No valid chunks were found for the following IDs: ${requestIDs.join(", ")}`);
+      }
+      const missingIDs = requestIDs.filter((id) => !chunks.some((chunk) => chunk._id === id));
+      try {
+        if (chunks.length === 0) {
+          return;
+        }
+        Logger(`Writing fetched chunks (${chunks.length}) to the database...`);
+        const result = await this.chunkManager.write(
+          chunks,
+          {
+            skipCache: true,
+            force: true
+            // Force writing to ensure the chunks with existing _rev.
+          },
+          "ChunkFetcher"
+        );
+        this.touchClaims(requestIDs);
+        if (result.result === true) {
+          Logger(`Fetched chunks were stored successfully: ${chunks.length}`, LOG_LEVEL_VERBOSE);
+        } else {
+          Logger(
+            `Fetched chunks could not be stored: ${chunks.map((chunk) => chunk._id).join(", ")}`,
+            LOG_LEVEL_VERBOSE
+          );
+        }
+      } catch (error) {
+        Logger(`An error occurred while storing fetched chunks!`, LOG_LEVEL_VERBOSE);
+        Logger(error, LOG_LEVEL_VERBOSE);
+      } finally {
+        for (const chunk of chunks) {
+          this.chunkManager.emitEvent(EVENT_CHUNK_FETCHED, chunk);
+        }
+        for (const chunkID of missingIDs) {
+          this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+        }
+      }
+    } catch (error) {
+      Logger("An error occurred while fetching remote chunks.", LOG_LEVEL_VERBOSE);
+      Logger(error, LOG_LEVEL_VERBOSE);
+    } finally {
+      for (const id of requestIDs) {
+        this.settleClaim(id);
+      }
+      this.currentProcessing--;
+      this.previousRequestTime = Date.now();
+      if (this.queue.length > 0) {
+        compatGlobal.setTimeout(() => void this.requestMissingChunks(), 0);
+      }
+    }
+  }
+}
+export {
+  ChunkFetcher,
+  EVENT_CHUNK_FETCHED,
+  EVENT_MISSING_CHUNKS,
+  EVENT_MISSING_CHUNK_REMOTE
+};

package/dist/managers/ChunkManager.d.ts

@@ -0,0 +1,2 @@
+import { LayeredChunkManager } from "./LayeredChunkManager.js";
+export { LayeredChunkManager as ChunkManager };

package/dist/managers/ChunkManager.js

@@ -0,0 +1,4 @@
+import { LayeredChunkManager } from "./LayeredChunkManager.js";
+export {
+  LayeredChunkManager as ChunkManager
+};

package/dist/managers/ConflictManager.d.ts

@@ -0,0 +1,37 @@
+import { type Diff } from "diff-match-patch";
+import { type EntryDoc, type FilePathWithPrefix, type diff_result_leaf, type LoadedEntry, type DIFF_CHECK_RESULT_AUTO } from "../common/types.js";
+import type { EntryManager } from "./EntryManager/EntryManager.js";
+import type { IPathService } from "../services/base/IService.js";
+type AutoMergeOutcomeOK = {
+    ok: DIFF_CHECK_RESULT_AUTO;
+};
+type AutoMergeCanBeDoneByDeletingRev = {
+    result: string;
+    conflictedRev: string;
+};
+type UserActionRequired = {
+    leftRev: string;
+    rightRev: string;
+    leftLeaf: diff_result_leaf | false;
+    rightLeaf: diff_result_leaf | false;
+};
+export type AutoMergeResult = Promise<AutoMergeOutcomeOK | AutoMergeCanBeDoneByDeletingRev | UserActionRequired>;
+export interface ConflictManagerOptions {
+    entryManager: EntryManager;
+    pathService: IPathService;
+    database: PouchDB.Database<EntryDoc>;
+}
+export declare class ConflictManager {
+    options: ConflictManagerOptions;
+    constructor(options: ConflictManagerOptions);
+    get database(): PouchDB.Database<EntryDoc>;
+    getConflictedDoc(path: FilePathWithPrefix, rev: string): Promise<false | diff_result_leaf>;
+    mergeSensibly(path: FilePathWithPrefix, baseRev: string, currentRev: string, conflictedRev: string): Promise<Diff[] | false>;
+    mergeObject(path: FilePathWithPrefix, baseRev: string, currentRev: string, conflictedRev: string): Promise<string | false>;
+    tryAutoMergeSensibly(path: FilePathWithPrefix, test: LoadedEntry, conflicts: string[]): Promise<false | {
+        result: string;
+        conflictedRev: string;
+    }>;
+    tryAutoMerge(path: FilePathWithPrefix, enableMarkdownAutoMerge: boolean): AutoMergeResult;
+}
+export {};

package/dist/managers/ConflictManager.js

@@ -0,0 +1,322 @@
+import { diff_match_patch, DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL } from "diff-match-patch";
+import { readString, decodeBinary } from "octagonal-wheels/binary";
+import { Logger, LOG_LEVEL_VERBOSE, LOG_LEVEL_INFO } from "octagonal-wheels/common/logger";
+import {
+  MISSING_OR_ERROR,
+  NOT_CONFLICTED
+} from "../common/types.js";
+import {
+  getDocData,
+  tryParseJSON,
+  generatePatchObj,
+  flattenObject,
+  applyPatch,
+  isSensibleMargeApplicable,
+  isObjectMargeApplicable
+} from "../common/utils.js";
+import { isErrorOfMissingDoc } from "../pouchdb/utils_couchdb.js";
+class ConflictManager {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  get database() {
+    return this.options.database;
+  }
+  async getConflictedDoc(path, rev) {
+    try {
+      const doc = await this.options.entryManager.getDBEntry(path, { rev }, false, true, true);
+      if (doc === false) return false;
+      let data = getDocData(doc.data);
+      if (doc.datatype == "newnote") {
+        data = readString(new Uint8Array(decodeBinary(doc.data)));
+      } else if (doc.datatype == "plain") {
+      }
+      return {
+        deleted: doc.deleted || doc._deleted,
+        ctime: doc.ctime,
+        mtime: doc.mtime,
+        rev,
+        data
+      };
+    } catch (ex) {
+      if (isErrorOfMissingDoc(ex)) {
+        return false;
+      }
+    }
+    return false;
+  }
+  async mergeSensibly(path, baseRev, currentRev, conflictedRev) {
+    const baseLeaf = await this.getConflictedDoc(path, baseRev);
+    const leftLeaf = await this.getConflictedDoc(path, currentRev);
+    const rightLeaf = await this.getConflictedDoc(path, conflictedRev);
+    let autoMerge = false;
+    if (baseLeaf == false || leftLeaf == false || rightLeaf == false) {
+      return false;
+    }
+    if (leftLeaf.deleted || rightLeaf.deleted) {
+      return false;
+    }
+    const dmp = new diff_match_patch();
+    const mapLeft = dmp.diff_linesToChars_(baseLeaf.data, leftLeaf.data);
+    const diffLeftSrc = dmp.diff_main(mapLeft.chars1, mapLeft.chars2, false);
+    dmp.diff_charsToLines_(diffLeftSrc, mapLeft.lineArray);
+    const mapRight = dmp.diff_linesToChars_(baseLeaf.data, rightLeaf.data);
+    const diffRightSrc = dmp.diff_main(mapRight.chars1, mapRight.chars2, false);
+    dmp.diff_charsToLines_(diffRightSrc, mapRight.lineArray);
+    function splitDiffPiece(src) {
+      const ret = [];
+      do {
+        const d = src.shift();
+        if (d === void 0) {
+          return ret;
+        }
+        const pieces = d[1].split(/([^\n]*\n)/).filter((f) => f != "");
+        if (typeof d == "undefined") {
+          break;
+        }
+        if (d[0] != DIFF_DELETE) {
+          ret.push(...pieces.map((e) => [d[0], e]));
+        }
+        if (d[0] == DIFF_DELETE) {
+          const nd = src.shift();
+          if (typeof nd != "undefined") {
+            const piecesPair = nd[1].split(/([^\n]*\n)/).filter((f) => f != "");
+            if (nd[0] == DIFF_INSERT) {
+              for (const pt of pieces) {
+                ret.push([d[0], pt]);
+                const pairP = piecesPair.shift();
+                if (typeof pairP != "undefined") ret.push([DIFF_INSERT, pairP]);
+              }
+              ret.push(...piecesPair.map((e) => [nd[0], e]));
+            } else {
+              ret.push(...pieces.map((e) => [d[0], e]));
+              ret.push(...piecesPair.map((e) => [nd[0], e]));
+            }
+          } else {
+            ret.push(...pieces.map((e) => [0, e]));
+          }
+        }
+      } while (src.length > 0);
+      return ret;
+    }
+    const diffLeft = splitDiffPiece(diffLeftSrc);
+    const diffRight = splitDiffPiece(diffRightSrc);
+    let rightIdx = 0;
+    let leftIdx = 0;
+    const merged = [];
+    autoMerge = true;
+    LOOP_MERGE: do {
+      if (leftIdx >= diffLeft.length && rightIdx >= diffRight.length) {
+        break LOOP_MERGE;
+      }
+      const leftItem = diffLeft[leftIdx] ?? [0, ""];
+      const rightItem = diffRight[rightIdx] ?? [0, ""];
+      leftIdx++;
+      rightIdx++;
+      if (leftItem[0] == DIFF_EQUAL && rightItem[0] == DIFF_EQUAL && leftItem[1] == rightItem[1]) {
+        merged.push(leftItem);
+        continue;
+      }
+      if (leftItem[0] == DIFF_DELETE && rightItem[0] == DIFF_DELETE && leftItem[1] == rightItem[1]) {
+        const nextLeftIdx = leftIdx;
+        const nextRightIdx = rightIdx;
+        const [nextLeftItem, nextRightItem] = [
+          diffLeft[nextLeftIdx] ?? [0, ""],
+          diffRight[nextRightIdx] ?? [0, ""]
+        ];
+        const nextLeftIsInsert = nextLeftItem[0] == DIFF_INSERT;
+        const nextRightIsInsert = nextRightItem[0] == DIFF_INSERT;
+        if (nextLeftIsInsert != nextRightIsInsert) {
+          autoMerge = false;
+          break;
+        }
+        if (nextLeftIsInsert && nextRightIsInsert && nextLeftItem[1] != nextRightItem[1]) {
+          autoMerge = false;
+          break;
+        }
+        merged.push(leftItem);
+        continue;
+      }
+      if (leftItem[0] == DIFF_INSERT && rightItem[0] == DIFF_INSERT) {
+        if (leftItem[1] == rightItem[1]) {
+          merged.push(leftItem);
+          continue;
+        } else {
+          if (leftLeaf.mtime <= rightLeaf.mtime) {
+            merged.push(leftItem);
+            merged.push(rightItem);
+            continue;
+          } else {
+            merged.push(rightItem);
+            merged.push(leftItem);
+            continue;
+          }
+        }
+      }
+      if (leftItem[0] == DIFF_INSERT) {
+        rightIdx--;
+        merged.push(leftItem);
+        continue;
+      }
+      if (rightItem[0] == DIFF_INSERT) {
+        leftIdx--;
+        merged.push(rightItem);
+        continue;
+      }
+      if (rightItem[1] != leftItem[1]) {
+        Logger(
+          `MERGING PANIC:${leftItem[0]},${leftItem[1]} == ${rightItem[0]},${rightItem[1]}`,
+          LOG_LEVEL_VERBOSE
+        );
+        autoMerge = false;
+        break LOOP_MERGE;
+      }
+      if (leftItem[0] == DIFF_DELETE) {
+        if (rightItem[0] == DIFF_EQUAL) {
+          merged.push(leftItem);
+          continue;
+        } else {
+          autoMerge = false;
+          break LOOP_MERGE;
+        }
+      }
+      if (rightItem[0] == DIFF_DELETE) {
+        if (leftItem[0] == DIFF_EQUAL) {
+          merged.push(rightItem);
+          continue;
+        } else {
+          autoMerge = false;
+          break LOOP_MERGE;
+        }
+      }
+      Logger(
+        `Weird condition:${leftItem[0]},${leftItem[1]} == ${rightItem[0]},${rightItem[1]}`,
+        LOG_LEVEL_VERBOSE
+      );
+      break LOOP_MERGE;
+    } while (leftIdx < diffLeft.length || rightIdx < diffRight.length);
+    if (autoMerge) {
+      Logger(`Sensibly merge available`, LOG_LEVEL_VERBOSE);
+      return merged;
+    } else {
+      return false;
+    }
+  }
+  async mergeObject(path, baseRev, currentRev, conflictedRev) {
+    try {
+      const baseLeaf = await this.getConflictedDoc(path, baseRev);
+      const leftLeaf = await this.getConflictedDoc(path, currentRev);
+      const rightLeaf = await this.getConflictedDoc(path, conflictedRev);
+      if (baseLeaf == false || leftLeaf == false || rightLeaf == false) {
+        Logger(`Could not load leafs for merge`, LOG_LEVEL_VERBOSE);
+        Logger(
+          `${baseLeaf ? "base" : "missing base"}, ${leftLeaf ? "left" : "missing left"}, ${rightLeaf ? "right" : "missing right"} }`,
+          LOG_LEVEL_VERBOSE
+        );
+        return false;
+      }
+      if (leftLeaf.deleted || rightLeaf.deleted) {
+        Logger(`Either is deleted`, LOG_LEVEL_VERBOSE);
+        return false;
+      }
+      const baseObj = { data: tryParseJSON(baseLeaf.data, {}) };
+      const leftObj = { data: tryParseJSON(leftLeaf.data, {}) };
+      const rightObj = { data: tryParseJSON(rightLeaf.data, {}) };
+      const diffLeft = generatePatchObj(baseObj, leftObj);
+      const diffRight = generatePatchObj(baseObj, rightObj);
+      const diffSetLeft = new Map(flattenObject(diffLeft));
+      const diffSetRight = new Map(flattenObject(diffRight));
+      for (const [key, value] of diffSetLeft) {
+        if (diffSetRight.has(key)) {
+          if (diffSetRight.get(key) == value) {
+            diffSetRight.delete(key);
+          }
+        }
+      }
+      for (const [key, value] of diffSetRight) {
+        if (diffSetLeft.has(key) && diffSetLeft.get(key) != value) {
+          Logger(`Conflicted key:${key}`, LOG_LEVEL_VERBOSE);
+          return false;
+        }
+      }
+      const patches = [
+        { mtime: leftLeaf.mtime, patch: diffLeft },
+        { mtime: rightLeaf.mtime, patch: diffRight }
+      ].sort((a, b) => a.mtime - b.mtime);
+      let newObj = { ...baseObj };
+      for (const patch of patches) {
+        newObj = applyPatch(newObj, patch.patch);
+      }
+      Logger(`Object merge is applicable!`, LOG_LEVEL_VERBOSE);
+      return JSON.stringify(newObj.data);
+    } catch (ex) {
+      Logger("Could not merge object");
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async tryAutoMergeSensibly(path, test, conflicts) {
+    const conflictedRev = conflicts[0];
+    const conflictedRevNo = Number(conflictedRev.split("-")[0]);
+    const revFrom = await this.database.get(await this.options.pathService.path2id(path), {
+      revs_info: true
+    });
+    const commonBase = (revFrom._revs_info || []).filter(
+      (e) => e.status == "available" && Number(e.rev.split("-")[0]) < conflictedRevNo
+    )?.[0]?.rev ?? "";
+    let p = void 0;
+    if (commonBase) {
+      if (isSensibleMargeApplicable(path)) {
+        const result = await this.mergeSensibly(path, commonBase, test._rev, conflictedRev);
+        if (result) {
+          p = result.filter((e) => e[0] != DIFF_DELETE).map((e) => e[1]).join("");
+          Logger(`Sensible merge:${path}`, LOG_LEVEL_INFO);
+        } else {
+          Logger(`Sensible merge is not applicable.`, LOG_LEVEL_VERBOSE);
+        }
+      } else if (isObjectMargeApplicable(path)) {
+        const result = await this.mergeObject(path, commonBase, test._rev, conflictedRev);
+        if (result) {
+          Logger(`Object merge:${path}`, LOG_LEVEL_INFO);
+          p = result;
+        } else {
+          Logger(`Object merge is not applicable..`, LOG_LEVEL_VERBOSE);
+        }
+      }
+      if (p !== void 0) {
+        return { result: p, conflictedRev };
+      }
+    }
+    return false;
+  }
+  async tryAutoMerge(path, enableMarkdownAutoMerge) {
+    const test = await this.options.entryManager.getDBEntry(
+      path,
+      { conflicts: true, revs_info: true },
+      false,
+      false,
+      true
+    );
+    if (test === false) return { ok: MISSING_OR_ERROR };
+    if (test == null) return { ok: MISSING_OR_ERROR };
+    if (!test._conflicts) return { ok: NOT_CONFLICTED };
+    if (test._conflicts.length == 0) return { ok: NOT_CONFLICTED };
+    const conflicts = test._conflicts.sort((a, b) => Number(a.split("-")[0]) - Number(b.split("-")[0]));
+    const leftLeaf = await this.getConflictedDoc(path, test._rev);
+    const rightLeaf = await this.getConflictedDoc(path, conflicts[0]);
+    if (leftLeaf !== false && rightLeaf !== false && leftLeaf.data == rightLeaf.data && leftLeaf.deleted == rightLeaf.deleted) {
+      return { leftRev: test._rev, rightRev: conflicts[0], leftLeaf, rightLeaf };
+    }
+    if ((isSensibleMargeApplicable(path) || isObjectMargeApplicable(path)) && enableMarkdownAutoMerge) {
+      const autoMergeResult = await this.tryAutoMergeSensibly(path, test, conflicts);
+      if (autoMergeResult !== false) {
+        return autoMergeResult;
+      }
+    }
+    return { leftRev: test._rev, rightRev: conflicts[0], leftLeaf, rightLeaf };
+  }
+}
+export {
+  ConflictManager
+};