@vrtmrz/livesync-commonlib 0.1.33 → 0.1.35

package/dist/common/models/setting.policy.js

@@ -0,0 +1,298 @@
+import { DEFAULT_SETTINGS } from "./setting.const.defaults.js";
+const SettingPolicies = {
+  Default: { markdown: "include", persistence: "include" },
+  LocalOnly: { markdown: "omit", persistence: "include" },
+  DeviceLocal: { markdown: "include", persistence: "device" },
+  MarkdownCredentials: { markdown: "credentials", persistence: "include" },
+  RemoteProfiles: { markdown: "credentials", persistence: "profiles" },
+  LocalConnection: { markdown: "include", persistence: "connection" },
+  ConnectionCredentials: { markdown: "credentials", persistence: "connection" },
+  ConnectionContext: { markdown: "include", persistence: "connection-context" },
+  E2EEPassphrase: { markdown: "credentials", persistence: "passphrase" },
+  IdDerivationKey: { markdown: "credentials", persistence: "id-key" },
+  RuntimeOnly: { markdown: "omit", persistence: "omit" }
+};
+const SETTINGS_PROPERTY_POLICY = {
+  liveSync: SettingPolicies.Default,
+  syncOnSave: SettingPolicies.Default,
+  syncOnStart: SettingPolicies.Default,
+  syncOnFileOpen: SettingPolicies.Default,
+  syncOnEditorSave: SettingPolicies.Default,
+  keepReplicationActiveInBackground: SettingPolicies.Default,
+  allowSleepDuringSynchronisation: SettingPolicies.Default,
+  allowSleepDuringSynchronisationOnDesktop: SettingPolicies.Default,
+  syncMinimumInterval: SettingPolicies.Default,
+  showVerboseLog: SettingPolicies.Default,
+  lessInformationInLog: SettingPolicies.Default,
+  showLongerLogInsideEditor: SettingPolicies.Default,
+  showStatusOnEditor: SettingPolicies.Default,
+  showStatusOnStatusbar: SettingPolicies.Default,
+  showOnlyIconsOnEditor: SettingPolicies.Default,
+  hideFileWarningNotice: SettingPolicies.Default,
+  networkWarningStyle: SettingPolicies.Default,
+  displayLanguage: SettingPolicies.Default,
+  trashInsteadDelete: SettingPolicies.Default,
+  doNotDeleteFolder: SettingPolicies.Default,
+  batchSave: SettingPolicies.Default,
+  batchSaveMinimumDelay: SettingPolicies.Default,
+  batchSaveMaximumDelay: SettingPolicies.Default,
+  syncMaxSizeInMB: SettingPolicies.Default,
+  useIgnoreFiles: SettingPolicies.Default,
+  ignoreFiles: SettingPolicies.Default,
+  processSizeMismatchedFiles: SettingPolicies.Default,
+  syncOnlyRegEx: SettingPolicies.Default,
+  syncIgnoreRegEx: SettingPolicies.Default,
+  syncAfterMerge: SettingPolicies.Default,
+  resolveConflictsByNewerFile: SettingPolicies.Default,
+  writeDocumentsIfConflicted: SettingPolicies.Default,
+  disableMarkdownAutoMerge: SettingPolicies.Default,
+  configPassphraseStore: SettingPolicies.Default,
+  encryptedPassphrase: SettingPolicies.LocalOnly,
+  encryptedIdDerivationKey: SettingPolicies.LocalOnly,
+  encryptedCouchDBConnection: SettingPolicies.LocalOnly,
+  periodicReplication: SettingPolicies.Default,
+  periodicReplicationInterval: SettingPolicies.Default,
+  syncInternalFiles: SettingPolicies.Default,
+  syncInternalFilesBeforeReplication: SettingPolicies.Default,
+  syncInternalFilesInterval: SettingPolicies.Default,
+  syncInternalFilesIgnorePatterns: SettingPolicies.Default,
+  syncInternalFilesTargetPatterns: SettingPolicies.Default,
+  watchInternalFileChanges: SettingPolicies.Default,
+  suppressNotifyHiddenFilesChange: SettingPolicies.Default,
+  syncInternalFileOverwritePatterns: SettingPolicies.Default,
+  usePluginSync: SettingPolicies.Default,
+  usePluginSettings: SettingPolicies.Default,
+  showOwnPlugins: SettingPolicies.Default,
+  autoSweepPlugins: SettingPolicies.Default,
+  autoSweepPluginsPeriodic: SettingPolicies.Default,
+  notifyPluginOrSettingUpdated: SettingPolicies.Default,
+  deviceAndVaultName: SettingPolicies.DeviceLocal,
+  usePluginSyncV2: SettingPolicies.Default,
+  usePluginEtc: SettingPolicies.Default,
+  pluginSyncExtendedSetting: SettingPolicies.Default,
+  useAdvancedMode: SettingPolicies.Default,
+  usePowerUserMode: SettingPolicies.Default,
+  useEdgeCaseMode: SettingPolicies.Default,
+  notifyThresholdOfRemoteStorageSize: SettingPolicies.Default,
+  disableWorkerForGeneratingChunks: SettingPolicies.Default,
+  processSmallFilesInUIThread: SettingPolicies.Default,
+  savingDelay: SettingPolicies.Default,
+  gcDelay: SettingPolicies.Default,
+  skipOlderFilesOnSync: SettingPolicies.Default,
+  useIndexedDBAdapter: SettingPolicies.Default,
+  enableDebugTools: SettingPolicies.Default,
+  writeLogToTheFile: SettingPolicies.Default,
+  settingSyncFile: SettingPolicies.Default,
+  writeCredentialsForSettingSync: SettingPolicies.Default,
+  notifyAllSettingSyncFile: SettingPolicies.Default,
+  suspendFileWatching: SettingPolicies.Default,
+  suspendParseReplicationResult: SettingPolicies.Default,
+  doNotSuspendOnFetching: SettingPolicies.Default,
+  maxMTimeForReflectEvents: SettingPolicies.Default,
+  versionUpFlash: SettingPolicies.Default,
+  settingVersion: SettingPolicies.Default,
+  isConfigured: SettingPolicies.Default,
+  lastReadUpdates: SettingPolicies.Default,
+  doctorProcessedVersion: SettingPolicies.Default,
+  remoteConfigurations: SettingPolicies.RemoteProfiles,
+  activeConfigurationId: SettingPolicies.MarkdownCredentials,
+  P2P_ActiveRemoteConfigurationId: SettingPolicies.MarkdownCredentials,
+  couchDB_URI: SettingPolicies.LocalConnection,
+  couchDB_USER: SettingPolicies.ConnectionCredentials,
+  couchDB_PASSWORD: SettingPolicies.ConnectionCredentials,
+  couchDB_DBNAME: SettingPolicies.LocalConnection,
+  couchDB_CustomHeaders: SettingPolicies.ConnectionCredentials,
+  useJWT: SettingPolicies.Default,
+  jwtAlgorithm: SettingPolicies.Default,
+  jwtKey: SettingPolicies.ConnectionCredentials,
+  jwtKid: SettingPolicies.ConnectionCredentials,
+  jwtSub: SettingPolicies.ConnectionCredentials,
+  jwtExpDuration: SettingPolicies.Default,
+  useRequestAPI: SettingPolicies.Default,
+  accessKey: SettingPolicies.ConnectionCredentials,
+  secretKey: SettingPolicies.ConnectionCredentials,
+  bucket: SettingPolicies.LocalConnection,
+  region: SettingPolicies.ConnectionContext,
+  endpoint: SettingPolicies.LocalConnection,
+  useCustomRequestHandler: SettingPolicies.Default,
+  bucketCustomHeaders: SettingPolicies.ConnectionCredentials,
+  bucketPrefix: SettingPolicies.Default,
+  forcePathStyle: SettingPolicies.Default,
+  remoteType: SettingPolicies.Default,
+  encrypt: SettingPolicies.Default,
+  passphrase: SettingPolicies.E2EEPassphrase,
+  idDerivationVersion: SettingPolicies.MarkdownCredentials,
+  idDerivationKey: SettingPolicies.IdDerivationKey,
+  usePathObfuscation: SettingPolicies.Default,
+  encryptInternalMetadata: SettingPolicies.Default,
+  E2EEAlgorithm: SettingPolicies.Default,
+  hashAlg: SettingPolicies.Default,
+  minimumChunkSize: SettingPolicies.Default,
+  customChunkSize: SettingPolicies.Default,
+  longLineThreshold: SettingPolicies.Default,
+  useSegmenter: SettingPolicies.Default,
+  enableChunkSplitterV2: SettingPolicies.Default,
+  doNotUseFixedRevisionForChunks: SettingPolicies.Default,
+  chunkSplitterVersion: SettingPolicies.Default,
+  useEden: SettingPolicies.Default,
+  maxChunksInEden: SettingPolicies.Default,
+  maxTotalLengthInEden: SettingPolicies.Default,
+  maxAgeInEden: SettingPolicies.Default,
+  tweakModified: SettingPolicies.Default,
+  checkIntegrityOnSave: SettingPolicies.Default,
+  useHistory: SettingPolicies.Default,
+  disableRequestURI: SettingPolicies.Default,
+  sendChunksBulk: SettingPolicies.Default,
+  sendChunksBulkMaxSize: SettingPolicies.Default,
+  useDynamicIterationCount: SettingPolicies.Default,
+  doNotPaceReplication: SettingPolicies.Default,
+  readChunksOnline: SettingPolicies.Default,
+  useOnlyLocalChunk: SettingPolicies.Default,
+  concurrencyOfReadChunksOnline: SettingPolicies.Default,
+  minimumIntervalOfReadChunksOnline: SettingPolicies.Default,
+  enableCompression: SettingPolicies.Default,
+  batch_size: SettingPolicies.Default,
+  batches_limit: SettingPolicies.Default,
+  ignoreVersionCheck: SettingPolicies.Default,
+  disableCheckingConfigMismatch: SettingPolicies.Default,
+  autoAcceptCompatibleTweak: SettingPolicies.Default,
+  hashCacheMaxCount: SettingPolicies.Default,
+  hashCacheMaxAmount: SettingPolicies.Default,
+  permitEmptyPassphrase: SettingPolicies.Default,
+  handleFilenameCaseSensitive: SettingPolicies.Default,
+  checkConflictOnlyOnOpen: SettingPolicies.Default,
+  showMergeDialogOnlyOnActive: SettingPolicies.Default,
+  additionalSuffixOfDatabaseName: SettingPolicies.LocalOnly,
+  useTimeouts: SettingPolicies.Default,
+  deleteMetadataOfDeletedFiles: SettingPolicies.Default,
+  automaticallyDeleteMetadataOfDeletedFiles: SettingPolicies.Default,
+  P2P_AutoAccepting: SettingPolicies.Default,
+  P2P_AutoSyncPeers: SettingPolicies.Default,
+  P2P_AutoWatchPeers: SettingPolicies.Default,
+  P2P_SyncOnReplication: SettingPolicies.Default,
+  P2P_RebuildFrom: SettingPolicies.Default,
+  P2P_AutoAcceptingPeers: SettingPolicies.Default,
+  P2P_AutoDenyingPeers: SettingPolicies.Default,
+  P2P_IsHeadless: SettingPolicies.Default,
+  P2P_iceServers: SettingPolicies.RuntimeOnly,
+  P2P_iceServersExpiresAt: SettingPolicies.RuntimeOnly,
+  P2P_Enabled: SettingPolicies.Default,
+  P2P_relays: SettingPolicies.Default,
+  P2P_roomID: SettingPolicies.Default,
+  P2P_passphrase: SettingPolicies.MarkdownCredentials,
+  P2P_AppID: SettingPolicies.Default,
+  P2P_AutoStart: SettingPolicies.Default,
+  P2P_AutoBroadcast: SettingPolicies.Default,
+  P2P_DevicePeerName: SettingPolicies.DeviceLocal,
+  P2P_turnServers: SettingPolicies.Default,
+  P2P_turnUsername: SettingPolicies.MarkdownCredentials,
+  P2P_turnCredential: SettingPolicies.MarkdownCredentials,
+  P2P_managedType: SettingPolicies.RuntimeOnly,
+  P2P_managedId: SettingPolicies.RuntimeOnly,
+  P2P_managedToken: SettingPolicies.RuntimeOnly,
+  P2P_maxWirePayloadBytes: SettingPolicies.Default,
+  P2P_connectionPath: SettingPolicies.Default,
+  P2P_useDiagRTC: SettingPolicies.Default
+};
+const settingKeys = Object.keys(SETTINGS_PROPERTY_POLICY);
+const protectedConnectionKeys = settingKeys.filter(
+  (key) => SETTINGS_PROPERTY_POLICY[key].persistence === "connection"
+);
+const connectionKeys = settingKeys.filter(
+  (key) => SETTINGS_PROPERTY_POLICY[key].persistence === "connection" || SETTINGS_PROPERTY_POLICY[key].persistence === "connection-context"
+);
+const omittedPersistenceKeys = settingKeys.filter((key) => SETTINGS_PROPERTY_POLICY[key].persistence === "omit");
+function copySetting(target, source, key) {
+  if (key in source) target[key] = source[key];
+  else delete target[key];
+}
+function cloneProfiles(settings) {
+  const profiles = {};
+  for (const [id, profile] of Object.entries(settings.remoteConfigurations ?? {})) {
+    Object.defineProperty(profiles, id, {
+      value: { ...profile },
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return profiles;
+}
+function createMarkdownSettings(settings, includeCredentials = settings.writeCredentialsForSettingSync === true) {
+  const output = {};
+  for (const key of settingKeys) {
+    const action = SETTINGS_PROPERTY_POLICY[key].markdown;
+    if (action === "omit" || action === "credentials" && !includeCredentials) continue;
+    copySetting(output, settings, key);
+  }
+  if (output.remoteConfigurations) output.remoteConfigurations = cloneProfiles(output);
+  return output;
+}
+function mergeMarkdownSettings(incoming, current) {
+  const merged = { ...DEFAULT_SETTINGS, ...incoming };
+  for (const key of settingKeys) {
+    const action = SETTINGS_PROPERTY_POLICY[key].markdown;
+    if (action === "omit" || action === "credentials" && merged.writeCredentialsForSettingSync !== true) {
+      copySetting(merged, current, key);
+    }
+  }
+  merged.remoteConfigurations = cloneProfiles(merged);
+  return merged;
+}
+function selectConnectionSettings(settings) {
+  const connection = {};
+  for (const key of connectionKeys) connection[key] = settings[key];
+  return connection;
+}
+function hasConnectionSettings(settings) {
+  return protectedConnectionKeys.some((key) => settings[key] !== "");
+}
+function clearConnectionSettings(settings) {
+  for (const key of connectionKeys) settings[key] = "";
+}
+function restoreConnectionSettings(settings, payload) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return false;
+  const connection = payload;
+  if (connectionKeys.some((key) => key in connection && typeof connection[key] !== "string")) return false;
+  for (const key of connectionKeys) {
+    if (key in connection) settings[key] = connection[key];
+  }
+  return true;
+}
+function omitUnpersistedSettings(settings) {
+  for (const key of omittedPersistenceKeys) delete settings[key];
+}
+function requireConfigurationCiphertext(value) {
+  if (value === "") throw new Error("Failed to encrypt configuration. Settings were not saved.");
+  return value;
+}
+function prepareSettingsForPersistence(settings) {
+  if (hasConnectionSettings(settings)) throw new Error("Connection settings were not prepared for persistence.");
+  if (settings.encrypt && settings.passphrase !== "")
+    throw new Error("The passphrase was not prepared for persistence.");
+  if (settings.idDerivationVersion === 1 && settings.idDerivationKey !== "") {
+    throw new Error("The ID derivation key was not prepared for persistence.");
+  }
+  if (omittedPersistenceKeys.some((key) => key in settings)) {
+    throw new Error("Runtime settings were not removed before persistence.");
+  }
+  if (settings.configPassphraseStore !== "" && Object.values(settings.remoteConfigurations).some(
+    (profile) => profile.uri.trim() !== "" && !profile.isEncrypted
+  )) {
+    throw new Error("Remote configurations were not prepared for persistence.");
+  }
+  return settings;
+}
+export {
+  SETTINGS_PROPERTY_POLICY,
+  SettingPolicies,
+  clearConnectionSettings,
+  createMarkdownSettings,
+  hasConnectionSettings,
+  mergeMarkdownSettings,
+  omitUnpersistedSettings,
+  prepareSettingsForPersistence,
+  requireConfigurationCiphertext,
+  restoreConnectionSettings,
+  selectConnectionSettings
+};

package/dist/common/utils.patch.js

@@ -2,6 +2,17 @@ const MARK_OPERATOR = `
`;
 const MARK_DELETED = `${MARK_OPERATOR}__DELETED`;
 const MARK_ISARRAY = `${MARK_OPERATOR}__ARRAY`;
 const MARK_SWAPPED = `${MARK_OPERATOR}__SWAP`;
+function hasOwnProperty(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+function setOwnProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
 function unorderedArrayToObject(obj) {
   return obj.map((e) => ({ [e.id]: e })).reduce((p, c) => ({ ...p, ...c }), {});
 }
@@ -30,34 +41,34 @@ function generatePatchObj(from, to) {
   const newEntries = Object.entries(to);
   for (const [key, value] of newEntries) {
     if (!tempMap.has(key)) {
-      ret[key] = value;
+      setOwnProperty(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 };
+        setOwnProperty(ret, key, { [MARK_SWAPPED]: value });
       } else {
         if (v === null && value === null) {
         } else if (v === null && value !== null) {
-          ret[key] = { [MARK_SWAPPED]: value };
+          setOwnProperty(ret, key, { [MARK_SWAPPED]: value });
         } else if (v !== null && value === null) {
-          ret[key] = { [MARK_SWAPPED]: value };
+          setOwnProperty(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;
+          if (Object.keys(wk).length > 0) setOwnProperty(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;
+          if (Object.keys(wk).length > 0) setOwnProperty(ret, key, wk);
         } else if (typeof v != "object" && typeof value != "object") {
           if (JSON.stringify(tempMap.get(key)) !== JSON.stringify(value)) {
-            ret[key] = value;
+            setOwnProperty(ret, key, value);
           }
         } else {
           if (JSON.stringify(tempMap.get(key)) !== JSON.stringify(value)) {
-            ret[key] = { [MARK_SWAPPED]: value };
+            setOwnProperty(ret, key, { [MARK_SWAPPED]: value });
           }
         }
       }
@@ -65,7 +76,7 @@ function generatePatchObj(from, to) {
     }
   }
   for (const [key] of tempMap) {
-    ret[key] = MARK_DELETED;
+    setOwnProperty(ret, key, MARK_DELETED);
   }
   return ret;
 }
@@ -73,21 +84,21 @@ function applyPatch(from, patch) {
   const ret = from;
   const patches = Object.entries(patch);
   for (const [key, value] of patches) {
-    if (value == MARK_DELETED) {
+    if (value === MARK_DELETED) {
       delete ret[key];
       continue;
     }
     if (value === null) {
-      ret[key] = null;
+      setOwnProperty(ret, key, null);
       continue;
     }
     if (typeof value == "object") {
-      if (MARK_SWAPPED in value) {
-        ret[key] = value[MARK_SWAPPED];
+      if (hasOwnProperty(value, MARK_SWAPPED)) {
+        setOwnProperty(ret, key, value[MARK_SWAPPED]);
         continue;
       }
-      if (MARK_ISARRAY in value) {
-        if (!(key in ret)) ret[key] = [];
+      if (hasOwnProperty(value, MARK_ISARRAY)) {
+        if (!hasOwnProperty(ret, key)) setOwnProperty(ret, key, []);
         if (!Array.isArray(ret[key])) {
           throw new Error("Patch target type is mismatched (array to something)");
         }
@@ -97,19 +108,23 @@ function applyPatch(from, patch) {
           value[MARK_ISARRAY]
         );
         const appliedArray = objectToUnorderedArray(appliedObject);
-        ret[key] = [...appliedArray];
+        setOwnProperty(ret, key, [...appliedArray]);
       } else {
-        if (!(key in ret)) {
-          ret[key] = value;
+        if (!hasOwnProperty(ret, key)) {
+          setOwnProperty(ret, key, value);
           continue;
         }
-        ret[key] = applyPatch(
-          ret[key],
-          value
+        setOwnProperty(
+          ret,
+          key,
+          applyPatch(
+            ret[key],
+            value
+          )
         );
       }
     } else {
-      ret[key] = value;
+      setOwnProperty(ret, key, value);
     }
   }
   return ret;
@@ -121,24 +136,28 @@ function mergeObject(objA, objB) {
     return objB;
   }
   for (const [key, v] of newEntries) {
-    if (key in ret) {
+    if (hasOwnProperty(ret, key)) {
       const value = ret[key];
       if (typeof v !== typeof value || Array.isArray(v) !== Array.isArray(value)) {
-        ret[key] = v;
+        setOwnProperty(ret, key, v);
       } else {
         if (typeof v == "object" && typeof value == "object" && !Array.isArray(v) && !Array.isArray(value)) {
-          ret[key] = mergeObject(
-            v,
-            value
+          setOwnProperty(
+            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])];
+          setOwnProperty(ret, key, [.../* @__PURE__ */ new Set([...v, ...value])]);
         } else {
-          ret[key] = v;
+          setOwnProperty(ret, key, v);
         }
       }
     } else {
-      ret[key] = v;
+      setOwnProperty(ret, key, v);
     }
   }
   const retSorted = Object.fromEntries(Object.entries(ret).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));

package/dist/managers/ChunkFetcher.d.ts

@@ -15,6 +15,13 @@ export declare class ChunkFetcher {
     get chunkManager(): ChunkManager;
     queue: DocumentID[];
     private readonly pendingClaims;
+    private reportedPendingCount;
+    private reportedFetchCounts;
+    private requestTimer;
+    private requestTimerDueAt;
+    private finiteActivityWasActive;
+    private finiteCompletionVersion;
+    private readonly stopObservingDelivery;
     private destroyed;
     get interval(): number;
     get concurrency(): number;
@@ -23,12 +30,20 @@ export declare class ChunkFetcher {
     destroy(): void;
     onEventHandler: (ids: DocumentID[]) => void;
     onEvent(ids: DocumentID[]): void;
+    private clearRequestTimer;
+    private scheduleRequest;
     private ensureClaims;
     private removePendingDelivery;
+    private updatePendingCount;
     private onClaimStalled;
     private settleClaim;
+    private getActiveClaimIds;
     private touchClaims;
     private waitForActivityBoundary;
+    private waitBeforeRemoteRequest;
+    private resolveLocallyAvailableRetries;
+    private logFetchedChunks;
+    private applyMissingChunkResults;
     /**
      * Processing requests
      */
@@ -40,5 +55,6 @@ export declare class ChunkFetcher {
      */
     previousRequestTime: number;
     canRequestMore(): boolean;
+    private isReady;
     requestMissingChunks(): Promise<void>;
 }