@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/common/configForDoc.js

@@ -0,0 +1,312 @@
+import { isCloudantURI } from "../pouchdb/utils_couchdb.js";
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, Logger } from "./logger.js";
+import { getConfName } from "./settingConstants.js";
+import { ChunkAlgorithmNames, E2EEAlgorithmNames, E2EEAlgorithms } from "./types.js";
+var ConditionType = /* @__PURE__ */ ((ConditionType2) => {
+  ConditionType2["PLATFORM_CASE_INSENSITIVE"] = "platform-case-insensitive";
+  ConditionType2["PLATFORM_CASE_SENSITIVE"] = "platform-case-sensitive";
+  ConditionType2["REMOTE_CASE_SENSITIVE"] = "remote-case-sensitive";
+  return ConditionType2;
+})(ConditionType || {});
+var RuleLevel = /* @__PURE__ */ ((RuleLevel2) => {
+  RuleLevel2[RuleLevel2["Must"] = 0] = "Must";
+  RuleLevel2[RuleLevel2["Necessary"] = 1] = "Necessary";
+  RuleLevel2[RuleLevel2["Recommended"] = 2] = "Recommended";
+  RuleLevel2[RuleLevel2["Optional"] = 3] = "Optional";
+  return RuleLevel2;
+})(RuleLevel || {});
+const DoctorRegulationV0_24_16 = {
+  version: "0.24.16",
+  rules: {
+    sendChunksBulk: {
+      value: false,
+      reason: "This is an obsolete setting and we should not enable this no more",
+      level: 0 /* Must */
+    },
+    sendChunksBulkMaxSize: {
+      value: 1,
+      reason: "This is an obsolete setting and we should not enable this no more",
+      level: 0 /* Must */
+    },
+    doNotUseFixedRevisionForChunks: {
+      value: true,
+      reason: "This value has been reverted at v0.24.16 for garbage collection of chunks.",
+      level: 2 /* Recommended */
+    },
+    handleFilenameCaseSensitive: {
+      value: false,
+      reason: "If Self-hosted LiveSync is Case-Sensitive, unexpected file operations may occur when synchronising with Windows, Android or other devices. This value should only be enabled if all devices have a Case-Sensitive file system.",
+      requireRebuild: true,
+      level: 2 /* Recommended */
+    },
+    useIndexedDBAdapter: {
+      value: true,
+      requireRebuildLocal: true,
+      level: 3 /* Optional */,
+      reason: "The old option is active. This is not a performance-appropriate setting."
+    },
+    useEden: {
+      reason: "This option is no longer recommended.",
+      level: 3 /* Optional */,
+      value: false
+    },
+    hashAlg: {
+      obsoleteValues: ["sha1", "xxhash32", ""],
+      value: "xxhash64",
+      level: 1 /* Necessary */,
+      reason: "The hash function is set to the old fallback. This should be retried. This may result in a change to the new fallback."
+    },
+    disableCheckingConfigMismatch: {
+      value: false,
+      level: 2 /* Recommended */,
+      reason: "If you disabled an older version of the dialogue because it was hard to understand, try it once in the latest version."
+    },
+    enableCompression: {
+      value: false,
+      level: 2 /* Recommended */,
+      requireRebuild: true,
+      reason: "This option will be sunset soon."
+    }
+  }
+};
+const DoctorRegulationV0_24_30 = {
+  version: "0.24.30",
+  rules: {
+    ...DoctorRegulationV0_24_16.rules,
+    usePluginSyncV2: {
+      value: true,
+      level: 2 /* Recommended */,
+      reason: "This option is now enabled by default. If you have problems with the new plugin, please report them."
+    },
+    chunkSplitterVersion: {
+      value: "v3-rabin-karp",
+      valueDisplay: ChunkAlgorithmNames["v3-rabin-karp"],
+      level: 2 /* Recommended */,
+      reason: "Chunk splitting has been optimised for more effective de-duplication. This is the new default value."
+    },
+    customChunkSize: {
+      min: 55,
+      // max: 1000,
+      value: 60,
+      valueDisplay: "60 (detected on if less than 55)",
+      level: 2 /* Recommended */,
+      detectionFunc: (settings) => settings?.chunkSplitterVersion === "v3-rabin-karp" && !isCloudantURI(settings?.couchDB_URI || ""),
+      reason: "With the V3 Rabin-Karp chunk splitter and Self-hosted CouchDB, the chunk size is set to 60 (means around 6MB) by default. This is in effect the maximum chunk size, which in practice is divided more finely."
+    }
+  }
+};
+const DoctorRegulationV0_25_0 = {
+  version: "0.25.0",
+  rules: {
+    ...DoctorRegulationV0_24_30.rules,
+    E2EEAlgorithm: {
+      value: E2EEAlgorithms.V2,
+      valueDisplay: E2EEAlgorithmNames[E2EEAlgorithms.V2],
+      level: 2 /* Recommended */,
+      reasonFunc: (_settings, translate) => translate("Doctor.RULES.E2EE_V02500.REASON")
+    }
+  }
+};
+const DoctorRegulationV0_25_27 = {
+  version: "0.25.27",
+  rules: {
+    ...DoctorRegulationV0_25_0.rules,
+    useIndexedDBAdapter: void 0
+  }
+};
+const DoctorRegulation = DoctorRegulationV0_25_27;
+function checkUnsuitableValues(setting, regulation = DoctorRegulation) {
+  const result = {
+    version: regulation.version,
+    rules: {}
+  };
+  for (const key in regulation.rules) {
+    if (!regulation.rules.hasOwnProperty(key)) continue;
+    const rule = regulation.rules[key];
+    if (!rule) continue;
+    const value = setting[key];
+    if (rule.value === value) {
+      Logger(`Rule satisfied: ${key} is ${value}`);
+      continue;
+    }
+    if (typeof value == "number" && "min" in rule && "max" in rule) {
+      const min = rule.min ?? Number.MIN_SAFE_INTEGER;
+      const max = rule.max ?? Number.MAX_SAFE_INTEGER;
+      if (value >= min && value <= max) {
+        Logger(`Rule satisfied: ${key} is ${value} between ${min} and ${max}`);
+        continue;
+      }
+    }
+    if (rule.detectionFunc && !rule.detectionFunc(setting)) {
+      Logger(`Rule condition satisfied: ${key} is ${value}, and detection function returned false`);
+      continue;
+    }
+    result.rules[key] = rule;
+    Logger(`Rule violation: ${key} is ${value} but should be ${rule.value}`);
+  }
+  return result;
+}
+const RebuildOptions = {
+  AutomaticAcceptable: 0,
+  ConfirmIfRequired: 1,
+  SkipEvenIfRequired: 2
+};
+async function performDoctorConsultation(env, settings, {
+  localRebuild = RebuildOptions.ConfirmIfRequired,
+  remoteRebuild = RebuildOptions.ConfirmIfRequired,
+  activateReason = "updated",
+  forceRescan = false
+}) {
+  const translate = env.translate;
+  let shouldRebuild = false;
+  let shouldRebuildLocal = false;
+  let isModified = false;
+  function getResult() {
+    return {
+      settings,
+      shouldRebuild,
+      shouldRebuildLocal,
+      isModified
+    };
+  }
+  const r = checkUnsuitableValues(settings);
+  if (!forceRescan && r.version == settings.doctorProcessedVersion) {
+    const isIssueFound = Object.keys(r.rules).length > 0;
+    const msg = isIssueFound ? "Issues found" : "No issues found";
+    Logger(`${msg} but marked as to be silent`, LOG_LEVEL_VERBOSE);
+    return getResult();
+  }
+  const issues = Object.entries(r.rules);
+  if (issues.length == 0) {
+    Logger(translate("Doctor.Message.NoIssues"), activateReason !== "updated" ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO);
+    return getResult();
+  } else {
+    const OPT_YES = `${translate("Doctor.Button.Yes")}`;
+    const OPT_NO = `${translate("Doctor.Button.No")}`;
+    const OPT_DISMISS = `${translate("Doctor.Button.DismissThisVersion")}`;
+    const issues2 = Object.keys(r.rules).map((key) => `- ${getConfName(key, translate)}`).join("\n");
+    const msg = await env.confirm.askSelectStringDialogue(
+      translate("Doctor.Dialogue.Main", { activateReason, issues: issues2 }),
+      [OPT_YES, OPT_NO, OPT_DISMISS],
+      {
+        title: translate("Doctor.Dialogue.Title"),
+        defaultAction: OPT_YES
+      }
+    );
+    if (msg == OPT_DISMISS) {
+      settings.doctorProcessedVersion = r.version;
+      isModified = true;
+      Logger("Marked as to be silent", LOG_LEVEL_VERBOSE);
+      return {
+        settings,
+        shouldRebuild,
+        shouldRebuildLocal,
+        isModified
+      };
+    }
+    if (msg != OPT_YES) return getResult();
+    const issueItems = Object.entries(r.rules);
+    Logger(`${issueItems.length} Issue(s) found `, LOG_LEVEL_VERBOSE);
+    let idx = 0;
+    const applySettings = {};
+    const OPT_FIX = `${translate("Doctor.Button.Fix")}`;
+    const OPT_SKIP = `${translate("Doctor.Button.Skip")}`;
+    const OPTION_FIX_WITHOUT_REBUILD = `${translate("Doctor.Button.FixButNoRebuild")}`;
+    let skipped = 0;
+    for (const [key, value] of issueItems) {
+      const levelMap = {
+        [1 /* Necessary */]: translate("Doctor.Level.Necessary"),
+        [2 /* Recommended */]: translate("Doctor.Level.Recommended"),
+        [3 /* Optional */]: translate("Doctor.Level.Optional"),
+        [0 /* Must */]: translate("Doctor.Level.Must")
+      };
+      const level = value.level ? levelMap[value.level] : "Unknown";
+      const options = [OPT_FIX];
+      let askRebuild = false;
+      let askRebuildLocal = false;
+      if (value.requireRebuild) {
+        if (remoteRebuild == RebuildOptions.AutomaticAcceptable) {
+          askRebuild = false;
+          shouldRebuild = true;
+        } else if (remoteRebuild == RebuildOptions.ConfirmIfRequired) {
+          askRebuild = true;
+        } else if (remoteRebuild == RebuildOptions.SkipEvenIfRequired) {
+          askRebuild = false;
+          shouldRebuild = false;
+        }
+      }
+      if (value.requireRebuildLocal) {
+        if (localRebuild == RebuildOptions.AutomaticAcceptable) {
+          askRebuildLocal = false;
+          shouldRebuildLocal = true;
+        } else if (localRebuild == RebuildOptions.ConfirmIfRequired) {
+          askRebuildLocal = true;
+        } else if (localRebuild == RebuildOptions.SkipEvenIfRequired) {
+          askRebuildLocal = false;
+          shouldRebuildLocal = false;
+        }
+      }
+      if (askRebuild || askRebuildLocal) {
+        options.push(OPTION_FIX_WITHOUT_REBUILD);
+      }
+      options.push(OPT_SKIP);
+      const note = `${askRebuild ? translate("Doctor.Message.RebuildRequired") : ""}${askRebuildLocal ? translate("Doctor.Message.RebuildLocalRequired") : ""}`;
+      const ret = await env.confirm.askSelectStringDialogue(
+        translate("Doctor.Dialogue.MainFix", {
+          name: getConfName(key, translate),
+          current: `${settings[key]}`,
+          reason: value.reasonFunc?.(settings, translate) ?? value.reason ?? " N/A ",
+          ideal: `${value.valueDisplayFunc ? value.valueDisplayFunc(settings) : value.value}`,
+          //@ts-ignore
+          level: `${level}`,
+          note
+        }),
+        options,
+        {
+          title: translate("Doctor.Dialogue.TitleFix", { current: `${++idx}`, total: `${issueItems.length}` }),
+          defaultAction: OPT_FIX
+        }
+      );
+      if (ret == OPT_FIX || ret == OPTION_FIX_WITHOUT_REBUILD) {
+        applySettings[key] = value.value;
+        if (ret == OPT_FIX) {
+          shouldRebuild = shouldRebuild || askRebuild || false;
+          shouldRebuildLocal = shouldRebuildLocal || askRebuildLocal || false;
+        }
+        isModified = true;
+      } else {
+        skipped++;
+      }
+    }
+    if (Object.keys(applySettings).length > 0) {
+      settings = {
+        ...settings,
+        ...applySettings
+      };
+    }
+    if (skipped == 0) {
+      settings.doctorProcessedVersion = r.version;
+      isModified = true;
+    } else {
+      if (await env.confirm.askYesNoDialog(translate("Doctor.Message.SomeSkipped"), {
+        title: translate("Doctor.Dialogue.TitleAlmostDone"),
+        defaultOption: "No"
+      }) == "no") {
+        settings.doctorProcessedVersion = r.version;
+        isModified = true;
+      }
+    }
+  }
+  return getResult();
+}
+export {
+  DoctorRegulation,
+  DoctorRegulationV0_24_16,
+  DoctorRegulationV0_24_30,
+  DoctorRegulationV0_25_0,
+  DoctorRegulationV0_25_27,
+  RebuildOptions,
+  RuleLevel,
+  checkUnsuitableValues,
+  performDoctorConsultation
+};

package/dist/common/coreEnvFunctions.d.ts

@@ -0,0 +1,21 @@
+export type LanguageGetter = () => string;
+export declare function setGetLanguage(func: LanguageGetter): void;
+export declare function getLanguage(): string;
+export declare const compatGlobal: typeof window;
+export type CompatTimeoutHandle = ReturnType<typeof setTimeout> | number;
+export type CompatIntervalHandle = ReturnType<typeof setInterval> | number;
+/**
+ * A wrapper around the global fetch function to ensure compatibility across different environments.
+ * In Obsidian, they recommend using their own requestUrl for better performance and reliability.
+ * However, at least for now, requestUrl cannot handle multiple concurrent requests, which causes
+ * problems for synchronise lively. So we will use the global fetch for now.
+ * If the situation changes in the future, change this function to use requestUrl.
+ * @param {RequestInfo} input  The resource that you wish to fetch. Can be either a string or a Request object.
+ * @param {RequestInit} [init] An options object containing any custom settings that you want to apply to the request.
+ * @returns {Promise<Response>} A Promise that resolves to the Response to that request, whether it is successful or not.
+ */
+export declare const _fetch: {
+    (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+} & typeof fetch;
+export declare const _activeDocument: Document;

package/dist/common/coreEnvFunctions.js

@@ -0,0 +1,22 @@
+let _getLanguage = () => "en";
+function setGetLanguage(func) {
+  _getLanguage = func;
+}
+function getLanguage() {
+  return _getLanguage();
+}
+const compatGlobal = typeof window !== "undefined" ? window : (
+  // compatibility for CLIs, tests, and other non-browser environments.
+  // eslint-disable-next-line obsidianmd/no-global-this
+  globalThis
+);
+const _fetch = compatGlobal.fetch.bind(compatGlobal);
+const activeDocumentWindow = compatGlobal;
+const _activeDocument = activeDocumentWindow.activeDocument ?? activeDocumentWindow.document;
+export {
+  _activeDocument,
+  _fetch,
+  compatGlobal,
+  getLanguage,
+  setGetLanguage
+};

package/dist/common/coreEnvVars.d.ts

@@ -0,0 +1,3 @@
+declare const manifestVersion: string;
+declare const packageVersion: string;
+export { manifestVersion, packageVersion };

package/dist/common/coreEnvVars.js

@@ -0,0 +1,6 @@
+const manifestVersion = typeof MANIFEST_VERSION !== "undefined" ? MANIFEST_VERSION : "-";
+const packageVersion = typeof PACKAGE_VERSION !== "undefined" ? PACKAGE_VERSION : "-";
+export {
+  manifestVersion,
+  packageVersion
+};

package/dist/common/i18n.d.ts

@@ -0,0 +1,18 @@
+import type { AllMessageKeys, I18N_LANGS } from "./rosetta.js";
+import type { TaggedType } from "./types.js";
+export declare let currentLang: I18N_LANGS;
+export declare function getResolvedLang(lang?: I18N_LANGS): I18N_LANGS;
+export declare function isAutoDisplayLanguage(lang: I18N_LANGS): boolean;
+export declare function __getMissingTranslations(): string[];
+export declare function __onMissingTranslation(callback: (key: string) => void): void;
+export declare function setLang(lang: I18N_LANGS): void;
+export declare function $t(message: string, lang?: I18N_LANGS): string;
+export declare function translateIfAvailable(message: string, lang?: I18N_LANGS): string;
+/**
+ * TagFunction to Automatically translate.
+ * @param strings
+ * @param values
+ * @returns
+ */
+export declare function $f(strings: TemplateStringsArray, ...values: string[]): string;
+export declare function $msg<T extends AllMessageKeys>(key: T, params?: Record<string, string>, lang?: I18N_LANGS): TaggedType<string, T>;