@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/common/types.js

@@ -0,0 +1,212 @@
+import {
+  LOG_LEVEL_DEBUG,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_URGENT,
+  LOG_LEVEL_VERBOSE
+} from "octagonal-wheels/common/logger";
+import { RESULT_NOT_FOUND, RESULT_TIMED_OUT } from "octagonal-wheels/common/const";
+import {
+  ChunkTypes,
+  EntryTypes,
+  MILESTONE_DOCID,
+  NODEINFO_DOCID,
+  NoteTypes,
+  SYNCINFO_ID,
+  VERSIONING_DOCID
+} from "./models/db.const.js";
+import {
+  AUTO_MERGED,
+  CANCELLED,
+  LEAVE_TO_SUBSEQUENT,
+  MISSING_OR_ERROR,
+  NOT_CONFLICTED,
+  TIME_ARGUMENT_INFINITY
+} from "./models/shared.const.symbols.js";
+import {
+  IDPrefixes,
+  LEAF_WAIT_ONLY_REMOTE,
+  LEAF_WAIT_TIMEOUT,
+  LEAF_WAIT_TIMEOUT_SEQUENTIAL_REPLICATOR,
+  MAX_DOC_SIZE,
+  MAX_DOC_SIZE_BIN,
+  PREFIX_CHUNK,
+  PREFIX_ENCRYPTED_CHUNK,
+  PREFIX_OBFUSCATED,
+  RECENT_MODIFIED_DOCS_QTY,
+  REPLICATION_BUSY_TIMEOUT,
+  SALT_OF_ID,
+  SALT_OF_PASSPHRASE,
+  SEED_MURMURHASH,
+  VER
+} from "./models/shared.const.behabiour.js";
+import {
+  AutoAccepting
+} from "./models/setting.type.js";
+import {
+  ChunkAlgorithmNames,
+  ChunkAlgorithms,
+  CURRENT_SETTING_VERSION,
+  E2EEAlgorithmNames,
+  E2EEAlgorithms,
+  HashAlgorithms,
+  REMOTE_COUCHDB,
+  REMOTE_MINIO,
+  REMOTE_P2P,
+  RemoteTypes,
+  SETTING_VERSION_INITIAL,
+  SETTING_VERSION_SUPPORT_CASE_INSENSITIVE,
+  MODE_AUTOMATIC,
+  MODE_PAUSED,
+  MODE_SELECTIVE,
+  MODE_SHINY
+} from "./models/setting.const.js";
+import {
+  PREFERRED_BASE,
+  PREFERRED_JOURNAL_SYNC,
+  PREFERRED_SETTING_CLOUDANT,
+  PREFERRED_SETTING_SELF_HOSTED
+} from "./models/setting.const.preferred.js";
+import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS } from "./models/setting.const.defaults.js";
+import { KeyIndexOfSettings } from "./models/setting.const.qr.js";
+import { isMetaEntry } from "./models/db.definition.js";
+import {
+  SETTING_KEY_P2P_DEVICE_NAME,
+  configURIBase,
+  configURIBaseQR,
+  SuffixDatabaseName,
+  ExtraSuffixIndexedDB
+} from "./models/shared.const.js";
+import {
+  configurationNames,
+  LEVEL_ADVANCED,
+  LEVEL_POWER_USER,
+  LEVEL_EDGE_CASE,
+  statusDisplay,
+  confName,
+  confDesc
+} from "./models/shared.definition.configNames.js";
+import {
+  ProtocolVersions,
+  DOCID_SYNC_PARAMETERS,
+  DOCID_JOURNAL_SYNC_PARAMETERS,
+  DEFAULT_SYNC_PARAMETERS
+} from "./models/sync.definition.js";
+import {
+  TweakValuesShouldMatchedTemplate,
+  IncompatibleChanges,
+  CompatibleButLossyChanges,
+  IncompatibleChangesInSpecificPattern,
+  TweakValuesRecommendedTemplate,
+  TweakValuesDefault,
+  TweakValuesTemplate,
+  DEVICE_ID_PREFERRED
+} from "./models/tweak.definition.js";
+import {
+  PREFIXMD_LOGFILE,
+  PREFIXMD_LOGFILE_UC,
+  FlagFilesOriginal,
+  FlagFilesHumanReadable,
+  FLAGMD_REDFLAG,
+  FLAGMD_REDFLAG2,
+  FLAGMD_REDFLAG2_HR,
+  FLAGMD_REDFLAG3,
+  FLAGMD_REDFLAG3_HR
+} from "./models/redflag.const.js";
+import { DatabaseConnectingStatuses } from "./models/shared.definition.js";
+export {
+  AUTO_MERGED,
+  AutoAccepting,
+  CANCELLED,
+  CURRENT_SETTING_VERSION,
+  ChunkAlgorithmNames,
+  ChunkAlgorithms,
+  ChunkTypes,
+  CompatibleButLossyChanges,
+  DEFAULT_SETTINGS,
+  DEFAULT_SYNC_PARAMETERS,
+  DEVICE_ID_PREFERRED,
+  DOCID_JOURNAL_SYNC_PARAMETERS,
+  DOCID_SYNC_PARAMETERS,
+  DatabaseConnectingStatuses,
+  E2EEAlgorithmNames,
+  E2EEAlgorithms,
+  EntryTypes,
+  ExtraSuffixIndexedDB,
+  FLAGMD_REDFLAG,
+  FLAGMD_REDFLAG2,
+  FLAGMD_REDFLAG2_HR,
+  FLAGMD_REDFLAG3,
+  FLAGMD_REDFLAG3_HR,
+  FlagFilesHumanReadable,
+  FlagFilesOriginal,
+  HashAlgorithms,
+  IDPrefixes,
+  IncompatibleChanges,
+  IncompatibleChangesInSpecificPattern,
+  KeyIndexOfSettings,
+  LEAF_WAIT_ONLY_REMOTE,
+  LEAF_WAIT_TIMEOUT,
+  LEAF_WAIT_TIMEOUT_SEQUENTIAL_REPLICATOR,
+  LEAVE_TO_SUBSEQUENT,
+  LEVEL_ADVANCED,
+  LEVEL_EDGE_CASE,
+  LEVEL_POWER_USER,
+  LOG_LEVEL_DEBUG,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_URGENT,
+  LOG_LEVEL_VERBOSE,
+  MAX_DOC_SIZE,
+  MAX_DOC_SIZE_BIN,
+  MILESTONE_DOCID,
+  MISSING_OR_ERROR,
+  MODE_AUTOMATIC,
+  MODE_PAUSED,
+  MODE_SELECTIVE,
+  MODE_SHINY,
+  NODEINFO_DOCID,
+  NOT_CONFLICTED,
+  NoteTypes,
+  P2P_DEFAULT_SETTINGS,
+  PREFERRED_BASE,
+  PREFERRED_JOURNAL_SYNC,
+  PREFERRED_SETTING_CLOUDANT,
+  PREFERRED_SETTING_SELF_HOSTED,
+  PREFIXMD_LOGFILE,
+  PREFIXMD_LOGFILE_UC,
+  PREFIX_CHUNK,
+  PREFIX_ENCRYPTED_CHUNK,
+  PREFIX_OBFUSCATED,
+  ProtocolVersions,
+  RECENT_MODIFIED_DOCS_QTY,
+  REMOTE_COUCHDB,
+  REMOTE_MINIO,
+  REMOTE_P2P,
+  REPLICATION_BUSY_TIMEOUT,
+  RESULT_NOT_FOUND,
+  RESULT_TIMED_OUT,
+  RemoteTypes,
+  SALT_OF_ID,
+  SALT_OF_PASSPHRASE,
+  SEED_MURMURHASH,
+  SETTING_KEY_P2P_DEVICE_NAME,
+  SETTING_VERSION_INITIAL,
+  SETTING_VERSION_SUPPORT_CASE_INSENSITIVE,
+  SYNCINFO_ID,
+  SuffixDatabaseName,
+  TIME_ARGUMENT_INFINITY,
+  TweakValuesDefault,
+  TweakValuesRecommendedTemplate,
+  TweakValuesShouldMatchedTemplate,
+  TweakValuesTemplate,
+  VER,
+  VERSIONING_DOCID,
+  confDesc,
+  confName,
+  configURIBase,
+  configURIBaseQR,
+  configurationNames,
+  isMetaEntry,
+  statusDisplay
+};

package/dist/common/utils.d.ts

@@ -0,0 +1,129 @@
+import { type AnyEntry, type DatabaseEntry, type EntryLeaf, type SyncInfo, type LoadedEntry, type SavingEntry, type NewEntry, type PlainEntry, type CustomRegExpSource, type ParsedCustomRegExp, type CustomRegExpSourceList, type ObsidianLiveSyncSettings, type RemoteDBSettings, type P2PConnectionInfo, type BucketSyncSetting, type CouchDBConnection, type EncryptionSettings } from "./types.js";
+import { replaceAll, replaceAllPairs } from "octagonal-wheels/string";
+export { replaceAll, replaceAllPairs };
+import { concatUInt8Array } from "octagonal-wheels/binary";
+export { concatUInt8Array };
+import { delay, fireAndForget } from "octagonal-wheels/promises";
+export { delay, fireAndForget };
+import { arrayToChunkedArray, unique } from "octagonal-wheels/collection";
+export { arrayToChunkedArray, unique };
+import { extractObject, isObjectDifferent } from "octagonal-wheels/object";
+export { extractObject, isObjectDifferent };
+import { sendValue, sendSignal, waitForSignal, waitForValue } from "octagonal-wheels/messagepassing/signal";
+export { sendValue, sendSignal, waitForSignal, waitForValue };
+import { throttle } from "octagonal-wheels/function";
+export { throttle };
+import type { SimpleStore } from "octagonal-wheels/databases/SimpleStoreBase";
+import { BASE_IS_NEW, EVEN, TARGET_IS_NEW } from "./models/shared.const.symbols.js";
+export type { SimpleStore };
+export { sizeToHumanReadable } from "octagonal-wheels/number";
+export declare function resolveWithIgnoreKnownError<T>(p: Promise<T>, def: T): Promise<T>;
+export declare const Parallels: (ps?: Set<Promise<unknown>>) => {
+    add: (p: Promise<unknown>) => Set<Promise<unknown>>;
+    wait: (limit: number) => Promise<unknown>;
+    all: () => Promise<unknown[]>;
+};
+export declare function allSettledWithConcurrencyLimit<T>(processes: Promise<T>[], limit: number): Promise<void>;
+export declare function getDocData(doc: string | string[]): string;
+export declare function getDocDataAsArray(doc: string | string[]): string[];
+export declare function getDocDataAsArrayBuffer(doc: string | string[] | ArrayBuffer): Uint8Array<ArrayBuffer>;
+export declare function isTextBlob(blob: Blob): boolean;
+export declare function createTextBlob(data: string | string[]): Blob;
+export declare function createBinaryBlob(data: Uint8Array<ArrayBuffer> | ArrayBuffer): Blob;
+export declare function createBlob(data: string | string[] | Uint8Array<ArrayBuffer> | ArrayBuffer | Blob): Blob;
+export declare function isTextDocument(doc: LoadedEntry): boolean;
+export declare function readAsBlob(doc: LoadedEntry): Blob;
+export declare function readContent(doc: LoadedEntry): string | ArrayBuffer;
+export declare function isDocContentSame(docA: string | string[] | Blob | ArrayBuffer, docB: string | string[] | Blob | ArrayBuffer): Promise<boolean>;
+export declare function isObfuscatedEntry(doc: DatabaseEntry): doc is AnyEntry;
+export declare function isEncryptedChunkEntry(doc: DatabaseEntry): doc is EntryLeaf;
+export declare function isSyncInfoEntry(doc: DatabaseEntry): doc is SyncInfo;
+export declare function memorizeFuncWithLRUCache<T, U>(func: (key: T) => U): (key: T) => U;
+export declare function memorizeFuncWithLRUCacheMulti<T extends unknown[], U>(func: (...keys: T) => U): (keys: T) => U;
+/**
+ *
+ * @param exclusion return only not exclusion
+ * @returns
+ *
+ * ["something",false,"aaaaa"].filter(onlyNot(false)) => yields ["something","aaaaaa"]. but, as string[].
+ */
+export declare function onlyNot<A, B>(exclusion: B): (item: A | B) => item is Exclude<A, B>;
+/**
+ * Run task with keeping minimum interval
+ * @param key waiting key
+ * @param interval interval (ms)
+ * @param task task to perform.
+ * @returns result of task
+ * @remarks This function is not designed to be concurrent.
+ */
+export declare function runWithInterval<T>(key: string, interval: number, task: () => Promise<T>): Promise<T>;
+/**
+ * Run task with keeping minimum interval on start
+ * @param key waiting key
+ * @param interval interval (ms)
+ * @param task task to perform.
+ * @returns result of task
+ * @remarks This function is not designed to be concurrent.
+ */
+export declare function runWithStartInterval<T>(key: string, interval: number, task: () => Promise<T>): Promise<T>;
+export declare const globalConcurrencyController: import("octagonal-wheels/concurrency/semaphore_v2").SemaphoreObject;
+export declare function determineTypeFromBlob(data: Blob): "newnote" | "plain";
+export declare function determineType(path: string, data: string | string[] | Uint8Array | ArrayBuffer | Blob): "newnote" | "plain";
+export declare function isAnyNote(doc: DatabaseEntry): doc is NewEntry | PlainEntry;
+export declare function isLoadedEntry(doc: DatabaseEntry): doc is LoadedEntry;
+export declare function isDeletedEntry(doc: LoadedEntry): boolean;
+export declare function createSavingEntryFromLoadedEntry(doc: LoadedEntry): SavingEntry;
+export declare function setAllItems<T>(set: Set<T>, items: T[]): Set<T>;
+export declare function escapeNewLineFromString(str: string): string;
+export declare function unescapeNewLineFromString(str: string): string;
+export declare function escapeMarkdownValue<T>(value: T): T;
+export declare function timeDeltaToHumanReadable(delta: number): string;
+export declare function wrapException<T>(func: () => Promise<Awaited<T>>): Promise<Awaited<T> | Error>;
+export declare function toRanges(sorted: number[]): string;
+export declare function isDirty(key: string, value: unknown): boolean;
+export declare function tryParseJSON<T extends object>(str: string, fallbackValue?: T): T | undefined;
+export { mergeObject, applyPatch, generatePatchObj, flattenObject, isObjectMargeApplicable, isSensibleMargeApplicable, } from "./utils.patch.js";
+export declare function parseHeaderValues(strHeader: string): Record<string, string>;
+/***
+ * Parse custom regular expression
+ * @param regexp
+ * @returns [negate: boolean, regexp: string]
+ * @example `!!foo` => [true, "foo"]
+ * @example `foo` => [false, "foo"]
+ */
+export declare function parseCustomRegExp(regexp: CustomRegExpSource): ParsedCustomRegExp;
+export declare function matchRegExp(regexp: CustomRegExpSource, target: string): boolean;
+export declare function isValidRegExp(regexp: CustomRegExpSource): boolean;
+export declare function isInvertedRegExp(regexp: CustomRegExpSource): boolean;
+export declare function constructCustomRegExpList<D extends string>(items: CustomRegExpSource[], delimiter: D): CustomRegExpSourceList<D>;
+export declare function splitCustomRegExpList<D extends string>(list: CustomRegExpSourceList<D>, delimiter: D): CustomRegExpSource[];
+export declare class CustomRegExp {
+    regexp: RegExp;
+    negate: boolean;
+    pattern: string;
+    constructor(regexp: CustomRegExpSource, flags?: string);
+    test(str: string): boolean;
+}
+type RegExpSettingKey = "syncOnlyRegEx" | "syncIgnoreRegEx" | "syncInternalFilesIgnorePatterns" | "syncInternalFilesTargetPatterns" | "syncInternalFileOverwritePatterns";
+export declare function getFileRegExp(settings: ObsidianLiveSyncSettings | RemoteDBSettings, key: RegExpSettingKey): CustomRegExp[];
+/**
+ * Copies properties from the source object to the target object only if they exist in the target.
+ * @param source The object to copy properties from.
+ * @param target The object to copy properties to.
+ */
+export declare function copyTo<T extends object, U extends T>(source: U, target: T): void;
+export declare function pickBucketSyncSettings(setting: ObsidianLiveSyncSettings): BucketSyncSetting;
+export declare function pickCouchDBSyncSettings(setting: ObsidianLiveSyncSettings): CouchDBConnection;
+export declare function pickEncryptionSettings(setting: ObsidianLiveSyncSettings | EncryptionSettings): EncryptionSettings;
+export declare function pickP2PSyncSettings(setting: Partial<ObsidianLiveSyncSettings> & P2PConnectionInfo): P2PConnectionInfo;
+export declare function wrapByDefault<T, U>(func: () => T, onError: (err: Error) => U): T | U;
+export declare function compareMTime(baseMTime: number, targetMTime: number): typeof BASE_IS_NEW | typeof TARGET_IS_NEW | typeof EVEN;
+export declare function displayRev(rev: string): string;
+/**
+ * Generate a random P2P Room ID in the format `123-456-789-abc`.
+ */
+export declare function generateP2PRoomId(): string;
+/**
+ * Extract the stable suffix (last segment) from a Room ID.
+ */
+export declare function extractP2PRoomSuffix(roomId: string): string;

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

@@ -0,0 +1,11 @@
+export declare function isErrorOf(ex: unknown, statusCode: number): boolean;
+/**
+ * Checks if the error is effectively a 404 error from CouchDB or PouchDB.
+ * @param ex some error object, expected to be from CouchDB or PouchDB.
+ * @returns true if the error is a 404 not found error, false otherwise.
+ * @throws if the input is not an object or does not have a numeric "status" property.
+ */
+export declare function isNotFoundError(ex: unknown): boolean;
+export declare function isConflictError(ex: unknown): boolean;
+export declare function isUnauthorizedError(ex: unknown): boolean;
+export declare function tryGetFilePath(entry: unknown): string | undefined;

package/dist/common/utils.doc.js

@@ -0,0 +1,35 @@
+function isErrorOf(ex, statusCode) {
+  if (!ex || typeof ex !== "object") {
+    throw new Error(`Expected an object error, but got ${typeof ex}`);
+  }
+  if ("status" in ex && typeof ex.status === "number" && ex.status == statusCode) {
+    return true;
+  }
+  return false;
+}
+function isNotFoundError(ex) {
+  return isErrorOf(ex, 404);
+}
+function isConflictError(ex) {
+  return isErrorOf(ex, 409);
+}
+function isUnauthorizedError(ex) {
+  return isErrorOf(ex, 401);
+}
+function isEntryWithPath(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  return "path" in entry && typeof entry.path === "string";
+}
+function tryGetFilePath(entry) {
+  if (isEntryWithPath(entry)) {
+    return entry.path;
+  }
+  return void 0;
+}
+export {
+  isConflictError,
+  isErrorOf,
+  isNotFoundError,
+  isUnauthorizedError,
+  tryGetFilePath
+};