@mnaoumov/obsidian-lib 6.0.4 → 6.2.0

package/dist/lib/cjs/plugin/plugin-context.cjs

@@ -123,6 +123,7 @@ var import_abort_controller = require('@mnaoumov/typescript-lib/abort-controller
 var import_debug = require('@mnaoumov/typescript-lib/debug');
 var import_library = require('@mnaoumov/typescript-lib/library');
 var import_css_class = require('../css-class.cjs');
+var import_debug2 = require('../debug.cjs');
 var import_generated_during_build = require('../generated-during-build.cjs');
 var import_library_styles = require('../library-styles.cjs');
 var import_library2 = require('../library.cjs');
@@ -154,7 +155,7 @@ function initPluginContext(pluginId) {
     debugPrefixNamespace: `${pluginId}:`,
     shouldPrintStackTrace: true
   });
-  (0, import_debug.showInitialDebugMessage)(pluginId);
+  (0, import_debug2.showInitialDebugMessage)(pluginId);
   (0, import_abort_controller.getSharedAbortController)();
   (0, import_library_styles.injectLibraryStyles)({
     doc: document,
@@ -168,4 +169,4 @@ function initPluginContext(pluginId) {
   initDebugController,
   initPluginContext
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/validation.cjs

@@ -114,11 +114,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var validation_exports = {};
 __export(validation_exports, {
+  ANDROID_UNSAFE_PATH_CHARS: () => ANDROID_UNSAFE_PATH_CHARS,
   OBSIDIAN_UNSAFE_FILENAME_CHARS: () => OBSIDIAN_UNSAFE_FILENAME_CHARS,
   UNIX_UNSAFE_PATH_CHARS: () => UNIX_UNSAFE_PATH_CHARS,
   WINDOWS_UNSAFE_PATH_CHARS: () => WINDOWS_UNSAFE_PATH_CHARS,
+  getFileNameValidationMessage: () => getFileNameValidationMessage,
   getOsAndObsidianUnsafePathCharsRegExp: () => getOsAndObsidianUnsafePathCharsRegExp,
   getOsUnsafePathCharsRegExp: () => getOsUnsafePathCharsRegExp,
+  getPathValidationMessage: () => getPathValidationMessage,
   hasWindowsTrailingChars: () => hasWindowsTrailingChars,
   isValidationMessageHolder: () => isValidationMessageHolder,
   isWindowsReservedName: () => isWindowsReservedName,
@@ -128,23 +131,49 @@ module.exports = __toCommonJS(validation_exports);
 var import_path = require('@mnaoumov/typescript-lib/path');
 var import_reg_exp = require('@mnaoumov/typescript-lib/reg-exp');
 var import_obsidian = require('obsidian');
+var import_i18n = require('./i18n/i18n.cjs');
 function isValidationMessageHolder(value) {
   return value.validationMessage !== void 0;
 }
 const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\]|]/g;
 const WINDOWS_UNSAFE_PATH_CHARS = /[*\\/<>:|?"]/g;
-const UNIX_UNSAFE_PATH_CHARS = /[\0/]/g;
+const UNIX_UNSAFE_PATH_CHARS = /[\0\\/:]/g;
+const ANDROID_UNSAFE_PATH_CHARS = /[\0*\\/<>:?"]/g;
 const WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;
 const WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;
-function getOsAndObsidianUnsafePathCharsRegExp(isWindows) {
+const FIRST_NON_CONTROL_CHAR = " ";
+function getFileNameValidationMessage(name, isWindows, isAndroid) {
+  if (name === "") {
+    return (0, import_i18n.t)(($) => $.obsidianLib.validation.emptyName);
+  }
+  if (hasControlChars(name)) {
+    return (0, import_i18n.t)(($) => $.obsidianLib.validation.controlCharacter, { name });
+  }
+  const unsafeChars = new Set(name.match(getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid)));
+  if (unsafeChars.size > 0) {
+    return (0, import_i18n.t)(($) => $.obsidianLib.validation.unsafeCharacters, { characters: [...unsafeChars].join(" "), name });
+  }
+  if (hasWindowsTrailingChars(name)) {
+    return (0, import_i18n.t)(($) => $.obsidianLib.validation.trailingCharacters, { name });
+  }
+  return isWindowsReservedName(name) ? (0, import_i18n.t)(($) => $.obsidianLib.validation.windowsReservedName, { name }) : "";
+}
+function getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid) {
   return (0, import_reg_exp.oneOf)([
-    getOsUnsafePathCharsRegExp(isWindows),
+    getOsUnsafePathCharsRegExp(isWindows, isAndroid),
     OBSIDIAN_UNSAFE_FILENAME_CHARS
   ]);
 }
-function getOsUnsafePathCharsRegExp(isWindows) {
+function getOsUnsafePathCharsRegExp(isWindows, isAndroid) {
   isWindows ??= import_obsidian.Platform.isWin;
-  return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
+  if (isWindows) {
+    return WINDOWS_UNSAFE_PATH_CHARS;
+  }
+  isAndroid ??= import_obsidian.Platform.isAndroidApp;
+  return isAndroid ? ANDROID_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
+}
+function getPathValidationMessage(path, isWindows, isAndroid) {
+  return path.split("/").map((segment) => getFileNameValidationMessage(segment, isWindows, isAndroid)).find(Boolean) ?? "";
 }
 function hasWindowsTrailingChars(name) {
   return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);
@@ -156,16 +185,27 @@ function isWindowsReservedName(name) {
 function trimWindowsTrailingChars(name) {
   return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, "");
 }
+function hasControlChars(name) {
+  for (const char of name) {
+    if (char < FIRST_NON_CONTROL_CHAR) {
+      return true;
+    }
+  }
+  return false;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ANDROID_UNSAFE_PATH_CHARS,
   OBSIDIAN_UNSAFE_FILENAME_CHARS,
   UNIX_UNSAFE_PATH_CHARS,
   WINDOWS_UNSAFE_PATH_CHARS,
+  getFileNameValidationMessage,
   getOsAndObsidianUnsafePathCharsRegExp,
   getOsUnsafePathCharsRegExp,
+  getPathValidationMessage,
   hasWindowsTrailingChars,
   isValidationMessageHolder,
   isWindowsReservedName,
   trimWindowsTrailingChars
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/validation.ts"],"sourcesContent":["/**\n * @file\n *\n * Validation utilities.\n */\n\nimport {\n  basename,\n  extname\n} from '@mnaoumov/typescript-lib/path';\nimport { oneOf } from '@mnaoumov/typescript-lib/reg-exp';\nimport { Platform } from 'obsidian';\n\n/**\n * Holds a validation message.\n */\nexport interface ValidationMessageHolder {\n  /**\n   * A validation message.\n   */\n  validationMessage: string;\n}\n\n/**\n * Type guard to check if a value is a validation message holder.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a validation message holder, `false` otherwise.\n */\nexport function isValidationMessageHolder(value: unknown): value is ValidationMessageHolder {\n  return (value as Partial<ValidationMessageHolder>).validationMessage !== undefined;\n}\n\n/**\n * Matches characters that are not safe to use in file names within Obsidian.\n */\nexport const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\\]|]/g;\n\n/**\n * Windows-specific unsafe file name path characters.\n */\nexport const WINDOWS_UNSAFE_PATH_CHARS = /[*\\\\/<>:|?\"]/g;\n\n/**\n * Unix-specific unsafe file name path characters.\n */\nexport const UNIX_UNSAFE_PATH_CHARS = /[\\0/]/g;\n\n/**\n * The MS-DOS device names Windows still refuses as a file name, with or without an extension.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately absent: they are accepted by\n * every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Unlike the exported character sets above, this carries no `g` flag, so `test` may be called on it\n * repeatedly — a `g`-flagged regexp advances `lastIndex` and answers differently on consecutive calls.\n */\nconst WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;\n\n/**\n * The trailing dots and spaces Windows strips from a name before it does anything else with it.\n */\nconst WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;\n\n/**\n * Returns a regexp matching all unsafe characters in file names/paths.\n *\n * Includes both OS-specific restrictions and Obsidian-specific ones.\n *\n * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.\n * @returns A regexp matching all unsafe characters in file names/paths.\n */\nexport function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean): RegExp {\n  return oneOf([\n    getOsUnsafePathCharsRegExp(isWindows),\n    OBSIDIAN_UNSAFE_FILENAME_CHARS\n  ]);\n}\n\n/**\n * Returns a regexp matching characters that are not safe to use in file names/paths at the OS level.\n *\n * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.\n * @returns A regexp matching characters that are not safe to use in file names/paths at the OS level.\n */\nexport function getOsUnsafePathCharsRegExp(isWindows?: boolean): RegExp {\n  isWindows ??= Platform.isWin;\n  return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;\n}\n\n/**\n * Checks whether a name ends with the dots or spaces Windows refuses.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, not a path.\n * @returns `true` if the name ends with a dot or a space, `false` otherwise.\n */\nexport function hasWindowsTrailingChars(name: string): boolean {\n  return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);\n}\n\n/**\n * Checks whether a name is one of the MS-DOS device names Windows refuses.\n *\n * Two steps the caller would otherwise have to know about happen here: trailing dots and spaces are\n * trimmed BEFORE the test, because Windows strips them before deciding and `CON ` is therefore as\n * reserved as `CON`; and the extension is dropped, because `CON.md` is reserved too.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately NOT reserved: they are accepted\n * by every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, with or without its extension.\n * @returns `true` if the name is reserved, `false` otherwise.\n */\nexport function isWindowsReservedName(name: string): boolean {\n  const trimmedName = trimWindowsTrailingChars(name);\n  return WINDOWS_RESERVED_NAME_REG_EXP.test(basename(trimmedName, extname(trimmedName)));\n}\n\n/**\n * Removes the trailing dots and spaces Windows refuses from the end of a name.\n *\n * Trim before testing for a reserved name, never after: trimming afterwards turns an accepted `CON ` into\n * a rejected `CON`. {@link isWindowsReservedName} already does this internally.\n *\n * @param name - The name to trim. A single path segment, not a path.\n * @returns The name without its trailing dots and spaces, which may be empty.\n */\nexport function trimWindowsTrailingChars(name: string): string {\n  return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, '');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAGO;AACP,qBAAsB;AACtB,sBAAyB;AAkBlB,SAAS,0BAA0B,OAAkD;AAC1F,SAAQ,MAA2C,sBAAsB;AAC3E;AAKO,MAAM,iCAAiC;AAKvC,MAAM,4BAA4B;AAKlC,MAAM,yBAAyB;AAWtC,MAAM,gCAAgC;AAKtC,MAAM,iCAAiC;AAUhC,SAAS,sCAAsC,WAA6B;AACjF,aAAO,sBAAM;AAAA,IACX,2BAA2B,SAAS;AAAA,IACpC;AAAA,EACF,CAAC;AACH;AAQO,SAAS,2BAA2B,WAA6B;AACtE,gBAAc,yBAAS;AACvB,SAAO,YAAY,4BAA4B;AACjD;AAWO,SAAS,wBAAwB,MAAuB;AAC7D,SAAO,+BAA+B,KAAK,IAAI;AACjD;AAkBO,SAAS,sBAAsB,MAAuB;AAC3D,QAAM,cAAc,yBAAyB,IAAI;AACjD,SAAO,8BAA8B,SAAK,sBAAS,iBAAa,qBAAQ,WAAW,CAAC,CAAC;AACvF;AAWO,SAAS,yBAAyB,MAAsB;AAC7D,SAAO,KAAK,QAAQ,gCAAgC,EAAE;AACxD;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/validation.ts"],"sourcesContent":["/**\n * @file\n *\n * Validation utilities.\n */\n\nimport {\n  basename,\n  extname\n} from '@mnaoumov/typescript-lib/path';\nimport { oneOf } from '@mnaoumov/typescript-lib/reg-exp';\nimport { Platform } from 'obsidian';\n\nimport { t } from './i18n/i18n.ts';\n\n/**\n * Holds a validation message.\n */\nexport interface ValidationMessageHolder {\n  /**\n   * A validation message.\n   */\n  validationMessage: string;\n}\n\n/**\n * Type guard to check if a value is a validation message holder.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a validation message holder, `false` otherwise.\n */\nexport function isValidationMessageHolder(value: unknown): value is ValidationMessageHolder {\n  return (value as Partial<ValidationMessageHolder>).validationMessage !== undefined;\n}\n\n/**\n * Matches characters that are not safe to use in file names within Obsidian.\n */\nexport const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\\]|]/g;\n\n/**\n * The characters Obsidian refuses in a file name on Windows.\n *\n * Read from Obsidian 1.15.0's `app.js`, whose name check throws on this set from `app.vault.create`, a\n * rename and Sync alike.\n */\nexport const WINDOWS_UNSAFE_PATH_CHARS = /[*\\\\/<>:|?\"]/g;\n\n/**\n * The characters Obsidian refuses in a file name on macOS, Linux and iOS, plus the NUL no file system stores.\n *\n * This is Obsidian's refusal set, not the file system's: macOS and Linux store `\\` and `:`, but Obsidian\n * refuses both, so a name holding either cannot be created through the vault there. Read from Obsidian\n * 1.15.0's `app.js`.\n */\nexport const UNIX_UNSAFE_PATH_CHARS = /[\\0\\\\/:]/g;\n\n/**\n * The characters Obsidian refuses in a file name on Android, plus the NUL no file system stores.\n *\n * Obsidian adds `* ? < > \"` to the {@link UNIX_UNSAFE_PATH_CHARS} set there, because Android's shared\n * storage refuses them. Read from Obsidian 1.15.0's `app.js`.\n */\nexport const ANDROID_UNSAFE_PATH_CHARS = /[\\0*\\\\/<>:?\"]/g;\n\n/**\n * The MS-DOS device names Windows still refuses as a file name, with or without an extension.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately absent: they are accepted by\n * every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Unlike the exported character sets above, this carries no `g` flag, so `test` may be called on it\n * repeatedly — a `g`-flagged regexp advances `lastIndex` and answers differently on consecutive calls.\n */\nconst WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;\n\n/**\n * The trailing dots and spaces Windows strips from a name before it does anything else with it.\n */\nconst WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;\n\n/**\n * The first character after the C0 control range, U+0000 to U+001F, which Windows refuses in a name.\n */\nconst FIRST_NON_CONTROL_CHAR = ' ';\n\n/**\n * Validates a single file or folder name against every naming rule this module owns.\n *\n * The rules, checked in this order, and the first one broken names the message:\n *\n * 1. The name is not empty.\n * 2. It holds no control character (U+0000 to U+001F).\n * 3. It holds none of the characters {@link getOsAndObsidianUnsafePathCharsRegExp} matches.\n * 4. It does not end with a dot or a space ({@link hasWindowsTrailingChars}).\n * 5. It is not an MS-DOS device name ({@link isWindowsReservedName}), with or without an extension.\n *\n * Only rule 3 depends on the platform. Rules 2, 4 and 5 apply on every platform, because a vault is synced,\n * and a name created on macOS or Linux that Windows refuses breaks the vault there. The character set follows\n * the platform because it is Obsidian's own refusal set, which differs per platform: a name such as `a?b` is\n * accepted on macOS, where Obsidian creates it.\n *\n * @param name - The name to validate. A single path segment, with or without its extension.\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns A message describing the first broken rule, or an empty string if the name is valid.\n */\nexport function getFileNameValidationMessage(name: string, isWindows?: boolean, isAndroid?: boolean): string {\n  if (name === '') {\n    return t(($) => $.obsidianLib.validation.emptyName);\n  }\n\n  if (hasControlChars(name)) {\n    return t(($) => $.obsidianLib.validation.controlCharacter, { name });\n  }\n\n  const unsafeChars = new Set(name.match(getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid)));\n  if (unsafeChars.size > 0) {\n    return t(($) => $.obsidianLib.validation.unsafeCharacters, { characters: [...unsafeChars].join(' '), name });\n  }\n\n  if (hasWindowsTrailingChars(name)) {\n    return t(($) => $.obsidianLib.validation.trailingCharacters, { name });\n  }\n\n  return isWindowsReservedName(name) ? t(($) => $.obsidianLib.validation.windowsReservedName, { name }) : '';\n}\n\n/**\n * Returns a regexp matching all unsafe characters in file names/paths.\n *\n * Includes both the platform's refused characters ({@link getOsUnsafePathCharsRegExp}) and the ones that break\n * links ({@link OBSIDIAN_UNSAFE_FILENAME_CHARS}).\n *\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns A regexp matching all unsafe characters in file names/paths.\n */\nexport function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp {\n  return oneOf([\n    getOsUnsafePathCharsRegExp(isWindows, isAndroid),\n    OBSIDIAN_UNSAFE_FILENAME_CHARS\n  ]);\n}\n\n/**\n * Returns a regexp matching the characters Obsidian refuses in a file name on the given platform.\n *\n * That is {@link WINDOWS_UNSAFE_PATH_CHARS} on Windows, {@link ANDROID_UNSAFE_PATH_CHARS} on Android and\n * {@link UNIX_UNSAFE_PATH_CHARS} everywhere else. It is Obsidian's set rather than the file system's, so a\n * name it accepts can be created through the vault.\n *\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns A regexp matching the characters Obsidian refuses in a file name on the given platform.\n */\nexport function getOsUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp {\n  isWindows ??= Platform.isWin;\n  if (isWindows) {\n    return WINDOWS_UNSAFE_PATH_CHARS;\n  }\n\n  isAndroid ??= Platform.isAndroidApp;\n  return isAndroid ? ANDROID_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;\n}\n\n/**\n * Validates every segment of a vault path with {@link getFileNameValidationMessage}.\n *\n * @param path - The vault-relative path to validate, with `/` as the separator.\n * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.\n * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to\n * `Platform.isAndroidApp`.\n * @returns The message for the first invalid segment, or an empty string if every segment is valid.\n */\nexport function getPathValidationMessage(path: string, isWindows?: boolean, isAndroid?: boolean): string {\n  return path.split('/').map((segment) => getFileNameValidationMessage(segment, isWindows, isAndroid)).find(Boolean) ?? '';\n}\n\n/**\n * Checks whether a name ends with the dots or spaces Windows refuses.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, not a path.\n * @returns `true` if the name ends with a dot or a space, `false` otherwise.\n */\nexport function hasWindowsTrailingChars(name: string): boolean {\n  return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);\n}\n\n/**\n * Checks whether a name is one of the MS-DOS device names Windows refuses.\n *\n * Two steps the caller would otherwise have to know about happen here: trailing dots and spaces are\n * trimmed BEFORE the test, because Windows strips them before deciding and `CON ` is therefore as\n * reserved as `CON`; and the extension is dropped, because `CON.md` is reserved too.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately NOT reserved: they are accepted\n * by every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, with or without its extension.\n * @returns `true` if the name is reserved, `false` otherwise.\n */\nexport function isWindowsReservedName(name: string): boolean {\n  const trimmedName = trimWindowsTrailingChars(name);\n  return WINDOWS_RESERVED_NAME_REG_EXP.test(basename(trimmedName, extname(trimmedName)));\n}\n\n/**\n * Removes the trailing dots and spaces Windows refuses from the end of a name.\n *\n * Trim before testing for a reserved name, never after: trimming afterwards turns an accepted `CON ` into\n * a rejected `CON`. {@link isWindowsReservedName} already does this internally.\n *\n * @param name - The name to trim. A single path segment, not a path.\n * @returns The name without its trailing dots and spaces, which may be empty.\n */\nexport function trimWindowsTrailingChars(name: string): string {\n  return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, '');\n}\n\n/**\n * Checks whether a name holds a control character, U+0000 to U+001F.\n *\n * @param name - The name to check.\n * @returns `true` if the name holds a control character, `false` otherwise.\n */\nfunction hasControlChars(name: string): boolean {\n  for (const char of name) {\n    if (char < FIRST_NON_CONTROL_CHAR) {\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAGO;AACP,qBAAsB;AACtB,sBAAyB;AAEzB,kBAAkB;AAkBX,SAAS,0BAA0B,OAAkD;AAC1F,SAAQ,MAA2C,sBAAsB;AAC3E;AAKO,MAAM,iCAAiC;AAQvC,MAAM,4BAA4B;AASlC,MAAM,yBAAyB;AAQ/B,MAAM,4BAA4B;AAWzC,MAAM,gCAAgC;AAKtC,MAAM,iCAAiC;AAKvC,MAAM,yBAAyB;AAwBxB,SAAS,6BAA6B,MAAc,WAAqB,WAA6B;AAC3G,MAAI,SAAS,IAAI;AACf,eAAO,eAAE,CAAC,MAAM,EAAE,YAAY,WAAW,SAAS;AAAA,EACpD;AAEA,MAAI,gBAAgB,IAAI,GAAG;AACzB,eAAO,eAAE,CAAC,MAAM,EAAE,YAAY,WAAW,kBAAkB,EAAE,KAAK,CAAC;AAAA,EACrE;AAEA,QAAM,cAAc,IAAI,IAAI,KAAK,MAAM,sCAAsC,WAAW,SAAS,CAAC,CAAC;AACnG,MAAI,YAAY,OAAO,GAAG;AACxB,eAAO,eAAE,CAAC,MAAM,EAAE,YAAY,WAAW,kBAAkB,EAAE,YAAY,CAAC,GAAG,WAAW,EAAE,KAAK,GAAG,GAAG,KAAK,CAAC;AAAA,EAC7G;AAEA,MAAI,wBAAwB,IAAI,GAAG;AACjC,eAAO,eAAE,CAAC,MAAM,EAAE,YAAY,WAAW,oBAAoB,EAAE,KAAK,CAAC;AAAA,EACvE;AAEA,SAAO,sBAAsB,IAAI,QAAI,eAAE,CAAC,MAAM,EAAE,YAAY,WAAW,qBAAqB,EAAE,KAAK,CAAC,IAAI;AAC1G;AAaO,SAAS,sCAAsC,WAAqB,WAA6B;AACtG,aAAO,sBAAM;AAAA,IACX,2BAA2B,WAAW,SAAS;AAAA,IAC/C;AAAA,EACF,CAAC;AACH;AAcO,SAAS,2BAA2B,WAAqB,WAA6B;AAC3F,gBAAc,yBAAS;AACvB,MAAI,WAAW;AACb,WAAO;AAAA,EACT;AAEA,gBAAc,yBAAS;AACvB,SAAO,YAAY,4BAA4B;AACjD;AAWO,SAAS,yBAAyB,MAAc,WAAqB,WAA6B;AACvG,SAAO,KAAK,MAAM,GAAG,EAAE,IAAI,CAAC,YAAY,6BAA6B,SAAS,WAAW,SAAS,CAAC,EAAE,KAAK,OAAO,KAAK;AACxH;AAWO,SAAS,wBAAwB,MAAuB;AAC7D,SAAO,+BAA+B,KAAK,IAAI;AACjD;AAkBO,SAAS,sBAAsB,MAAuB;AAC3D,QAAM,cAAc,yBAAyB,IAAI;AACjD,SAAO,8BAA8B,SAAK,sBAAS,iBAAa,qBAAQ,WAAW,CAAC,CAAC;AACvF;AAWO,SAAS,yBAAyB,MAAsB;AAC7D,SAAO,KAAK,QAAQ,gCAAgC,EAAE;AACxD;AAQA,SAAS,gBAAgB,MAAuB;AAC9C,aAAW,QAAQ,MAAM;AACvB,QAAI,OAAO,wBAAwB;AACjC,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/lib/cjs/validation.d.cts

@@ -25,29 +25,85 @@ export declare function isValidationMessageHolder(value: unknown): value is Vali
  */
 export declare const OBSIDIAN_UNSAFE_FILENAME_CHARS: RegExp;
 /**
- * Windows-specific unsafe file name path characters.
+ * The characters Obsidian refuses in a file name on Windows.
+ *
+ * Read from Obsidian 1.15.0's `app.js`, whose name check throws on this set from `app.vault.create`, a
+ * rename and Sync alike.
  */
 export declare const WINDOWS_UNSAFE_PATH_CHARS: RegExp;
 /**
- * Unix-specific unsafe file name path characters.
+ * The characters Obsidian refuses in a file name on macOS, Linux and iOS, plus the NUL no file system stores.
+ *
+ * This is Obsidian's refusal set, not the file system's: macOS and Linux store `\` and `:`, but Obsidian
+ * refuses both, so a name holding either cannot be created through the vault there. Read from Obsidian
+ * 1.15.0's `app.js`.
  */
 export declare const UNIX_UNSAFE_PATH_CHARS: RegExp;
+/**
+ * The characters Obsidian refuses in a file name on Android, plus the NUL no file system stores.
+ *
+ * Obsidian adds `* ? < > "` to the {@link UNIX_UNSAFE_PATH_CHARS} set there, because Android's shared
+ * storage refuses them. Read from Obsidian 1.15.0's `app.js`.
+ */
+export declare const ANDROID_UNSAFE_PATH_CHARS: RegExp;
+/**
+ * Validates a single file or folder name against every naming rule this module owns.
+ *
+ * The rules, checked in this order, and the first one broken names the message:
+ *
+ * 1. The name is not empty.
+ * 2. It holds no control character (U+0000 to U+001F).
+ * 3. It holds none of the characters {@link getOsAndObsidianUnsafePathCharsRegExp} matches.
+ * 4. It does not end with a dot or a space ({@link hasWindowsTrailingChars}).
+ * 5. It is not an MS-DOS device name ({@link isWindowsReservedName}), with or without an extension.
+ *
+ * Only rule 3 depends on the platform. Rules 2, 4 and 5 apply on every platform, because a vault is synced,
+ * and a name created on macOS or Linux that Windows refuses breaks the vault there. The character set follows
+ * the platform because it is Obsidian's own refusal set, which differs per platform: a name such as `a?b` is
+ * accepted on macOS, where Obsidian creates it.
+ *
+ * @param name - The name to validate. A single path segment, with or without its extension.
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
+ * @returns A message describing the first broken rule, or an empty string if the name is valid.
+ */
+export declare function getFileNameValidationMessage(name: string, isWindows?: boolean, isAndroid?: boolean): string;
 /**
  * Returns a regexp matching all unsafe characters in file names/paths.
  *
- * Includes both OS-specific restrictions and Obsidian-specific ones.
+ * Includes both the platform's refused characters ({@link getOsUnsafePathCharsRegExp}) and the ones that break
+ * links ({@link OBSIDIAN_UNSAFE_FILENAME_CHARS}).
  *
- * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
  * @returns A regexp matching all unsafe characters in file names/paths.
  */
-export declare function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean): RegExp;
+export declare function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp;
+/**
+ * Returns a regexp matching the characters Obsidian refuses in a file name on the given platform.
+ *
+ * That is {@link WINDOWS_UNSAFE_PATH_CHARS} on Windows, {@link ANDROID_UNSAFE_PATH_CHARS} on Android and
+ * {@link UNIX_UNSAFE_PATH_CHARS} everywhere else. It is Obsidian's set rather than the file system's, so a
+ * name it accepts can be created through the vault.
+ *
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
+ * @returns A regexp matching the characters Obsidian refuses in a file name on the given platform.
+ */
+export declare function getOsUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp;
 /**
- * Returns a regexp matching characters that are not safe to use in file names/paths at the OS level.
+ * Validates every segment of a vault path with {@link getFileNameValidationMessage}.
  *
- * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.
- * @returns A regexp matching characters that are not safe to use in file names/paths at the OS level.
+ * @param path - The vault-relative path to validate, with `/` as the separator.
+ * @param isWindows - Whether to use the Windows character set. Defaults to `Platform.isWin`.
+ * @param isAndroid - Whether to use the Android character set when `isWindows` is false. Defaults to
+ * `Platform.isAndroidApp`.
+ * @returns The message for the first invalid segment, or an empty string if every segment is valid.
  */
-export declare function getOsUnsafePathCharsRegExp(isWindows?: boolean): RegExp;
+export declare function getPathValidationMessage(path: string, isWindows?: boolean, isAndroid?: boolean): string;
 /**
  * Checks whether a name ends with the dots or spaces Windows refuses.
  *

package/dist/lib/esm/__merged.d.mts

@@ -57,7 +57,7 @@ export { CssClass } from './css-class.mjs';
 export { PluginDataHandler } from './data-handler.mjs';
 export { fixTitle, makeLinkWithPath } from './dataview-link.mjs';
 export { getRenderedContainer, insertCodeBlock, reloadCurrentFileCache, renderIframe, renderPaginatedList, renderPaginatedTable } from './dataview.mjs';
-export { getObsidianLibDebugger } from './debug.mjs';
+export { getObsidianLibDebugger, showInitialDebugMessage } from './debug.mjs';
 export { bootstrapDemoVault } from './demo-vault-helper.mjs';
 export { getDemoVaultArchiveFileName, getDemoVaultFolderName } from './demo-vault-naming.mjs';
 export { openDemoVault } from './desktop-demo-vault-opener.mjs';
@@ -160,7 +160,7 @@ export { PluginStatusBarItemRegistrar } from './status-bar-item-registrar.mjs';
 export { getTemplaterFunctions, getTemplaterRenderTargetFile, parseTemplate, requireTemplaterApi, resolveTemplaterApi, TEMPLATER_PLUGIN_ID, TemplaterActiveFileProvider, TemplaterRunMode, TemplaterUnavailabilityReason, TemplaterUnavailableError } from './templater.mjs';
 export { DurationTransformer } from './transformers/duration-transformer.mjs';
 export { clickElement, clickMouse, hoverElement, moveMouse, pressKey, typeIntoEditor, unhoverElement } from './trusted-input.mjs';
-export { getOsAndObsidianUnsafePathCharsRegExp, getOsUnsafePathCharsRegExp, hasWindowsTrailingChars, isValidationMessageHolder, isWindowsReservedName, OBSIDIAN_UNSAFE_FILENAME_CHARS, trimWindowsTrailingChars, UNIX_UNSAFE_PATH_CHARS, WINDOWS_UNSAFE_PATH_CHARS } from './validation.mjs';
+export { ANDROID_UNSAFE_PATH_CHARS, getFileNameValidationMessage, getOsAndObsidianUnsafePathCharsRegExp, getOsUnsafePathCharsRegExp, getPathValidationMessage, hasWindowsTrailingChars, isValidationMessageHolder, isWindowsReservedName, OBSIDIAN_UNSAFE_FILENAME_CHARS, trimWindowsTrailingChars, UNIX_UNSAFE_PATH_CHARS, WINDOWS_UNSAFE_PATH_CHARS } from './validation.mjs';
 export { deleteIfNotUsed, DeleteIfNotUsedResult } from './vault-delete.mjs';
 export { VaultTransaction } from './vault-transaction.mjs';
 export { cleanupEmptyFolders, copySafe, createFolderSafe, CreateFolderSafeResult, createTemporaryFile, createTemporaryFolder, deleteEmptyFolder, deleteEmptyFolderHierarchy, getAbstractFilePathSafe, getAvailablePath, getFilePathSafe, getFolderPathSafe, getMarkdownFilesSorted, getNoteFilesSorted, getOrCreateAbstractFileSafe, getOrCreateFileSafe, getOrCreateFolderSafe, getSafeRenamePath, InvokeFileActionSafeResult, invokeWithFileSystemLock, isChild, isChildOrSelf, isEmptyFolder, listSafe, process, readSafe, renameSafe, saveNote, trashSafe } from './vault.mjs';
@@ -178,7 +178,7 @@ export { ASYNC_OPERATION_HOOK_KEY, ASYNC_OPERATION_HOOK_VERSION, getAsyncOperati
 export { Beeper } from '@mnaoumov/typescript-lib/beeper';
 export { blobToArrayBuffer, blobToDataUrl, blobToJpegArrayBuffer, dataUrlToArrayBuffer, isImageFile } from '@mnaoumov/typescript-lib/blob';
 export { formatBytes } from '@mnaoumov/typescript-lib/bytes';
-export { enableLibraryDebuggers, getDebugController, getDebugger, getLibDebugger, printWithStackTrace, showInitialDebugMessage } from '@mnaoumov/typescript-lib/debug';
+export { enableLibraryDebuggers, formatDebugGuideReference, getDebugController, getDebugger, getLibDebugger, isDebugNamespaceEnabled, printWithStackTrace } from '@mnaoumov/typescript-lib/debug';
 export { getDebugSwitch, getDebugSwitches, getTerminateOnTimeoutDebugSwitch, onDebugSwitchChanged, registerDebugSwitch, setDebugSwitch } from '@mnaoumov/typescript-lib/debug-switches';
 export { extractZipArchive } from '@mnaoumov/typescript-lib/desktop-zip-extractor';
 export { AsyncCallbackDisposable, AsyncDisposableBase, CallbackDisposable, CombineAsyncDisposable, CombineDisposable, DisposableBase, dispose, disposeAsync, DisposeErrorBehavior, DisposeOrder, isAsyncDisposable, isAsyncDisposableEx, isDisposable, isDisposableEx, MultipleDisposeBehavior, toAsyncDisposableEx, toDisposableEx } from '@mnaoumov/typescript-lib/disposable';