@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/esm/path-compatibility.mjs

@@ -0,0 +1,277 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { Platform } from "obsidian";
+import {
+  getOsUnsafePathCharsRegExp,
+  hasWindowsTrailingChars,
+  isWindowsReservedName,
+  OBSIDIAN_UNSAFE_FILENAME_CHARS,
+  trimWindowsTrailingChars
+} from "./validation.mjs";
+var PathCompatibilityPlatform = /* @__PURE__ */ ((PathCompatibilityPlatform2) => {
+  PathCompatibilityPlatform2["Android"] = "Android";
+  PathCompatibilityPlatform2["Ios"] = "Ios";
+  PathCompatibilityPlatform2["Linux"] = "Linux";
+  PathCompatibilityPlatform2["MacOs"] = "MacOs";
+  PathCompatibilityPlatform2["Windows"] = "Windows";
+  return PathCompatibilityPlatform2;
+})(PathCompatibilityPlatform || {});
+var PathCompatibilityViolationType = /* @__PURE__ */ ((PathCompatibilityViolationType2) => {
+  PathCompatibilityViolationType2["ForbiddenCharacter"] = "ForbiddenCharacter";
+  PathCompatibilityViolationType2["NameTooLong"] = "NameTooLong";
+  PathCompatibilityViolationType2["ObsidianForbiddenCharacter"] = "ObsidianForbiddenCharacter";
+  PathCompatibilityViolationType2["PathTooLong"] = "PathTooLong";
+  PathCompatibilityViolationType2["ReservedName"] = "ReservedName";
+  PathCompatibilityViolationType2["TrailingCharacter"] = "TrailingCharacter";
+  PathCompatibilityViolationType2["UnicodeNotNormalized"] = "UnicodeNotNormalized";
+  return PathCompatibilityViolationType2;
+})(PathCompatibilityViolationType || {});
+const PATH_COMPATIBILITY_PLATFORMS = [
+  "Windows" /* Windows */,
+  "Android" /* Android */,
+  "Linux" /* Linux */,
+  "MacOs" /* MacOs */,
+  "Ios" /* Ios */
+];
+const PATH_COMPATIBILITY_PLATFORM_LABELS = {
+  ["Android" /* Android */]: "Android",
+  ["Ios" /* Ios */]: "iOS",
+  ["Linux" /* Linux */]: "Linux",
+  ["MacOs" /* MacOs */]: "macOS",
+  ["Windows" /* Windows */]: "Windows"
+};
+const WINDOWS_MAX_FILE_PATH_LENGTH = 259;
+const WINDOWS_MAX_FOLDER_PATH_LENGTH = 247;
+const WINDOWS_MAX_NAME_LENGTH = 255;
+const UNIX_MAX_NAME_BYTES = 255;
+const LINUX_MAX_PATH_BYTES = 4096;
+const DARWIN_MAX_PATH_BYTES = 1024;
+const CONTROL_CHARS_REG_EXP = /[\u{0}-\u{1F}]/gu;
+const PATH_COMPATIBILITY_PROFILES = {
+  ["Android" /* Android */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: LINUX_MAX_PATH_BYTES,
+    maxFolderPathLength: LINUX_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "Android" /* Android */,
+    shouldMeasureInBytes: true
+  },
+  ["Ios" /* Ios */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: DARWIN_MAX_PATH_BYTES,
+    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "Ios" /* Ios */,
+    shouldMeasureInBytes: true
+  },
+  ["Linux" /* Linux */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: LINUX_MAX_PATH_BYTES,
+    maxFolderPathLength: LINUX_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "Linux" /* Linux */,
+    shouldMeasureInBytes: true
+  },
+  ["MacOs" /* MacOs */]: {
+    hasWindowsNamingRules: false,
+    maxFilePathLength: DARWIN_MAX_PATH_BYTES,
+    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,
+    maxNameLength: UNIX_MAX_NAME_BYTES,
+    platform: "MacOs" /* MacOs */,
+    shouldMeasureInBytes: true
+  },
+  ["Windows" /* Windows */]: {
+    hasWindowsNamingRules: true,
+    maxFilePathLength: WINDOWS_MAX_FILE_PATH_LENGTH,
+    maxFolderPathLength: WINDOWS_MAX_FOLDER_PATH_LENGTH,
+    maxNameLength: WINDOWS_MAX_NAME_LENGTH,
+    platform: "Windows" /* Windows */,
+    shouldMeasureInBytes: false
+  }
+};
+function findPathCompatibilityViolations(params) {
+  const violations = [];
+  const name = getName(params.path);
+  const profiles = getProfiles(params.platforms);
+  const obsidianForbiddenCharacters = findCharacters(name, OBSIDIAN_UNSAFE_FILENAME_CHARS);
+  if (profiles.length > 0 && obsidianForbiddenCharacters.length > 0) {
+    violations.push({ characters: obsidianForbiddenCharacters, platform: null, type: "ObsidianForbiddenCharacter" /* ObsidianForbiddenCharacter */ });
+  }
+  for (const profile of profiles) {
+    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;
+    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(params.path, profile.shouldMeasureInBytes);
+    if (fullPathLength > maxPathLength) {
+      violations.push({
+        measurement: {
+          isInBytes: profile.shouldMeasureInBytes,
+          length: fullPathLength,
+          limit: maxPathLength,
+          vaultRootLength: params.maxVaultRootPathLength
+        },
+        platform: profile.platform,
+        type: "PathTooLong" /* PathTooLong */
+      });
+    }
+    const nameLength = measure(name, profile.shouldMeasureInBytes);
+    if (nameLength > profile.maxNameLength) {
+      violations.push({
+        measurement: { isInBytes: profile.shouldMeasureInBytes, length: nameLength, limit: profile.maxNameLength, vaultRootLength: null },
+        platform: profile.platform,
+        type: "NameTooLong" /* NameTooLong */
+      });
+    }
+    const platformForbiddenCharacters = findCharacters(name, getPlatformForbiddenCharactersRegExp(profile));
+    if (platformForbiddenCharacters.length > 0) {
+      violations.push({ characters: platformForbiddenCharacters, platform: profile.platform, type: "ForbiddenCharacter" /* ForbiddenCharacter */ });
+    }
+    if (!profile.hasWindowsNamingRules) {
+      continue;
+    }
+    if (isWindowsReservedName(name)) {
+      violations.push({ platform: profile.platform, type: "ReservedName" /* ReservedName */ });
+    }
+    if (hasWindowsTrailingChars(name)) {
+      violations.push({ platform: profile.platform, type: "TrailingCharacter" /* TrailingCharacter */ });
+    }
+  }
+  return violations;
+}
+function getCurrentPathCompatibilityPlatform() {
+  if (Platform.isWin) {
+    return "Windows" /* Windows */;
+  }
+  if (Platform.isAndroidApp) {
+    return "Android" /* Android */;
+  }
+  if (Platform.isIosApp) {
+    return "Ios" /* Ios */;
+  }
+  if (Platform.isMacOS) {
+    return "MacOs" /* MacOs */;
+  }
+  return Platform.isLinux ? "Linux" /* Linux */ : null;
+}
+function getForbiddenCharacterReplacementValidationMessage(replacement) {
+  const regExps = [
+    getOsUnsafePathCharsRegExp(true, false),
+    getOsUnsafePathCharsRegExp(false, true),
+    getOsUnsafePathCharsRegExp(false, false),
+    OBSIDIAN_UNSAFE_FILENAME_CHARS,
+    CONTROL_CHARS_REG_EXP
+  ];
+  for (const char of replacement) {
+    if (regExps.some((regExp) => char.replace(regExp, "") !== char)) {
+      return `The replacement must not contain "${char}": a file name cannot hold it on every platform.`;
+    }
+  }
+  return "";
+}
+function isUnicodeNormalized(name) {
+  return name === name.normalize("NFC");
+}
+function measure($string, shouldMeasureInBytes) {
+  return shouldMeasureInBytes ? new Blob([$string]).size : $string.length;
+}
+function repairName(params) {
+  const profiles = getProfiles(params.platforms);
+  if (profiles.length === 0) {
+    return buildName(params.basename, params.extension);
+  }
+  let basename = params.basename;
+  let extension = params.extension;
+  for (const profile of profiles) {
+    basename = replaceForbiddenCharacters(basename, profile, params.forbiddenCharacterReplacement);
+    extension = replaceForbiddenCharacters(extension, profile, params.forbiddenCharacterReplacement);
+  }
+  extension = trimTrailingDotsAndSpaces(extension, profiles);
+  basename = trimTrailingDotsAndSpaces(basename, profiles);
+  if (profiles.some((profile) => profile.hasWindowsNamingRules) && isWindowsReservedName(buildName(basename, extension))) {
+    basename += "_";
+  }
+  const codePoints = [...basename];
+  while (codePoints.length > 0) {
+    const candidate = trimTrailingDotsAndSpaces(codePoints.join(""), profiles);
+    if (candidate === "") {
+      return null;
+    }
+    if (doesFitEveryProfile(candidate, extension, profiles, params)) {
+      return buildName(candidate, extension);
+    }
+    codePoints.pop();
+  }
+  return null;
+}
+function buildName(basename, extension) {
+  return extension === "" ? basename : `${basename}.${extension}`;
+}
+function doesFitEveryProfile(basename, extension, profiles, params) {
+  const name = buildName(basename, extension);
+  const path = params.parentPath === "" ? name : `${params.parentPath}/${name}`;
+  return profiles.every((profile) => {
+    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;
+    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(path, profile.shouldMeasureInBytes);
+    return measure(name, profile.shouldMeasureInBytes) <= profile.maxNameLength && fullPathLength <= maxPathLength;
+  });
+}
+function findCharacters(name, regExp) {
+  return [...new Set(name.match(regExp))];
+}
+function getName(path) {
+  const slashIndex = path.lastIndexOf("/");
+  return slashIndex === -1 ? path : path.slice(slashIndex + 1);
+}
+function getPlatformForbiddenCharactersRegExp(profile) {
+  return getOsUnsafePathCharsRegExp(profile.hasWindowsNamingRules, profile.platform === "Android" /* Android */);
+}
+function getProfiles(platforms) {
+  return platforms.map((platform) => PATH_COMPATIBILITY_PROFILES[platform]);
+}
+function replaceForbiddenCharacters($string, profile, replacement) {
+  return $string.replace(getPlatformForbiddenCharactersRegExp(profile), () => replacement).replace(OBSIDIAN_UNSAFE_FILENAME_CHARS, () => replacement);
+}
+function trimTrailingDotsAndSpaces($string, profiles) {
+  return profiles.some((profile) => profile.hasWindowsNamingRules) ? trimWindowsTrailingChars($string) : $string;
+}
+export {
+  PATH_COMPATIBILITY_PLATFORMS,
+  PATH_COMPATIBILITY_PLATFORM_LABELS,
+  PathCompatibilityPlatform,
+  PathCompatibilityViolationType,
+  findPathCompatibilityViolations,
+  getCurrentPathCompatibilityPlatform,
+  getForbiddenCharacterReplacementValidationMessage,
+  isUnicodeNormalized,
+  measure,
+  repairName
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/path-compatibility.ts"],"sourcesContent":["/**\n * @file\n *\n * Which naming constraints each platform imposes, which of them a given path violates, and how to repair a\n * name so it satisfies every enabled platform at once.\n *\n * Pure by design — no `App`, no vault, no I/O — so the whole correctness surface (byte counting, extension\n * preservation, truncation order, profile composition) is unit-testable without an Obsidian instance. The\n * vault pass that consumes it lives in each plugin that reports or repairs path problems.\n *\n * A vault is synced, so the platform that matters is not necessarily the one running: enabling several\n * platforms composes their constraints by intersection, and a name has to satisfy all of them.\n */\n\nimport { Platform } from 'obsidian';\n\nimport {\n  getOsUnsafePathCharsRegExp,\n  hasWindowsTrailingChars,\n  isWindowsReservedName,\n  OBSIDIAN_UNSAFE_FILENAME_CHARS,\n  trimWindowsTrailingChars\n} from './validation.ts';\n\n/**\n * A platform a vault may be synced to, and whose naming rules can therefore be enforced.\n */\nexport enum PathCompatibilityPlatform {\n  Android = 'Android',\n  Ios = 'Ios',\n  Linux = 'Linux',\n  MacOs = 'MacOs',\n  Windows = 'Windows'\n}\n\n/**\n * What a single path or name is wrong about, on one platform.\n */\nexport enum PathCompatibilityViolationType {\n  ForbiddenCharacter = 'ForbiddenCharacter',\n  NameTooLong = 'NameTooLong',\n\n  /**\n   * The name holds a character Obsidian links do not work with (`#`, `^`, `[`, `]`, `|`). Obsidian's rule, not\n   * a platform's: the filesystem stores such a name fine, so naming a platform for it would be false.\n   */\n  ObsidianForbiddenCharacter = 'ObsidianForbiddenCharacter',\n  PathTooLong = 'PathTooLong',\n  ReservedName = 'ReservedName',\n  TrailingCharacter = 'TrailingCharacter',\n\n  /**\n   * The name is stored on disk in a form other than Unicode NFC, e.g. `й` as `и` followed by a combining\n   * breve. Not a platform's rule but a sync hazard: tools outside Obsidian see the two forms as two names.\n   */\n  UnicodeNotNormalized = 'UnicodeNotNormalized'\n}\n\n/**\n * Parameters for {@link findPathCompatibilityViolations}.\n */\nexport interface FindPathCompatibilityViolationsParams {\n  /**\n   * Whether the path names a folder, which has its own path budget.\n   */\n  readonly isFolder: boolean;\n\n  /**\n   * The length of the longest vault root path the vault is expected to live under, in characters.\n   *\n   * The vault root of a platform the check is not running on is unknowable, so it is stated rather than\n   * guessed — see the `maxVaultRootPathLength` setting.\n   */\n  readonly maxVaultRootPathLength: number;\n\n  /**\n   * The vault-relative path to check.\n   */\n  readonly path: string;\n\n  /**\n   * The platforms whose rules to enforce.\n   */\n  readonly platforms: readonly PathCompatibilityPlatform[];\n}\n\n/**\n * A length a path or name was measured at, and the limit it exceeds.\n */\nexport interface PathCompatibilityMeasurement {\n  /**\n   * Whether both numbers count UTF-8 bytes rather than UTF-16 units.\n   */\n  readonly isInBytes: boolean;\n\n  /**\n   * The measured length.\n   */\n  readonly length: number;\n\n  /**\n   * The largest length the platform accepts.\n   */\n  readonly limit: number;\n\n  /**\n   * The vault root length counted into {@link PathCompatibilityMeasurement.length}, before the separator\n   * after it. `null` for a name, which carries no root.\n   */\n  readonly vaultRootLength: null | number;\n}\n\n/**\n * The naming rules of one platform.\n */\nexport interface PathCompatibilityProfile {\n  /**\n   * Whether this platform applies Windows' naming rules: its forbidden characters, its reserved device\n   * names, and its rejection of trailing dots and spaces.\n   *\n   * One flag for three rules because they are one filesystem's rules, and no platform adopts a subset.\n   */\n  readonly hasWindowsNamingRules: boolean;\n\n  /**\n   * The longest absolute path a file may have, in this profile's unit.\n   */\n  readonly maxFilePathLength: number;\n\n  /**\n   * The longest absolute path a folder may have, in this profile's unit.\n   *\n   * Below {@link PathCompatibilityProfile.maxFilePathLength} on Windows, where the shorter budget leaves\n   * room for an `8.3` name inside the folder.\n   */\n  readonly maxFolderPathLength: number;\n\n  /**\n   * The longest single name — one path segment — in this profile's unit.\n   */\n  readonly maxNameLength: number;\n\n  /**\n   * The platform this profile describes.\n   */\n  readonly platform: PathCompatibilityPlatform;\n\n  /**\n   * Whether lengths count UTF-8 bytes (ext4, APFS) rather than UTF-16 units (NTFS).\n   *\n   * This is the whole reason the 255 limit is not a character count: a name of 128 CJK characters is 384\n   * bytes and is rejected by ext4 while being nowhere near any limit Windows has.\n   */\n  readonly shouldMeasureInBytes: boolean;\n}\n\n/**\n * One thing wrong with one path, and the platform that objects to it.\n */\nexport interface PathCompatibilityViolation {\n  /**\n   * The offending characters, each once, in the order they first appear in the name.\n   *\n   * Set for {@link PathCompatibilityViolationType.ForbiddenCharacter} and\n   * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter}, so the report can name them.\n   */\n  readonly characters?: readonly string[];\n\n  /**\n   * What was measured and the limit it was measured against.\n   *\n   * Set for {@link PathCompatibilityViolationType.NameTooLong} and\n   * {@link PathCompatibilityViolationType.PathTooLong}, so a reader of the report can verify the verdict.\n   */\n  readonly measurement?: PathCompatibilityMeasurement;\n\n  /**\n   * The platform whose rules the path breaks. Another enabled platform may accept the very same path.\n   *\n   * `null` for a violation no single platform owns, which is\n   * {@link PathCompatibilityViolationType.ObsidianForbiddenCharacter} and\n   * {@link PathCompatibilityViolationType.UnicodeNotNormalized}.\n   */\n  readonly platform: null | PathCompatibilityPlatform;\n\n  /**\n   * What is wrong.\n   */\n  readonly type: PathCompatibilityViolationType;\n}\n\n/**\n * Parameters for {@link repairName}.\n */\nexport interface RepairNameParams {\n  /**\n   * The name without its extension. For a folder, the whole name.\n   */\n  readonly basename: string;\n\n  /**\n   * The name's extension, without the leading dot. Empty for a folder or an extension-less file.\n   */\n  readonly extension: string;\n\n  /**\n   * What each forbidden character is replaced with. Empty deletes it. Must pass\n   * {@link getForbiddenCharacterReplacementValidationMessage}, or the repair would put back what it removed.\n   */\n  readonly forbiddenCharacterReplacement: string;\n\n  /**\n   * Whether the name belongs to a folder.\n   */\n  readonly isFolder: boolean;\n\n  /**\n   * The length of the longest vault root path the vault is expected to live under, in characters.\n   */\n  readonly maxVaultRootPathLength: number;\n\n  /**\n   * The vault-relative path of the parent folder. Empty at the vault root.\n   */\n  readonly parentPath: string;\n\n  /**\n   * The platforms whose rules the repaired name must satisfy.\n   */\n  readonly platforms: readonly PathCompatibilityPlatform[];\n}\n\n/**\n * Every platform, in the order the settings tab and the consistency report list them: the ones whose limits\n * actually bind in practice first.\n */\nexport const PATH_COMPATIBILITY_PLATFORMS: readonly PathCompatibilityPlatform[] = [\n  PathCompatibilityPlatform.Windows,\n  PathCompatibilityPlatform.Android,\n  PathCompatibilityPlatform.Linux,\n  PathCompatibilityPlatform.MacOs,\n  PathCompatibilityPlatform.Ios\n];\n\n/**\n * How each platform is named in the settings tab and the consistency report.\n *\n * Not translated: these are product names, and `macOS` is spelled `macOS` in every language.\n */\nexport const PATH_COMPATIBILITY_PLATFORM_LABELS: Record<PathCompatibilityPlatform, string> = {\n  [PathCompatibilityPlatform.Android]: 'Android',\n  [PathCompatibilityPlatform.Ios]: 'iOS',\n  [PathCompatibilityPlatform.Linux]: 'Linux',\n  [PathCompatibilityPlatform.MacOs]: 'macOS',\n  [PathCompatibilityPlatform.Windows]: 'Windows'\n};\n\n/**\n * `MAX_PATH` is 260 including the terminating NUL, so 259 usable characters for a file.\n */\nconst WINDOWS_MAX_FILE_PATH_LENGTH = 259;\n\n/**\n * A folder gets 12 fewer, leaving room for a `\\` and an 8.3 name inside it.\n */\nconst WINDOWS_MAX_FOLDER_PATH_LENGTH = 247;\n\n/**\n * NTFS's per-name cap, in UTF-16 units. Never the binding constraint: a path that fits in\n * {@link WINDOWS_MAX_FILE_PATH_LENGTH} characters contains no longer name.\n */\nconst WINDOWS_MAX_NAME_LENGTH = 255;\n\n/**\n * Ext4 / f2fs / APFS all cap a single name at 255 BYTES. This is the limit a character count gets wrong.\n */\nconst UNIX_MAX_NAME_BYTES = 255;\n\n/**\n * `PATH_MAX` on Linux and Android. So far above anything a vault produces that only the name limit binds.\n */\nconst LINUX_MAX_PATH_BYTES = 4096;\n\n/**\n * `PATH_MAX` on macOS and iOS.\n */\nconst DARWIN_MAX_PATH_BYTES = 1024;\n\n// eslint-disable-next-line no-control-regex -- Control characters are exactly what this matches.\nconst CONTROL_CHARS_REG_EXP = /[\\u{0}-\\u{1F}]/gu;\n\nconst PATH_COMPATIBILITY_PROFILES: Record<PathCompatibilityPlatform, PathCompatibilityProfile> = {\n  [PathCompatibilityPlatform.Android]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: LINUX_MAX_PATH_BYTES,\n    maxFolderPathLength: LINUX_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.Android,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.Ios]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: DARWIN_MAX_PATH_BYTES,\n    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.Ios,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.Linux]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: LINUX_MAX_PATH_BYTES,\n    maxFolderPathLength: LINUX_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.Linux,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.MacOs]: {\n    hasWindowsNamingRules: false,\n    maxFilePathLength: DARWIN_MAX_PATH_BYTES,\n    maxFolderPathLength: DARWIN_MAX_PATH_BYTES,\n    maxNameLength: UNIX_MAX_NAME_BYTES,\n    platform: PathCompatibilityPlatform.MacOs,\n    shouldMeasureInBytes: true\n  },\n\n  [PathCompatibilityPlatform.Windows]: {\n    hasWindowsNamingRules: true,\n    maxFilePathLength: WINDOWS_MAX_FILE_PATH_LENGTH,\n    maxFolderPathLength: WINDOWS_MAX_FOLDER_PATH_LENGTH,\n    maxNameLength: WINDOWS_MAX_NAME_LENGTH,\n    platform: PathCompatibilityPlatform.Windows,\n    shouldMeasureInBytes: false\n  }\n};\n\n/**\n * Finds everything wrong with a path, across every enabled platform.\n *\n * Read-only: this is what the consistency report renders, and it never proposes a repair.\n *\n * @param params - The path and the platforms to check it against.\n * @returns The violations, empty when the path is valid everywhere.\n */\nexport function findPathCompatibilityViolations(params: FindPathCompatibilityViolationsParams): PathCompatibilityViolation[] {\n  const violations: PathCompatibilityViolation[] = [];\n  const name = getName(params.path);\n  const profiles = getProfiles(params.platforms);\n\n  /*\n   * Once, with no platform: every platform stores such a name, and only Obsidian's links refuse it. Still\n   * gated on a platform being enabled, because that is what switches the whole check on, and the repair only\n   * replaces these characters under a profile.\n   */\n  const obsidianForbiddenCharacters = findCharacters(name, OBSIDIAN_UNSAFE_FILENAME_CHARS);\n\n  if (profiles.length > 0 && obsidianForbiddenCharacters.length > 0) {\n    violations.push({ characters: obsidianForbiddenCharacters, platform: null, type: PathCompatibilityViolationType.ObsidianForbiddenCharacter });\n  }\n\n  for (const profile of profiles) {\n    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;\n    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(params.path, profile.shouldMeasureInBytes);\n\n    if (fullPathLength > maxPathLength) {\n      violations.push({\n        measurement: {\n          isInBytes: profile.shouldMeasureInBytes,\n          length: fullPathLength,\n          limit: maxPathLength,\n          vaultRootLength: params.maxVaultRootPathLength\n        },\n        platform: profile.platform,\n        type: PathCompatibilityViolationType.PathTooLong\n      });\n    }\n\n    const nameLength = measure(name, profile.shouldMeasureInBytes);\n\n    if (nameLength > profile.maxNameLength) {\n      violations.push({\n        measurement: { isInBytes: profile.shouldMeasureInBytes, length: nameLength, limit: profile.maxNameLength, vaultRootLength: null },\n        platform: profile.platform,\n        type: PathCompatibilityViolationType.NameTooLong\n      });\n    }\n\n    const platformForbiddenCharacters = findCharacters(name, getPlatformForbiddenCharactersRegExp(profile));\n\n    if (platformForbiddenCharacters.length > 0) {\n      violations.push({ characters: platformForbiddenCharacters, platform: profile.platform, type: PathCompatibilityViolationType.ForbiddenCharacter });\n    }\n\n    if (!profile.hasWindowsNamingRules) {\n      continue;\n    }\n\n    if (isWindowsReservedName(name)) {\n      violations.push({ platform: profile.platform, type: PathCompatibilityViolationType.ReservedName });\n    }\n\n    if (hasWindowsTrailingChars(name)) {\n      violations.push({ platform: profile.platform, type: PathCompatibilityViolationType.TrailingCharacter });\n    }\n  }\n\n  return violations;\n}\n\n/**\n * The platform the plugin is running on, or `null` on a platform with no profile.\n *\n * Used only to seed the settings defaults, so that a fresh install reports on the vault in front of it\n * without the user configuring anything first.\n *\n * @returns The current platform, or `null`.\n */\nexport function getCurrentPathCompatibilityPlatform(): null | PathCompatibilityPlatform {\n  if (Platform.isWin) {\n    return PathCompatibilityPlatform.Windows;\n  }\n\n  if (Platform.isAndroidApp) {\n    return PathCompatibilityPlatform.Android;\n  }\n\n  if (Platform.isIosApp) {\n    return PathCompatibilityPlatform.Ios;\n  }\n\n  if (Platform.isMacOS) {\n    return PathCompatibilityPlatform.MacOs;\n  }\n\n  return Platform.isLinux ? PathCompatibilityPlatform.Linux : null;\n}\n\n/**\n * Validates the text a forbidden character is replaced with.\n *\n * Every platform's set is checked, not only the enabled ones: the toggles can change after the replacement\n * is chosen, and a replacement one platform refuses would make the repair of that platform produce a name\n * that is still invalid there.\n *\n * @param replacement - The replacement text. Empty is valid and deletes the character.\n * @returns A message naming the first refused character, or an empty string when the replacement is valid.\n */\nexport function getForbiddenCharacterReplacementValidationMessage(replacement: string): string {\n  const regExps = [\n    getOsUnsafePathCharsRegExp(true, false),\n    getOsUnsafePathCharsRegExp(false, true),\n    getOsUnsafePathCharsRegExp(false, false),\n    OBSIDIAN_UNSAFE_FILENAME_CHARS,\n    CONTROL_CHARS_REG_EXP\n  ];\n\n  // A string iterates by code point, so a surrogate pair is named whole, as the user typed it.\n  for (const char of replacement) {\n    // `replace` rather than `test`, for the reason given at `replaceForbiddenCharacters`.\n    if (regExps.some((regExp) => char.replace(regExp, '') !== char)) {\n      return `The replacement must not contain \"${char}\": a file name cannot hold it on every platform.`;\n    }\n  }\n\n  return '';\n}\n\n/**\n * Whether a name is in Unicode NFC, the form Obsidian gives every name it creates.\n *\n * @param name - The name as it is stored on disk.\n * @returns Whether it is NFC.\n */\nexport function isUnicodeNormalized(name: string): boolean {\n  return name === name.normalize('NFC');\n}\n\n/**\n * Measures a string the way a filesystem does.\n *\n * @param $string - The string to measure.\n * @param shouldMeasureInBytes - Whether to count UTF-8 bytes rather than UTF-16 units.\n * @returns The length.\n */\nexport function measure($string: string, shouldMeasureInBytes: boolean): number {\n  return shouldMeasureInBytes ? new Blob([$string]).size : $string.length;\n}\n\n/**\n * Repairs a name so that it satisfies every enabled platform.\n *\n * The order is deliberate: characters are replaced and a reserved name de-reserved BEFORE anything is\n * truncated, because both can change the length, and trailing dots and spaces are trimmed AFTER every cut,\n * because a cut can expose new ones.\n *\n * Truncation only ever shortens the basename — an extension is what tells Obsidian and the OS what the file\n * is, so a truncated one turns a working `.png` into a broken `.pn`.\n *\n * @param params - The name and the platforms it must satisfy.\n * @returns The repaired name, unchanged when it was already valid, or `null` when no name survives the\n * repair — which is what the report calls out rather than failing silently.\n */\nexport function repairName(params: RepairNameParams): null | string {\n  const profiles = getProfiles(params.platforms);\n\n  if (profiles.length === 0) {\n    return buildName(params.basename, params.extension);\n  }\n\n  let basename = params.basename;\n  let extension = params.extension;\n\n  for (const profile of profiles) {\n    basename = replaceForbiddenCharacters(basename, profile, params.forbiddenCharacterReplacement);\n    extension = replaceForbiddenCharacters(extension, profile, params.forbiddenCharacterReplacement);\n  }\n\n  // `note.md ` parses as basename `note` + extension `md `, so trimming only the basename would leave the\n  // trailing space exactly where Windows rejects it — at the end of the name.\n  extension = trimTrailingDotsAndSpaces(extension, profiles);\n\n  /*\n   * Trim BEFORE the de-reserving below, never after. `isWindowsReservedName` trims for its own answer, so\n   * `CON ` is reported reserved either way — but the underscore is appended to whatever is here, and an\n   * untrimmed `CON ` would de-reserve to `CON _` instead of `CON_`.\n   */\n  basename = trimTrailingDotsAndSpaces(basename, profiles);\n\n  /*\n   * The REBUILT name, never the bare basename: `params.basename` has already had its extension split off,\n   * and the library drops one extension of its own, so passing the basename would strip a second segment\n   * and call `CON.x` + `md` reserved — which is not what the report says about `CON.x.md`.\n   */\n  if (profiles.some((profile) => profile.hasWindowsNamingRules) && isWindowsReservedName(buildName(basename, extension))) {\n    // A trailing underscore rather than a prefix: it keeps the name sorting where the user expects it.\n    basename += '_';\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-misused-spread -- Code points are exactly the unit wanted: cutting by UTF-16 unit would split a surrogate pair and leave half an emoji.\n  const codePoints = [...basename];\n\n  while (codePoints.length > 0) {\n    const candidate = trimTrailingDotsAndSpaces(codePoints.join(''), profiles);\n\n    if (candidate === '') {\n      return null;\n    }\n\n    if (doesFitEveryProfile(candidate, extension, profiles, params)) {\n      return buildName(candidate, extension);\n    }\n\n    codePoints.pop();\n  }\n\n  return null;\n}\n\nfunction buildName(basename: string, extension: string): string {\n  return extension === '' ? basename : `${basename}.${extension}`;\n}\n\nfunction doesFitEveryProfile(basename: string, extension: string, profiles: PathCompatibilityProfile[], params: RepairNameParams): boolean {\n  const name = buildName(basename, extension);\n  const path = params.parentPath === '' ? name : `${params.parentPath}/${name}`;\n\n  return profiles.every((profile) => {\n    const maxPathLength = params.isFolder ? profile.maxFolderPathLength : profile.maxFilePathLength;\n    const fullPathLength = params.maxVaultRootPathLength + 1 + measure(path, profile.shouldMeasureInBytes);\n\n    return measure(name, profile.shouldMeasureInBytes) <= profile.maxNameLength && fullPathLength <= maxPathLength;\n  });\n}\n\n/*\n * Each character once, in order of first appearance. `match` on a `g`-flagged regexp returns every match and\n * ignores `lastIndex`, so the shared constants are safe here.\n */\nfunction findCharacters(name: string, regExp: RegExp): string[] {\n  return [...new Set(name.match(regExp))];\n}\n\nfunction getName(path: string): string {\n  const slashIndex = path.lastIndexOf('/');\n  return slashIndex === -1 ? path : path.slice(slashIndex + 1);\n}\n\n/*\n * Both flags explicitly: the library defaults an omitted one to the platform RUNNING the check, which would make\n * the Android profile's verdict depend on where the check runs rather than on the profile. Android's shared\n * storage refuses `* ? < > \"` too: Obsidian Sync itself skips such a remote name on Android.\n */\nfunction getPlatformForbiddenCharactersRegExp(profile: PathCompatibilityProfile): RegExp {\n  return getOsUnsafePathCharsRegExp(profile.hasWindowsNamingRules, profile.platform === PathCompatibilityPlatform.Android);\n}\n\nfunction getProfiles(platforms: readonly PathCompatibilityPlatform[]): PathCompatibilityProfile[] {\n  return platforms.map((platform) => PATH_COMPATIBILITY_PROFILES[platform]);\n}\n\n/*\n * `replace` rather than `test`: the library's regexps carry the `g` flag, and `test` on a `g`-flagged regexp\n * advances `lastIndex`, so consecutive calls on the same constant answer differently.\n */\nfunction replaceForbiddenCharacters($string: string, profile: PathCompatibilityProfile, replacement: string): string {\n  /*\n   * One replacement per forbidden character rather than one per run: it keeps the name's visual structure,\n   * which is what makes the repaired name still recognizable to whoever wrote it. Nothing is lost either way —\n   * the original name is preserved in the note's frontmatter. A replacer FUNCTION, so a `$&` in the\n   * replacement is not expanded as a backreference.\n   */\n  return $string\n    .replace(getPlatformForbiddenCharactersRegExp(profile), () => replacement)\n    .replace(OBSIDIAN_UNSAFE_FILENAME_CHARS, () => replacement);\n}\n\n/*\n * The profile guard is the plugin's, not the library's: the library answers for Windows unconditionally, and\n * this decides whether Windows is one of the platforms the vault has to satisfy.\n */\nfunction trimTrailingDotsAndSpaces($string: string, profiles: PathCompatibilityProfile[]): string {\n  return profiles.some((profile) => profile.hasWindowsNamingRules) ? trimWindowsTrailingChars($string) : $string;\n}\n"],"mappings":"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","names":["PathCompatibilityPlatform","PathCompatibilityViolationType"]}

package/dist/lib/esm/plugin/index.d.mts

@@ -9,3 +9,4 @@ export * as 'plugin-lifecycle-events' from './plugin-lifecycle-events.mjs';
 export * as 'plugin-settings-tab' from './plugin-settings-tab.mjs';
 export * as 'plugin' from './plugin.mjs';
 export * as 'settings-migration-api' from './settings-migration-api.mjs';
+export * as 'third-party-plugin' from './third-party-plugin.mjs';

package/dist/lib/esm/plugin/index.mjs

@@ -13,6 +13,7 @@ import * as plugin_lifecycle_events from "./plugin-lifecycle-events.mjs";
 import * as plugin_settings_tab from "./plugin-settings-tab.mjs";
 import * as plugin from "./plugin.mjs";
 import * as settings_migration_api from "./settings-migration-api.mjs";
+import * as third_party_plugin from "./third-party-plugin.mjs";
 export {
   plugin,
   plugin_api as "plugin-api",
@@ -23,6 +24,7 @@ export {
   plugin_instance as "plugin-instance",
   plugin_lifecycle_events as "plugin-lifecycle-events",
   plugin_settings_tab as "plugin-settings-tab",
-  settings_migration_api as "settings-migration-api"
+  settings_migration_api as "settings-migration-api",
+  third_party_plugin as "third-party-plugin"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdwbHVnaW4tYXBpJyBmcm9tICcuL3BsdWdpbi1hcGkudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1hc3luYy1jbGVhbnVwJyBmcm9tICcuL3BsdWdpbi1hc3luYy1jbGVhbnVwLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4taW5zdGFsbC1zdGF0ZScgZnJvbSAnLi9wbHVnaW4taW5zdGFsbC1zdGF0ZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWluc3RhbmNlJyBmcm9tICcuL3BsdWdpbi1pbnN0YW5jZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWxpZmVjeWNsZS1ldmVudHMnIGZyb20gJy4vcGx1Z2luLWxpZmVjeWNsZS1ldmVudHMudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy10YWInIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLXRhYi50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luJyBmcm9tICcuL3BsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc2V0dGluZ3MtbWlncmF0aW9uLWFwaScgZnJvbSAnLi9zZXR0aW5ncy1taWdyYXRpb24tYXBpLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsZ0JBQWtCO0FBQzlCLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxvQkFBc0I7QUFDbEMsWUFBWUMseUJBQTJCO0FBQ3ZDLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxxQkFBdUI7QUFDbkMsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLHlCQUEyQjtBQUN2QyxZQUFZLFlBQWM7QUFDMUIsWUFBWUMsNEJBQThCOyIsCiAgIm5hbWVzIjogWyJwbHVnaW4tYXBpIiwgInBsdWdpbi1hc3luYy1jbGVhbnVwIiwgInBsdWdpbi1jb250ZXh0IiwgInBsdWdpbi1ldmVudC1zb3VyY2UiLCAicGx1Z2luLWluc3RhbGwtc3RhdGUiLCAicGx1Z2luLWluc3RhbmNlIiwgInBsdWdpbi1saWZlY3ljbGUtZXZlbnRzIiwgInBsdWdpbi1zZXR0aW5ncy10YWIiLCAic2V0dGluZ3MtbWlncmF0aW9uLWFwaSJdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3BsdWdpbi9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdwbHVnaW4tYXBpJyBmcm9tICcuL3BsdWdpbi1hcGkudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1hc3luYy1jbGVhbnVwJyBmcm9tICcuL3BsdWdpbi1hc3luYy1jbGVhbnVwLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4tY29udGV4dCcgZnJvbSAnLi9wbHVnaW4tY29udGV4dC50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWV2ZW50LXNvdXJjZScgZnJvbSAnLi9wbHVnaW4tZXZlbnQtc291cmNlLnRzJztcbmV4cG9ydCAqIGFzICdwbHVnaW4taW5zdGFsbC1zdGF0ZScgZnJvbSAnLi9wbHVnaW4taW5zdGFsbC1zdGF0ZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWluc3RhbmNlJyBmcm9tICcuL3BsdWdpbi1pbnN0YW5jZS50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luLWxpZmVjeWNsZS1ldmVudHMnIGZyb20gJy4vcGx1Z2luLWxpZmVjeWNsZS1ldmVudHMudHMnO1xuZXhwb3J0ICogYXMgJ3BsdWdpbi1zZXR0aW5ncy10YWInIGZyb20gJy4vcGx1Z2luLXNldHRpbmdzLXRhYi50cyc7XG5leHBvcnQgKiBhcyAncGx1Z2luJyBmcm9tICcuL3BsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnc2V0dGluZ3MtbWlncmF0aW9uLWFwaScgZnJvbSAnLi9zZXR0aW5ncy1taWdyYXRpb24tYXBpLnRzJztcbmV4cG9ydCAqIGFzICd0aGlyZC1wYXJ0eS1wbHVnaW4nIGZyb20gJy4vdGhpcmQtcGFydHktcGx1Z2luLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsZ0JBQWtCO0FBQzlCLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxvQkFBc0I7QUFDbEMsWUFBWUMseUJBQTJCO0FBQ3ZDLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxxQkFBdUI7QUFDbkMsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLHlCQUEyQjtBQUN2QyxZQUFZLFlBQWM7QUFDMUIsWUFBWUMsNEJBQThCO0FBQzFDLFlBQVlDLHdCQUEwQjsiLAogICJuYW1lcyI6IFsicGx1Z2luLWFwaSIsICJwbHVnaW4tYXN5bmMtY2xlYW51cCIsICJwbHVnaW4tY29udGV4dCIsICJwbHVnaW4tZXZlbnQtc291cmNlIiwgInBsdWdpbi1pbnN0YWxsLXN0YXRlIiwgInBsdWdpbi1pbnN0YW5jZSIsICJwbHVnaW4tbGlmZWN5Y2xlLWV2ZW50cyIsICJwbHVnaW4tc2V0dGluZ3MtdGFiIiwgInNldHRpbmdzLW1pZ3JhdGlvbi1hcGkiLCAidGhpcmQtcGFydHktcGx1Z2luIl0KfQo=

package/dist/lib/esm/plugin/plugin-async-cleanup.d.mts

@@ -28,6 +28,11 @@ export declare const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = "pluginAsyncCleanupsV1";
  * How long a new plugin instance waits for the previous instance's cleanups by default.
  */
 export declare const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 10000;
+/**
+ * How long a new plugin instance waits for the previous instance's cleanups, by default, before it shows a notice that
+ * its load is paused. Shorter waits show nothing, so the usual few milliseconds never flash a notice.
+ */
+export declare const DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS = 500;
 /**
  * Parameters for {@link didPluginAsyncCleanupsSettle}.
  */

package/dist/lib/esm/plugin/plugin-async-cleanup.mjs

@@ -34,6 +34,7 @@ import { printError } from "@mnaoumov/typescript-lib/error";
 import { getObsidianLibState } from "../obsidian-lib-state.mjs";
 const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = "pluginAsyncCleanupsV1";
 const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 1e4;
+const DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS = 500;
 async function didPluginAsyncCleanupsSettle(params) {
   const promise = getPendingCleanups().get(params.pluginId);
   if (!promise) {
@@ -86,6 +87,7 @@ async function runCleanupSafely(params) {
   }
 }
 export {
+  DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS,
   DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS,
   PLUGIN_ASYNC_CLEANUPS_STATE_KEY,
   didPluginAsyncCleanupsSettle,
@@ -93,4 +95,4 @@ export {
   registerPluginAsyncCleanup,
   trackPluginAsyncCleanup
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/plugin-async-cleanup.ts"],"sourcesContent":["/**\n * @file\n *\n * Async cleanup that outlives a plugin instance, so the next instance of the same plugin can await it.\n *\n * Obsidian's `onunload` is synchronous and nothing awaits what it starts. Read from Obsidian `1.15.1`:\n * `Plugins.unloadPlugin` calls the old instance's `unload()` and returns, and `enablePlugin` then constructs the new\n * instance and awaits its `load()`. So on a disable / enable, a reload or an update while enabled, work like closing\n * an IndexedDB connection is still in flight when the new instance starts, and the new instance can open a database\n * the old one still holds.\n *\n * The registry here closes that gap without owning the reload lifecycle: a cleanup starts when the component it is\n * registered on unloads, its promise is kept realm-wide under the plugin id, and the next instance awaits it, bounded\n * by a timeout, before it starts. `PluginBase` does both halves itself.\n *\n * The registry lives in the realm-global shared-state bag under the versioned key `pluginAsyncCleanupsV1`, because the\n * old instance and the new one may bundle different copies of this library. It is a wire format between those copies:\n * a plain `Map` from plugin id to a `Promise<void>` that never rejects. A change of meaning moves to a new key.\n */\n\nimport type { Component } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { printError } from '@mnaoumov/typescript-lib/error';\n\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\n\n/**\n * The shared-state key of the pending cleanups. Versioned, because it is a wire format between copies of this library.\n */\nexport const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = 'pluginAsyncCleanupsV1';\n\n/**\n * How long a new plugin instance waits for the previous instance's cleanups by default.\n */\nexport const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * Parameters for {@link didPluginAsyncCleanupsSettle}.\n */\nexport interface DidPluginAsyncCleanupsSettleParams {\n  /**\n   * The id of the plugin whose pending cleanups to await.\n   */\n  readonly pluginId: string;\n\n  /**\n   * How long to wait before giving up. Defaults to {@link DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS}.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * An async cleanup.\n */\nexport type PluginAsyncCleanup = () => Promisable<void>;\n\n/**\n * Parameters for {@link registerPluginAsyncCleanup}.\n */\nexport interface RegisterPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The component whose unload starts the cleanup.\n   */\n  readonly component: Component;\n\n  /**\n   * The id of the plugin the cleanup belongs to, which the next instance waits under.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link trackPluginAsyncCleanup}.\n */\nexport interface TrackPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run now.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The id of the plugin the cleanup belongs to.\n   */\n  readonly pluginId: string;\n}\n\ninterface TrackedCleanupEntry {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Assigned once the self-removing promise exists.\n  promise?: Promise<void>;\n}\n\n/**\n * Awaits every cleanup still in flight for the plugin, bounded by a timeout.\n *\n * Resolves at once when nothing is pending. Never rejects.\n *\n * @param params - The parameters.\n * @returns `true` if every pending cleanup settled in time, `false` if the timeout was reached first.\n */\nexport async function didPluginAsyncCleanupsSettle(params: DidPluginAsyncCleanupsSettleParams): Promise<boolean> {\n  const promise = getPendingCleanups().get(params.pluginId);\n  if (!promise) {\n    return true;\n  }\n\n  let timeoutId: number | undefined;\n  const timeoutPromise = new Promise<false>((resolve) => {\n    timeoutId = window.setTimeout(() => {\n      resolve(false);\n    }, params.timeoutInMilliseconds ?? DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS);\n  });\n\n  try {\n    return await Promise.race([promise.then(() => true), timeoutPromise]);\n  } finally {\n    window.clearTimeout(timeoutId);\n  }\n}\n\n/**\n * Checks whether a plugin has cleanups still in flight.\n *\n * @param pluginId - The plugin id.\n * @returns Whether any cleanup registered under the id has not settled yet.\n */\nexport function hasPendingPluginAsyncCleanups(pluginId: string): boolean {\n  return getPendingCleanups().has(pluginId);\n}\n\n/**\n * Registers an async cleanup that starts when the component unloads and that the next instance of the plugin awaits.\n *\n * The cleanup runs exactly once, on the component's unload. Register it on the component whose lifetime matches the\n * resource: a `PluginBase` subclass calls `registerAsyncCleanup` instead, which scopes it to the feature surface.\n *\n * @param params - The parameters.\n */\nexport function registerPluginAsyncCleanup(params: RegisterPluginAsyncCleanupParams): void {\n  params.component.register(() => {\n    trackPluginAsyncCleanup({\n      cleanup: params.cleanup,\n      pluginId: params.pluginId\n    });\n  });\n}\n\n/**\n * Runs an async cleanup now and tracks it under the plugin id until it settles.\n *\n * A cleanup that throws or rejects is printed and counts as settled, so a failing cleanup never stops the next\n * instance from loading.\n *\n * @param params - The parameters.\n */\nexport function trackPluginAsyncCleanup(params: TrackPluginAsyncCleanupParams): void {\n  const pendingCleanups = getPendingCleanups();\n  const previousPromise = pendingCleanups.get(params.pluginId);\n  const cleanupPromise = runCleanupSafely(params);\n  // Never rejects: `runCleanupSafely` catches, and so did whichever call tracked `previousPromise`.\n  const entry: TrackedCleanupEntry = {};\n  entry.promise = (async (): Promise<void> => {\n    await Promise.all([previousPromise, cleanupPromise]);\n    // A later call may have chained onto this entry already; only the latest entry removes itself.\n    if (pendingCleanups.get(params.pluginId) === entry.promise) {\n      pendingCleanups.delete(params.pluginId);\n    }\n  })();\n  pendingCleanups.set(params.pluginId, entry.promise);\n}\n\nfunction getPendingCleanups(): Map<string, Promise<void>> {\n  return getObsidianLibState(PLUGIN_ASYNC_CLEANUPS_STATE_KEY, new Map<string, Promise<void>>()).value;\n}\n\nasync function runCleanupSafely(params: TrackPluginAsyncCleanupParams): Promise<void> {\n  try {\n    await params.cleanup();\n  } catch (error) {\n    printError(new Error(`Async cleanup of plugin ${params.pluginId} failed`, { cause: error }));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAS,kBAAkB;AAE3B,SAAS,2BAA2B;AAK7B,MAAM,kCAAkC;AAKxC,MAAM,uDAAuD;AAsEpE,eAAsB,6BAA6B,QAA8D;AAC/G,QAAM,UAAU,mBAAmB,EAAE,IAAI,OAAO,QAAQ;AACxD,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAe,CAAC,YAAY;AACrD,gBAAY,OAAO,WAAW,MAAM;AAClC,cAAQ,KAAK;AAAA,IACf,GAAG,OAAO,yBAAyB,oDAAoD;AAAA,EACzF,CAAC;AAED,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,QAAQ,KAAK,MAAM,IAAI,GAAG,cAAc,CAAC;AAAA,EACtE,UAAE;AACA,WAAO,aAAa,SAAS;AAAA,EAC/B;AACF;AAQO,SAAS,8BAA8B,UAA2B;AACvE,SAAO,mBAAmB,EAAE,IAAI,QAAQ;AAC1C;AAUO,SAAS,2BAA2B,QAAgD;AACzF,SAAO,UAAU,SAAS,MAAM;AAC9B,4BAAwB;AAAA,MACtB,SAAS,OAAO;AAAA,MAChB,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH,CAAC;AACH;AAUO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,kBAAkB,mBAAmB;AAC3C,QAAM,kBAAkB,gBAAgB,IAAI,OAAO,QAAQ;AAC3D,QAAM,iBAAiB,iBAAiB,MAAM;AAE9C,QAAM,QAA6B,CAAC;AACpC,QAAM,WAAW,YAA2B;AAC1C,UAAM,QAAQ,IAAI,CAAC,iBAAiB,cAAc,CAAC;AAEnD,QAAI,gBAAgB,IAAI,OAAO,QAAQ,MAAM,MAAM,SAAS;AAC1D,sBAAgB,OAAO,OAAO,QAAQ;AAAA,IACxC;AAAA,EACF,GAAG;AACH,kBAAgB,IAAI,OAAO,UAAU,MAAM,OAAO;AACpD;AAEA,SAAS,qBAAiD;AACxD,SAAO,oBAAoB,iCAAiC,oBAAI,IAA2B,CAAC,EAAE;AAChG;AAEA,eAAe,iBAAiB,QAAsD;AACpF,MAAI;AACF,UAAM,OAAO,QAAQ;AAAA,EACvB,SAAS,OAAO;AACd,eAAW,IAAI,MAAM,2BAA2B,OAAO,QAAQ,WAAW,EAAE,OAAO,MAAM,CAAC,CAAC;AAAA,EAC7F;AACF;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/plugin-async-cleanup.ts"],"sourcesContent":["/**\n * @file\n *\n * Async cleanup that outlives a plugin instance, so the next instance of the same plugin can await it.\n *\n * Obsidian's `onunload` is synchronous and nothing awaits what it starts. Read from Obsidian `1.15.1`:\n * `Plugins.unloadPlugin` calls the old instance's `unload()` and returns, and `enablePlugin` then constructs the new\n * instance and awaits its `load()`. So on a disable / enable, a reload or an update while enabled, work like closing\n * an IndexedDB connection is still in flight when the new instance starts, and the new instance can open a database\n * the old one still holds.\n *\n * The registry here closes that gap without owning the reload lifecycle: a cleanup starts when the component it is\n * registered on unloads, its promise is kept realm-wide under the plugin id, and the next instance awaits it, bounded\n * by a timeout, before it starts. `PluginBase` does both halves itself.\n *\n * The registry lives in the realm-global shared-state bag under the versioned key `pluginAsyncCleanupsV1`, because the\n * old instance and the new one may bundle different copies of this library. It is a wire format between those copies:\n * a plain `Map` from plugin id to a `Promise<void>` that never rejects. A change of meaning moves to a new key.\n */\n\nimport type { Component } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { printError } from '@mnaoumov/typescript-lib/error';\n\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\n\n/**\n * The shared-state key of the pending cleanups. Versioned, because it is a wire format between copies of this library.\n */\nexport const PLUGIN_ASYNC_CLEANUPS_STATE_KEY = 'pluginAsyncCleanupsV1';\n\n/**\n * How long a new plugin instance waits for the previous instance's cleanups by default.\n */\nexport const DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * How long a new plugin instance waits for the previous instance's cleanups, by default, before it shows a notice that\n * its load is paused. Shorter waits show nothing, so the usual few milliseconds never flash a notice.\n */\nexport const DEFAULT_PLUGIN_ASYNC_CLEANUP_NOTICE_DELAY_IN_MILLISECONDS = 500;\n\n/**\n * Parameters for {@link didPluginAsyncCleanupsSettle}.\n */\nexport interface DidPluginAsyncCleanupsSettleParams {\n  /**\n   * The id of the plugin whose pending cleanups to await.\n   */\n  readonly pluginId: string;\n\n  /**\n   * How long to wait before giving up. Defaults to {@link DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS}.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * An async cleanup.\n */\nexport type PluginAsyncCleanup = () => Promisable<void>;\n\n/**\n * Parameters for {@link registerPluginAsyncCleanup}.\n */\nexport interface RegisterPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The component whose unload starts the cleanup.\n   */\n  readonly component: Component;\n\n  /**\n   * The id of the plugin the cleanup belongs to, which the next instance waits under.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link trackPluginAsyncCleanup}.\n */\nexport interface TrackPluginAsyncCleanupParams {\n  /**\n   * The cleanup to run now.\n   */\n  readonly cleanup: PluginAsyncCleanup;\n\n  /**\n   * The id of the plugin the cleanup belongs to.\n   */\n  readonly pluginId: string;\n}\n\ninterface TrackedCleanupEntry {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Assigned once the self-removing promise exists.\n  promise?: Promise<void>;\n}\n\n/**\n * Awaits every cleanup still in flight for the plugin, bounded by a timeout.\n *\n * Resolves at once when nothing is pending. Never rejects.\n *\n * @param params - The parameters.\n * @returns `true` if every pending cleanup settled in time, `false` if the timeout was reached first.\n */\nexport async function didPluginAsyncCleanupsSettle(params: DidPluginAsyncCleanupsSettleParams): Promise<boolean> {\n  const promise = getPendingCleanups().get(params.pluginId);\n  if (!promise) {\n    return true;\n  }\n\n  let timeoutId: number | undefined;\n  const timeoutPromise = new Promise<false>((resolve) => {\n    timeoutId = window.setTimeout(() => {\n      resolve(false);\n    }, params.timeoutInMilliseconds ?? DEFAULT_PLUGIN_ASYNC_CLEANUP_TIMEOUT_IN_MILLISECONDS);\n  });\n\n  try {\n    return await Promise.race([promise.then(() => true), timeoutPromise]);\n  } finally {\n    window.clearTimeout(timeoutId);\n  }\n}\n\n/**\n * Checks whether a plugin has cleanups still in flight.\n *\n * @param pluginId - The plugin id.\n * @returns Whether any cleanup registered under the id has not settled yet.\n */\nexport function hasPendingPluginAsyncCleanups(pluginId: string): boolean {\n  return getPendingCleanups().has(pluginId);\n}\n\n/**\n * Registers an async cleanup that starts when the component unloads and that the next instance of the plugin awaits.\n *\n * The cleanup runs exactly once, on the component's unload. Register it on the component whose lifetime matches the\n * resource: a `PluginBase` subclass calls `registerAsyncCleanup` instead, which scopes it to the feature surface.\n *\n * @param params - The parameters.\n */\nexport function registerPluginAsyncCleanup(params: RegisterPluginAsyncCleanupParams): void {\n  params.component.register(() => {\n    trackPluginAsyncCleanup({\n      cleanup: params.cleanup,\n      pluginId: params.pluginId\n    });\n  });\n}\n\n/**\n * Runs an async cleanup now and tracks it under the plugin id until it settles.\n *\n * A cleanup that throws or rejects is printed and counts as settled, so a failing cleanup never stops the next\n * instance from loading.\n *\n * @param params - The parameters.\n */\nexport function trackPluginAsyncCleanup(params: TrackPluginAsyncCleanupParams): void {\n  const pendingCleanups = getPendingCleanups();\n  const previousPromise = pendingCleanups.get(params.pluginId);\n  const cleanupPromise = runCleanupSafely(params);\n  // Never rejects: `runCleanupSafely` catches, and so did whichever call tracked `previousPromise`.\n  const entry: TrackedCleanupEntry = {};\n  entry.promise = (async (): Promise<void> => {\n    await Promise.all([previousPromise, cleanupPromise]);\n    // A later call may have chained onto this entry already; only the latest entry removes itself.\n    if (pendingCleanups.get(params.pluginId) === entry.promise) {\n      pendingCleanups.delete(params.pluginId);\n    }\n  })();\n  pendingCleanups.set(params.pluginId, entry.promise);\n}\n\nfunction getPendingCleanups(): Map<string, Promise<void>> {\n  return getObsidianLibState(PLUGIN_ASYNC_CLEANUPS_STATE_KEY, new Map<string, Promise<void>>()).value;\n}\n\nasync function runCleanupSafely(params: TrackPluginAsyncCleanupParams): Promise<void> {\n  try {\n    await params.cleanup();\n  } catch (error) {\n    printError(new Error(`Async cleanup of plugin ${params.pluginId} failed`, { cause: error }));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAS,kBAAkB;AAE3B,SAAS,2BAA2B;AAK7B,MAAM,kCAAkC;AAKxC,MAAM,uDAAuD;AAM7D,MAAM,4DAA4D;AAsEzE,eAAsB,6BAA6B,QAA8D;AAC/G,QAAM,UAAU,mBAAmB,EAAE,IAAI,OAAO,QAAQ;AACxD,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAe,CAAC,YAAY;AACrD,gBAAY,OAAO,WAAW,MAAM;AAClC,cAAQ,KAAK;AAAA,IACf,GAAG,OAAO,yBAAyB,oDAAoD;AAAA,EACzF,CAAC;AAED,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,QAAQ,KAAK,MAAM,IAAI,GAAG,cAAc,CAAC;AAAA,EACtE,UAAE;AACA,WAAO,aAAa,SAAS;AAAA,EAC/B;AACF;AAQO,SAAS,8BAA8B,UAA2B;AACvE,SAAO,mBAAmB,EAAE,IAAI,QAAQ;AAC1C;AAUO,SAAS,2BAA2B,QAAgD;AACzF,SAAO,UAAU,SAAS,MAAM;AAC9B,4BAAwB;AAAA,MACtB,SAAS,OAAO;AAAA,MAChB,UAAU,OAAO;AAAA,IACnB,CAAC;AAAA,EACH,CAAC;AACH;AAUO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,kBAAkB,mBAAmB;AAC3C,QAAM,kBAAkB,gBAAgB,IAAI,OAAO,QAAQ;AAC3D,QAAM,iBAAiB,iBAAiB,MAAM;AAE9C,QAAM,QAA6B,CAAC;AACpC,QAAM,WAAW,YAA2B;AAC1C,UAAM,QAAQ,IAAI,CAAC,iBAAiB,cAAc,CAAC;AAEnD,QAAI,gBAAgB,IAAI,OAAO,QAAQ,MAAM,MAAM,SAAS;AAC1D,sBAAgB,OAAO,OAAO,QAAQ;AAAA,IACxC;AAAA,EACF,GAAG;AACH,kBAAgB,IAAI,OAAO,UAAU,MAAM,OAAO;AACpD;AAEA,SAAS,qBAAiD;AACxD,SAAO,oBAAoB,iCAAiC,oBAAI,IAA2B,CAAC,EAAE;AAChG;AAEA,eAAe,iBAAiB,QAAsD;AACpF,MAAI;AACF,UAAM,OAAO,QAAQ;AAAA,EACvB,SAAS,OAAO;AACd,eAAW,IAAI,MAAM,2BAA2B,OAAO,QAAQ,WAAW,EAAE,OAAO,MAAM,CAAC,CAAC;AAAA,EAC7F;AACF;","names":[]}

package/dist/lib/esm/plugin/plugin-context.mjs

@@ -75,6 +75,7 @@ function initPluginContext(pluginId) {
   showInitialDebugMessage(pluginId);
   getSharedAbortController();
   injectLibraryStyles({
+    // eslint-disable-next-line obsidianmd/prefer-active-doc -- The shared library styles belong to the main window; `activeDocument` would put them in whichever popout has focus.
     doc: document,
     libraryStyles: LIBRARY_STYLES,
     libraryVersion: LIBRARY_VERSION
@@ -85,4 +86,4 @@ export {
   initDebugController,
   initPluginContext
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/plugin/plugin-event-source.d.mts

@@ -4,7 +4,7 @@
  *
  * Contains the implementation of the plugin event source.
  */
-import type { AsyncEventRef, AsyncEventSource } from '@mnaoumov/typescript-lib/async-events';
+import type { AsyncEventRef, AsyncEventSource, CallbackArguments } from '@mnaoumov/typescript-lib/async-events';
 import type { StringKeys } from '@mnaoumov/typescript-lib/type';
 import type { Promisable } from 'type-fest';
 import type { PluginBase } from './plugin.mjs';
@@ -45,7 +45,7 @@ export declare class PluginEventSourceImpl implements PluginEventSource {
      * events.off('my-event', myListener);
      * ```
      */
-    off<EventName extends StringKeys<PluginEventMap>, Arguments extends EventName extends StringKeys<PluginEventMap> ? PluginEventMap[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void;
+    off<EventName extends StringKeys<PluginEventMap>, Arguments extends CallbackArguments<PluginEventMap, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>): void;
     /**
      * Remove an event listener by reference.
      *
@@ -72,7 +72,7 @@ export declare class PluginEventSourceImpl implements PluginEventSource {
      * });
      * ```
      */
-    on<EventName extends StringKeys<PluginEventMap>, Arguments extends EventName extends StringKeys<PluginEventMap> ? PluginEventMap[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
+    on<EventName extends StringKeys<PluginEventMap>, Arguments extends CallbackArguments<PluginEventMap, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
     /**
      * Add an event listener that will be triggered only once.
      *
@@ -93,5 +93,5 @@ export declare class PluginEventSourceImpl implements PluginEventSource {
      * });
      * ```
      */
-    once<EventName extends StringKeys<PluginEventMap>, Arguments extends EventName extends StringKeys<PluginEventMap> ? PluginEventMap[EventName] : unknown[]>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
+    once<EventName extends StringKeys<PluginEventMap>, Arguments extends CallbackArguments<PluginEventMap, EventName>>(name: EventName, callback: (...$arguments: Arguments) => Promisable<void>, thisArgument?: unknown): AsyncEventRef;
 }

package/dist/lib/esm/plugin/plugin-event-source.mjs

@@ -90,4 +90,4 @@ class PluginEventSourceImpl {
 export {
   PluginEventSourceImpl
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/plugin/plugin-instance.d.mts

@@ -34,6 +34,13 @@
 import type { App, Plugin } from 'obsidian';
 import { Component } from 'obsidian';
 import type { PluginNoticeComponent } from '../components/plugin-notice-component.mjs';
+/**
+ * The event `app.plugins` triggers after every enable, disable, install, uninstall and manifest reload.
+ *
+ * Read from Obsidian `1.15.1`: `didChange` triggers it debounced by one macrotask, so several changes in one
+ * task arrive as one event, after `enablePlugin` / `disablePlugin` returned.
+ */
+export declare const PLUGINS_CHANGED_EVENT_NAME = "changed";
 /**
  * Whether another plugin's instance can be used right now, and if not, why.
  */