@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/common/utils.js

@@ -0,0 +1,583 @@
+import { LRUCache } from "octagonal-wheels/memory/LRUCache";
+import { isPlainText } from "../string_and_binary/path.js";
+import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
+import { arrayBufferToBase64Single, decodeBinary, writeString } from "../string_and_binary/convert.js";
+import {
+  PREFIX_ENCRYPTED_CHUNK,
+  PREFIX_OBFUSCATED,
+  SYNCINFO_ID
+} from "./types.js";
+import { isErrorOfMissingDoc } from "../pouchdb/utils_couchdb.js";
+import { replaceAll, replaceAllPairs } from "octagonal-wheels/string";
+import { concatUInt8Array } from "octagonal-wheels/binary";
+import { delay, fireAndForget } from "octagonal-wheels/promises";
+import { arrayToChunkedArray, unique } from "octagonal-wheels/collection";
+import { extractObject, isObjectDifferent } from "octagonal-wheels/object";
+import { sendValue, sendSignal, waitForSignal, waitForValue } from "octagonal-wheels/messagepassing/signal";
+import { throttle } from "octagonal-wheels/function";
+import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "./models/shared.const.symbols.js";
+import { sizeToHumanReadable } from "octagonal-wheels/number";
+import { compatGlobal } from "./coreEnvFunctions.js";
+import { ensureError } from "./utils.object.js";
+function resolveWithIgnoreKnownError(p, def) {
+  return new Promise((res, rej) => {
+    p.then(res).catch((ex) => isErrorOfMissingDoc(ex) ? res(def) : rej(ensureError(ex)));
+  });
+}
+const Parallels = (ps = /* @__PURE__ */ new Set()) => ({
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  add: (p) => ps.add(!!p.then(() => ps.delete(p)).catch(() => ps.delete(p)) && p),
+  wait: (limit) => ps.size >= limit && Promise.race(ps),
+  all: () => Promise.all(ps)
+});
+async function allSettledWithConcurrencyLimit(processes, limit) {
+  const ps = Parallels();
+  for (const proc of processes) {
+    ps.add(proc);
+    await ps.wait(limit);
+  }
+  (await ps.all()).forEach(() => {
+  });
+}
+function getDocData(doc) {
+  return typeof doc == "string" ? doc : doc.join("");
+}
+function getDocDataAsArray(doc) {
+  return typeof doc == "string" ? [doc] : doc;
+}
+function getDocDataAsArrayBuffer(doc) {
+  if (doc instanceof ArrayBuffer) return new Uint8Array(doc);
+  const docData = getDocDataAsArray(doc);
+  const s = docData.map((e) => writeString(e));
+  return concatUInt8Array(s);
+}
+function isTextBlob(blob) {
+  return blob.type === "text/plain";
+}
+function createTextBlob(data) {
+  const d = Array.isArray(data) ? data : [data];
+  return new Blob(d, { endings: "transparent", type: "text/plain" });
+}
+function createBinaryBlob(data) {
+  return new Blob([data], { endings: "transparent", type: "application/octet-stream" });
+}
+function createBlob(data) {
+  if (data instanceof Blob) return data;
+  if (data instanceof Uint8Array || data instanceof ArrayBuffer) return createBinaryBlob(data);
+  return createTextBlob(data);
+}
+function isTextDocument(doc) {
+  if (doc.type == "plain") return true;
+  if (doc.datatype == "plain") return true;
+  if (isPlainText(doc.path)) return true;
+  return false;
+}
+function readAsBlob(doc) {
+  if (isTextDocument(doc)) {
+    return createTextBlob(doc.data);
+  } else {
+    return createBinaryBlob(decodeBinary(doc.data));
+  }
+}
+function readContent(doc) {
+  if (isTextDocument(doc)) {
+    return getDocData(doc.data);
+  } else {
+    return decodeBinary(doc.data);
+  }
+}
+const isIndexDBCmpExist = typeof compatGlobal?.indexedDB?.cmp !== "undefined";
+async function isDocContentSame(docA, docB) {
+  const blob1 = createBlob(docA);
+  const blob2 = createBlob(docB);
+  if (blob1.size != blob2.size) return false;
+  if (isIndexDBCmpExist) {
+    return compatGlobal.indexedDB.cmp(await blob1.arrayBuffer(), await blob2.arrayBuffer()) === 0;
+  }
+  const checkQuantum = 1e4;
+  const length = blob1.size;
+  let i = 0;
+  while (i < length) {
+    const ab1 = await blob1.slice(i, i + checkQuantum).arrayBuffer();
+    const ab2 = await blob2.slice(i, i + checkQuantum).arrayBuffer();
+    i += checkQuantum;
+    if (await arrayBufferToBase64Single(ab1) != await arrayBufferToBase64Single(ab2)) return false;
+  }
+  return true;
+}
+function isObfuscatedEntry(doc) {
+  if (doc._id.startsWith(PREFIX_OBFUSCATED)) {
+    return true;
+  }
+  return false;
+}
+function isEncryptedChunkEntry(doc) {
+  if (doc._id.startsWith(PREFIX_ENCRYPTED_CHUNK)) {
+    return true;
+  }
+  return false;
+}
+function isSyncInfoEntry(doc) {
+  if (doc._id == SYNCINFO_ID) {
+    return true;
+  }
+  return false;
+}
+function memorizeFuncWithLRUCache(func) {
+  const cache = new LRUCache(100, 1e5, true);
+  return (key) => {
+    const isExists = cache.has(key);
+    if (isExists) return cache.get(key);
+    const value = func(key);
+    cache.set(key, value);
+    return value;
+  };
+}
+function memorizeFuncWithLRUCacheMulti(func) {
+  const cache = new LRUCache(100, 1e5, true);
+  return (keys) => {
+    const theKey = keys.map(
+      (e) => typeof e == "string" || typeof e == "number" || typeof e == "boolean" ? e.toString() : JSON.stringify(e)
+    ).join("-");
+    const isExists = cache.has(theKey);
+    if (isExists) return cache.get(theKey);
+    const value = func(...keys);
+    cache.set(theKey, value);
+    return value;
+  };
+}
+function onlyNot(exclusion) {
+  function _onlyNot(item) {
+    if (item === exclusion) return false;
+    return true;
+  }
+  return _onlyNot;
+}
+const lastProcessed = {};
+function markInterval(key, now) {
+  const next = now ?? Date.now();
+  if (lastProcessed?.[key] ?? 0 < next) {
+    lastProcessed[key] = next;
+  }
+}
+async function runWithInterval(key, interval, task) {
+  const now = Date.now();
+  try {
+    if (!(key in lastProcessed)) {
+      markInterval(key, now);
+      return await task();
+    }
+    const last = lastProcessed[key];
+    const diff = now - last;
+    if (diff < interval) {
+      markInterval(key, now);
+      await delay(diff);
+    }
+    markInterval(key);
+    return await task();
+  } finally {
+    markInterval(key);
+  }
+}
+async function runWithStartInterval(key, interval, task) {
+  const now = Date.now();
+  if (!(key in lastProcessed)) {
+    markInterval(key, now);
+    return await task();
+  }
+  const last = lastProcessed[key];
+  const diff = now - last;
+  if (diff < interval) {
+    markInterval(key, now);
+    await delay(diff);
+  }
+  markInterval(key);
+  return await task();
+}
+const globalConcurrencyController = Semaphore(50);
+function determineTypeFromBlob(data) {
+  return isTextBlob(data) ? "plain" : "newnote";
+}
+function determineType(path, data) {
+  if (data instanceof Blob) {
+    return determineTypeFromBlob(data);
+  }
+  if (isPlainText(path)) return "plain";
+  if (data instanceof Uint8Array) return "newnote";
+  if (data instanceof ArrayBuffer) return "newnote";
+  return "plain";
+}
+function isAnyNote(doc) {
+  return "type" in doc && (doc.type == "newnote" || doc.type == "plain");
+}
+function isLoadedEntry(doc) {
+  return "type" in doc && (doc.type == "newnote" || doc.type == "plain") && "data" in doc;
+}
+function isDeletedEntry(doc) {
+  return doc._deleted || doc.deleted || false;
+}
+function createSavingEntryFromLoadedEntry(doc) {
+  const data = readAsBlob(doc);
+  const type = determineType(doc.path, data);
+  return {
+    ...doc,
+    data,
+    datatype: type,
+    type,
+    children: []
+  };
+}
+function setAllItems(set, items) {
+  items.forEach((e) => set.add(e));
+  return set;
+}
+const map = {
+  "\n": "\\n",
+  "\r": "\\r",
+  "\\": "\\\\"
+};
+const revMap = {
+  "\\n": "\n",
+  "\\r": "\r",
+  "\\\\": "\\"
+};
+function escapeNewLineFromString(str) {
+  if (str.indexOf("\n") === -1 && str.indexOf("\r") === -1) {
+    return str;
+  }
+  const p = str.replace(/(\n|\r|\\)/g, (m) => `${map[m]}`);
+  return "\\f" + p;
+}
+function unescapeNewLineFromString(str) {
+  if (!str.startsWith("\\f")) {
+    return str;
+  }
+  const p = str.substring(2).replace(/(\\n|\\r|\\\\)/g, (m) => `${revMap[m]}`);
+  return p;
+}
+function escapeMarkdownValue(value) {
+  if (typeof value === "string") {
+    return replaceAllPairs(value, ["|", "\\|"], ["`", "\\`"]);
+  } else {
+    return value;
+  }
+}
+function timeDeltaToHumanReadable(delta) {
+  const sec = delta / 1e3;
+  if (sec < 60) {
+    return `${sec.toFixed(2)}s`;
+  }
+  const min = sec / 60;
+  if (min < 60) {
+    return `${min.toFixed(2)}m`;
+  }
+  const hour = min / 60;
+  if (hour < 24) {
+    return `${hour.toFixed(2)}h`;
+  }
+  const day = hour / 24;
+  if (day < 365) {
+    return `${day.toFixed(2)}d`;
+  }
+  const year = day / 365;
+  return `${year.toFixed(2)}y`;
+}
+async function wrapException(func) {
+  try {
+    return await func();
+  } catch (ex) {
+    if (ex instanceof Error) {
+      return ex;
+    }
+    return new Error(String(ex));
+  }
+}
+function toRanges(sorted) {
+  if (sorted?.length == 0) return "";
+  const ranges = [];
+  let start = sorted[0];
+  let end = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i] === end + 1) {
+      end = sorted[i];
+    } else {
+      ranges.push(start === end ? `${start.toString(32)}` : `${start.toString(32)}-${end.toString(32)}`);
+      start = sorted[i];
+      end = sorted[i];
+    }
+  }
+  ranges.push(start === end ? `${start.toString(32)}` : `${start.toString(32)}-${end.toString(32)}`);
+  return ranges.join(",");
+}
+const previousValues = /* @__PURE__ */ new Map();
+function isDirty(key, value) {
+  const prev = previousValues.get(key);
+  if (prev === value) return false;
+  previousValues.set(key, value);
+  return true;
+}
+function tryParseJSON(str, fallbackValue) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return fallbackValue;
+  }
+}
+import {
+  mergeObject,
+  applyPatch,
+  generatePatchObj,
+  flattenObject,
+  isObjectMargeApplicable,
+  isSensibleMargeApplicable
+} from "./utils.patch.js";
+function parseHeaderValues(strHeader) {
+  const headers = {};
+  const lines = strHeader.split("\n");
+  for (const line of lines) {
+    const [key, value] = line.split(":", 2).map((e) => e.trim());
+    if (key && value) {
+      headers[key] = value;
+    }
+  }
+  return headers;
+}
+function parseCustomRegExp(regexp) {
+  if (regexp.startsWith("!!")) {
+    return [true, regexp.slice(2)];
+  }
+  return [false, regexp];
+}
+function matchRegExp(regexp, target) {
+  const [negate, regexpWithoutNegate] = parseCustomRegExp(regexp);
+  if (regexpWithoutNegate.length == 0) return false;
+  const re = new RegExp(regexpWithoutNegate);
+  return negate ? !re.test(target) : re.test(target);
+}
+function isValidRegExp(regexp) {
+  try {
+    const [, exp] = parseCustomRegExp(regexp);
+    new RegExp(exp);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInvertedRegExp(regexp) {
+  const [negate] = parseCustomRegExp(regexp);
+  return negate;
+}
+function parseCustomRegExpList(list, flags, delimiter) {
+  const d = delimiter ?? ",";
+  const source = `${list ?? ""}`;
+  const items = source.replace(/\n| /g, "").split(d).filter((e) => e);
+  return items.map((e) => new CustomRegExp(e, flags));
+}
+function constructCustomRegExpList(items, delimiter) {
+  return items.map((e) => `${e}`).join(`${delimiter}`);
+}
+function splitCustomRegExpList(list, delimiter) {
+  const d = delimiter;
+  const source = `${list ?? ""}`;
+  return source.split(d).filter((e) => e);
+}
+class CustomRegExp {
+  regexp;
+  negate;
+  pattern;
+  constructor(regexp, flags) {
+    const [negate, exp] = parseCustomRegExp(regexp);
+    this.pattern = exp;
+    this.regexp = new RegExp(exp, flags);
+    this.negate = negate;
+  }
+  test(str) {
+    return this.negate ? !this.regexp.test(str) : this.regexp.test(str);
+  }
+}
+function getFileRegExp(settings, key) {
+  const flagCase = settings.handleFilenameCaseSensitive ? "" : "i";
+  if (key === "syncInternalFilesIgnorePatterns" || key === "syncInternalFilesTargetPatterns" || key === "syncInternalFileOverwritePatterns") {
+    const regExp2 = settings[key];
+    return parseCustomRegExpList(regExp2, flagCase, ",");
+  }
+  const regExp = settings[key];
+  return parseCustomRegExpList(regExp, flagCase, "|[]|");
+}
+function copyTo(source, target) {
+  for (const key of Object.keys(target)) {
+    target[key] = source[key];
+  }
+}
+function pickBucketSyncSettings(setting) {
+  return {
+    bucket: setting.bucket,
+    region: setting.region,
+    endpoint: setting.endpoint,
+    accessKey: setting.accessKey,
+    secretKey: setting.secretKey,
+    bucketPrefix: setting.bucketPrefix,
+    forcePathStyle: setting.forcePathStyle,
+    useCustomRequestHandler: setting.useCustomRequestHandler,
+    bucketCustomHeaders: setting.bucketCustomHeaders
+  };
+}
+function pickCouchDBSyncSettings(setting) {
+  return {
+    couchDB_URI: setting.couchDB_URI,
+    couchDB_USER: setting.couchDB_USER,
+    couchDB_PASSWORD: setting.couchDB_PASSWORD,
+    couchDB_DBNAME: setting.couchDB_DBNAME,
+    useRequestAPI: setting.useRequestAPI,
+    // Advanced settings
+    couchDB_CustomHeaders: setting.couchDB_CustomHeaders,
+    jwtAlgorithm: setting.jwtAlgorithm,
+    jwtExpDuration: setting.jwtExpDuration,
+    jwtKey: setting.jwtKey,
+    jwtKid: setting.jwtKid,
+    jwtSub: setting.jwtSub,
+    useJWT: setting.useJWT
+  };
+}
+function pickEncryptionSettings(setting) {
+  return {
+    E2EEAlgorithm: setting.E2EEAlgorithm,
+    encrypt: setting.encrypt,
+    passphrase: setting.passphrase,
+    usePathObfuscation: setting.usePathObfuscation
+  };
+}
+function pickP2PSyncSettings(setting) {
+  return {
+    P2P_Enabled: setting.P2P_Enabled,
+    P2P_AppID: setting.P2P_AppID,
+    P2P_roomID: setting.P2P_roomID,
+    P2P_passphrase: setting.P2P_passphrase,
+    P2P_relays: setting.P2P_relays,
+    P2P_AutoStart: setting.P2P_AutoStart,
+    P2P_AutoBroadcast: setting.P2P_AutoBroadcast,
+    P2P_DevicePeerName: setting.P2P_DevicePeerName || "",
+    P2P_turnServers: setting.P2P_turnServers,
+    P2P_turnUsername: setting.P2P_turnUsername,
+    P2P_turnCredential: setting.P2P_turnCredential
+  };
+}
+function wrapByDefault(func, onError) {
+  try {
+    return func();
+  } catch (ex) {
+    const error = ex instanceof Error ? ex : new Error(String(ex));
+    return onError(error);
+  }
+}
+const resolution = 2e3;
+function compareMTime(baseMTime, targetMTime) {
+  const truncatedBaseMTime = ~~(baseMTime / resolution) * resolution;
+  const truncatedTargetMTime = ~~(targetMTime / resolution) * resolution;
+  if (truncatedBaseMTime == truncatedTargetMTime) return EVEN;
+  if (truncatedBaseMTime > truncatedTargetMTime) return BASE_IS_NEW;
+  if (truncatedBaseMTime < truncatedTargetMTime) return TARGET_IS_NEW;
+  throw new Error("Unexpected error");
+}
+function displayRev(rev) {
+  const [number, hash] = rev.split("-");
+  return `${number}-${hash.substring(0, 6)}`;
+}
+function generateP2PRoomId() {
+  const randomValues = new Uint16Array(4);
+  crypto.getRandomValues(randomValues);
+  const MAX_UINT16 = 65536;
+  const a = Math.floor(randomValues[0] / MAX_UINT16 * 1e3);
+  const b = Math.floor(randomValues[1] / MAX_UINT16 * 1e3);
+  const c = Math.floor(randomValues[2] / MAX_UINT16 * 1e3);
+  const dRange = 36 * 36 * 36;
+  const d = Math.floor(randomValues[3] / MAX_UINT16 * dRange);
+  return `${a.toString().padStart(3, "0")}-${b.toString().padStart(3, "0")}-${c.toString().padStart(3, "0")}-${d.toString(36).padStart(3, "0")}`;
+}
+function extractP2PRoomSuffix(roomId) {
+  const trimmed = roomId.trim();
+  if (trimmed === "") return "";
+  const parts = trimmed.split("-").map((e) => e.trim()).filter((e) => e);
+  if (parts.length === 0) return "";
+  return parts[parts.length - 1] ?? "";
+}
+export {
+  CustomRegExp,
+  Parallels,
+  allSettledWithConcurrencyLimit,
+  applyPatch,
+  arrayToChunkedArray,
+  compareMTime,
+  concatUInt8Array,
+  constructCustomRegExpList,
+  copyTo,
+  createBinaryBlob,
+  createBlob,
+  createSavingEntryFromLoadedEntry,
+  createTextBlob,
+  delay,
+  determineType,
+  determineTypeFromBlob,
+  displayRev,
+  escapeMarkdownValue,
+  escapeNewLineFromString,
+  extractObject,
+  extractP2PRoomSuffix,
+  fireAndForget,
+  flattenObject,
+  generateP2PRoomId,
+  generatePatchObj,
+  getDocData,
+  getDocDataAsArray,
+  getDocDataAsArrayBuffer,
+  getFileRegExp,
+  globalConcurrencyController,
+  isAnyNote,
+  isDeletedEntry,
+  isDirty,
+  isDocContentSame,
+  isEncryptedChunkEntry,
+  isInvertedRegExp,
+  isLoadedEntry,
+  isObfuscatedEntry,
+  isObjectDifferent,
+  isObjectMargeApplicable,
+  isSensibleMargeApplicable,
+  isSyncInfoEntry,
+  isTextBlob,
+  isTextDocument,
+  isValidRegExp,
+  matchRegExp,
+  memorizeFuncWithLRUCache,
+  memorizeFuncWithLRUCacheMulti,
+  mergeObject,
+  onlyNot,
+  parseCustomRegExp,
+  parseHeaderValues,
+  pickBucketSyncSettings,
+  pickCouchDBSyncSettings,
+  pickEncryptionSettings,
+  pickP2PSyncSettings,
+  readAsBlob,
+  readContent,
+  replaceAll,
+  replaceAllPairs,
+  resolveWithIgnoreKnownError,
+  runWithInterval,
+  runWithStartInterval,
+  sendSignal,
+  sendValue,
+  setAllItems,
+  sizeToHumanReadable,
+  splitCustomRegExpList,
+  throttle,
+  timeDeltaToHumanReadable,
+  toRanges,
+  tryParseJSON,
+  unescapeNewLineFromString,
+  unique,
+  waitForSignal,
+  waitForValue,
+  wrapByDefault,
+  wrapException
+};

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

@@ -0,0 +1,2 @@
+export declare function asCopy<T>(obj: T): T;
+export declare function ensureError(error: unknown): Error;

package/dist/common/utils.object.js

@@ -0,0 +1,14 @@
+import { LiveSyncError } from "./LSError.js";
+function asCopy(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function ensureError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return LiveSyncError.fromError(error);
+}
+export {
+  asCopy,
+  ensureError
+};

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

@@ -0,0 +1,8 @@
+export declare function generatePatchObj(from: Record<string | number | symbol, unknown>, to: Record<string | number | symbol, unknown>): Record<string | number | symbol, unknown>;
+export declare function applyPatch(from: Record<string | number | symbol, unknown>, patch: Record<string | number | symbol, unknown>): Record<string | number | symbol, unknown>;
+export declare function mergeObject(objA: Record<string | number | symbol, unknown> | [unknown], objB: Record<string | number | symbol, unknown> | [unknown]): unknown[] | {
+    [k: string]: unknown;
+};
+export declare function flattenObject(obj: Record<string | number | symbol, unknown>, path?: string[]): [string, unknown][];
+export declare function isSensibleMargeApplicable(path: string): boolean;
+export declare function isObjectMargeApplicable(path: string): boolean;