@mnaoumov/obsidian-lib 6.1.0 → 6.2.1

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

@@ -31,12 +31,10 @@ ensureBrowserProcess();
 })();
 
 import { getSharedAbortController } from "@mnaoumov/typescript-lib/abort-controller";
-import {
-  getDebugController,
-  showInitialDebugMessage
-} from "@mnaoumov/typescript-lib/debug";
+import { getDebugController } from "@mnaoumov/typescript-lib/debug";
 import { Library } from "@mnaoumov/typescript-lib/library";
 import { CssClass } from "../css-class.mjs";
+import { showInitialDebugMessage } from "../debug.mjs";
 import {
   LIBRARY_STYLES,
   LIBRARY_VERSION
@@ -87,4 +85,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/setting-components/text-based-component.mjs

@@ -55,10 +55,13 @@ function getTextBasedComponentValue($unknown) {
   return $unknown instanceof AbstractTextComponent ? new AbstractTextComponentWrapper($unknown) : null;
 }
 function isTextBasedComponent(component) {
+  if (typeof component !== "object" || component === null || !("setPlaceholderValue" in component) || !("isEmpty" in component)) {
+    return false;
+  }
   const textBasedComponent = component;
   return typeof textBasedComponent.setPlaceholderValue === "function" && typeof textBasedComponent.isEmpty === "function";
 }
 export {
   getTextBasedComponentValue
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -25,13 +25,27 @@ 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.
  *
@@ -43,39 +57,53 @@ export declare const UNIX_UNSAFE_PATH_CHARS: RegExp;
  * 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 `isWindows`. 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 stays
- * platform-dependent, because a name such as `Meeting: notes` is common on macOS, where it works.
+ * 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 include the Windows-specific character set. 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 message describing the first broken rule, or an empty string if the name is valid.
  */
-export declare function getFileNameValidationMessage(name: string, isWindows?: boolean): string;
+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 characters that are not safe to use in file names/paths at the OS level.
+ * 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 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 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): RegExp;
+export declare function getOsUnsafePathCharsRegExp(isWindows?: boolean, isAndroid?: boolean): RegExp;
 /**
  * Validates every segment of a vault path with {@link getFileNameValidationMessage}.
  *
  * @param path - The vault-relative path to validate, with `/` as the separator.
- * @param isWindows - Whether to include the Windows-specific character set. 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 The message for the first invalid segment, or an empty string if every segment is valid.
  */
-export declare function getPathValidationMessage(path: string, isWindows?: boolean): string;
+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/validation.mjs

@@ -42,18 +42,19 @@ function isValidationMessageHolder(value) {
 }
 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 = /[ .]+$/;
 const FIRST_NON_CONTROL_CHAR = " ";
-function getFileNameValidationMessage(name, isWindows) {
+function getFileNameValidationMessage(name, isWindows, isAndroid) {
   if (name === "") {
     return t(($) => $.obsidianLib.validation.emptyName);
   }
   if (hasControlChars(name)) {
     return t(($) => $.obsidianLib.validation.controlCharacter, { name });
   }
-  const unsafeChars = new Set(name.match(getOsAndObsidianUnsafePathCharsRegExp(isWindows)));
+  const unsafeChars = new Set(name.match(getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid)));
   if (unsafeChars.size > 0) {
     return t(($) => $.obsidianLib.validation.unsafeCharacters, { characters: [...unsafeChars].join(" "), name });
   }
@@ -62,18 +63,22 @@ function getFileNameValidationMessage(name, isWindows) {
   }
   return isWindowsReservedName(name) ? t(($) => $.obsidianLib.validation.windowsReservedName, { name }) : "";
 }
-function getOsAndObsidianUnsafePathCharsRegExp(isWindows) {
+function getOsAndObsidianUnsafePathCharsRegExp(isWindows, isAndroid) {
   return oneOf([
-    getOsUnsafePathCharsRegExp(isWindows),
+    getOsUnsafePathCharsRegExp(isWindows, isAndroid),
     OBSIDIAN_UNSAFE_FILENAME_CHARS
   ]);
 }
-function getOsUnsafePathCharsRegExp(isWindows) {
+function getOsUnsafePathCharsRegExp(isWindows, isAndroid) {
   isWindows ??= Platform.isWin;
-  return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
+  if (isWindows) {
+    return WINDOWS_UNSAFE_PATH_CHARS;
+  }
+  isAndroid ??= Platform.isAndroidApp;
+  return isAndroid ? ANDROID_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
 }
-function getPathValidationMessage(path, isWindows) {
-  return path.split("/").map((segment) => getFileNameValidationMessage(segment, isWindows)).find(Boolean) ?? "";
+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);
@@ -94,6 +99,7 @@ function hasControlChars(name) {
   return false;
 }
 export {
+  ANDROID_UNSAFE_PATH_CHARS,
   OBSIDIAN_UNSAFE_FILENAME_CHARS,
   UNIX_UNSAFE_PATH_CHARS,
   WINDOWS_UNSAFE_PATH_CHARS,
@@ -106,4 +112,4 @@ export {
   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\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 * 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 * 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 `isWindows`. 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 stays\n * platform-dependent, because a name such as `Meeting: notes` is common on macOS, where it works.\n *\n * @param name - The name to validate. A single path segment, with or without its extension.\n * @param isWindows - Whether to include the Windows-specific character set. Defaults to `Platform.isWin`.\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): 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)));\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 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 * 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 include the Windows-specific character set. Defaults to `Platform.isWin`.\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): string {\n  return path.split('/').map((segment) => getFileNameValidationMessage(segment, isWindows)).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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAa;AACtB,SAAS,gBAAgB;AAEzB,SAAS,SAAS;AAkBX,SAAS,0BAA0B,OAAkD;AAC1F,SAAQ,MAA2C,sBAAsB;AAC3E;AAKO,MAAM,iCAAiC;AAKvC,MAAM,4BAA4B;AAKlC,MAAM,yBAAyB;AAWtC,MAAM,gCAAgC;AAKtC,MAAM,iCAAiC;AAKvC,MAAM,yBAAyB;AAqBxB,SAAS,6BAA6B,MAAc,WAA6B;AACtF,MAAI,SAAS,IAAI;AACf,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,SAAS;AAAA,EACpD;AAEA,MAAI,gBAAgB,IAAI,GAAG;AACzB,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,kBAAkB,EAAE,KAAK,CAAC;AAAA,EACrE;AAEA,QAAM,cAAc,IAAI,IAAI,KAAK,MAAM,sCAAsC,SAAS,CAAC,CAAC;AACxF,MAAI,YAAY,OAAO,GAAG;AACxB,WAAO,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,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,oBAAoB,EAAE,KAAK,CAAC;AAAA,EACvE;AAEA,SAAO,sBAAsB,IAAI,IAAI,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,qBAAqB,EAAE,KAAK,CAAC,IAAI;AAC1G;AAUO,SAAS,sCAAsC,WAA6B;AACjF,SAAO,MAAM;AAAA,IACX,2BAA2B,SAAS;AAAA,IACpC;AAAA,EACF,CAAC;AACH;AAQO,SAAS,2BAA2B,WAA6B;AACtE,gBAAc,SAAS;AACvB,SAAO,YAAY,4BAA4B;AACjD;AASO,SAAS,yBAAyB,MAAc,WAA6B;AAClF,SAAO,KAAK,MAAM,GAAG,EAAE,IAAI,CAAC,YAAY,6BAA6B,SAAS,SAAS,CAAC,EAAE,KAAK,OAAO,KAAK;AAC7G;AAWO,SAAS,wBAAwB,MAAuB;AAC7D,SAAO,+BAA+B,KAAK,IAAI;AACjD;AAkBO,SAAS,sBAAsB,MAAuB;AAC3D,QAAM,cAAc,yBAAyB,IAAI;AACjD,SAAO,8BAA8B,KAAK,SAAS,aAAa,QAAQ,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":[]}
+//# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAa;AACtB,SAAS,gBAAgB;AAEzB,SAAS,SAAS;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,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,SAAS;AAAA,EACpD;AAEA,MAAI,gBAAgB,IAAI,GAAG;AACzB,WAAO,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,WAAO,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,WAAO,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,oBAAoB,EAAE,KAAK,CAAC;AAAA,EACvE;AAEA,SAAO,sBAAsB,IAAI,IAAI,EAAE,CAAC,MAAM,EAAE,YAAY,WAAW,qBAAqB,EAAE,KAAK,CAAC,IAAI;AAC1G;AAaO,SAAS,sCAAsC,WAAqB,WAA6B;AACtG,SAAO,MAAM;AAAA,IACX,2BAA2B,WAAW,SAAS;AAAA,IAC/C;AAAA,EACF,CAAC;AACH;AAcO,SAAS,2BAA2B,WAAqB,WAA6B;AAC3F,gBAAc,SAAS;AACvB,MAAI,WAAW;AACb,WAAO;AAAA,EACT;AAEA,gBAAc,SAAS;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,KAAK,SAAS,aAAa,QAAQ,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/obsidian-lib",
-  "version": "6.1.0",
+  "version": "6.2.1",
   "description": "Runtime library for Obsidian plugin development: plugin base classes, components, settings, modals, vault and metadata helpers.",
   "keywords": [
     "obsidian",
@@ -334,7 +334,7 @@
   "dependencies": {
     "@lezer/common": "1.5.2",
     "@mnaoumov/obsidian-dataview": "^1.0.0",
-    "@mnaoumov/typescript-lib": "^1.6.2",
+    "@mnaoumov/typescript-lib": "^2.0.0",
     "@standard-schema/spec": "^1.1.0",
     "@types/react": "^19.3.0",
     "compare-versions": "^6.1.1",