@mnaoumov/obsidian-lib 4.2.1 → 5.0.0

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

@@ -30,20 +30,26 @@ function ensureBrowserProcess() {
 ensureBrowserProcess();
 })();
 
-import {
-  ALWAYS_MATCH_REG_EXP,
-  escapeRegExp,
-  isValidRegExp,
-  NEVER_MATCH_REG_EXP
-} from "@mnaoumov/typescript-lib/reg-exp";
-import { trimEnd } from "@mnaoumov/typescript-lib/string";
+import { escapeRegExp } from "@mnaoumov/typescript-lib/reg-exp";
 import { assertNever } from "@mnaoumov/typescript-lib/type-guards";
 import { t } from "./i18n/i18n.mjs";
+const REG_EXP_ENTRY_REG_EXP = /^\/.*\/[a-z]*$/s;
+const CASE_INSENSITIVE_FLAG = "i";
+const STATEFUL_FLAGS_REG_EXP = /[gy]/g;
+const GLOB_CHARACTERS = /* @__PURE__ */ new Set(["?", "[", "*"]);
+const GLOBSTAR = "**";
+const GLOBSTAR_FOLDERS = "**/";
+const ALWAYS_MATCHER = {
+  isMatch: () => true
+};
+const NEVER_MATCHER = {
+  isMatch: () => false
+};
 class PathSetting {
   constructor(type) {
     this.type = type;
-    this.defaultRegExp = getDefaultRegExp(type);
-    this.regExp = this.defaultRegExp;
+    this.defaultMatcher = getDefaultMatcher(type);
+    this.matchers = [this.defaultMatcher];
   }
   type;
   get array() {
@@ -51,19 +57,20 @@ class PathSetting {
   }
   set array(value) {
     this._array = value.filter(Boolean);
-    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;
+    this.matchers = makeMatchers(this._array, this.defaultMatcher) ?? [this.defaultMatcher];
   }
   _array = [];
-  defaultRegExp;
-  regExp;
-  isPathIgnored(path) {
+  defaultMatcher;
+  matchers;
+  isPathIgnored(path, isFolder) {
+    const isMatch = this.matchers.some((matcher) => matcher.isMatch(path, isFolder));
     switch (this.type) {
       /* v8 ignore stop */
       case "Exclude" /* Exclude */: {
-        return this.regExp.test(path);
+        return isMatch;
       }
       case "Include" /* Include */: {
-        return !this.regExp.test(path);
+        return !isMatch;
       }
       default: {
         assertNever(this.type);
@@ -110,58 +117,225 @@ class PathSettings {
    * Checks if a path is ignored by the include/exclude path settings.
    *
    * @param path - The path to check.
+   * @param isFolder - Whether the path is a folder. Only a folder-only glob (one ending in `/`) reads it: such a glob
+   * always matches the contents of a matching folder, and matches the folder itself only when this is `true`.
    * @returns `true` if the path is ignored, `false` otherwise.
    */
-  isPathIgnored(path) {
-    return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);
+  isPathIgnored(path, isFolder = false) {
+    return this._includePaths.isPathIgnored(path, isFolder) || this._excludePaths.isPathIgnored(path, isFolder);
   }
 }
 function pathsValidator(paths) {
   for (const path of paths) {
-    if (path.startsWith("/") && path.endsWith("/") && !isValidRegExp(path.slice(1, -1))) {
-      return t(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });
+    const { error } = compileEntry(path, NEVER_MATCHER);
+    if (error !== void 0) {
+      return error;
+    }
+  }
+}
+function compileEntry(entry, defaultMatcher) {
+  if (entry === "/") {
+    return { matcher: defaultMatcher };
+  }
+  if (REG_EXP_ENTRY_REG_EXP.test(entry)) {
+    const flagsSeparatorIndex = entry.lastIndexOf("/");
+    return compileRegExpEntry(entry, entry.slice(1, flagsSeparatorIndex), entry.slice(flagsSeparatorIndex + 1));
+  }
+  return hasUnescapedGlobCharacter(entry) ? compileGlobEntry(entry) : compilePlainPathEntry(entry);
+}
+function compileGlobEntry(glob) {
+  const isFolderOnly = glob.endsWith("/");
+  const body = glob.replace(/\/+$/, "");
+  const globSource = getGlobSource(body);
+  if (!globSource.isValid) {
+    return {
+      error: t(($) => $.obsidianDevUtils.pathSettings.invalidGlob, { glob, reason: globSource.error })
+    };
+  }
+  const { source } = globSource;
+  const prefix = body.includes("/") ? "^" : "(?:^|/)";
+  let selfRegExp;
+  let contentsRegExp;
+  try {
+    selfRegExp = new RegExp(`${prefix}${source}$`, CASE_INSENSITIVE_FLAG);
+    contentsRegExp = new RegExp(`${prefix}${source}/`, CASE_INSENSITIVE_FLAG);
+  } catch (error_) {
+    return {
+      error: t(($) => $.obsidianDevUtils.pathSettings.invalidGlob, { glob, reason: getRegExpErrorReason(error_) })
+    };
+  }
+  return {
+    matcher: {
+      isMatch: (path, isFolder) => contentsRegExp.test(path) || (isFolder || !isFolderOnly) && selfRegExp.test(path)
     }
+  };
+}
+function compilePlainPathEntry(path) {
+  const unescapedPath = path.replaceAll(/\\(?<character>.)/gs, "$<character>").replace(/\/+$/, "");
+  const regExp = new RegExp(`^${escapeRegExp(unescapedPath)}(?:/|$)`, CASE_INSENSITIVE_FLAG);
+  return {
+    matcher: {
+      isMatch: (pathToCheck) => regExp.test(pathToCheck)
+    }
+  };
+}
+function compileRegExpEntry(entry, source, flags) {
+  let regExp;
+  try {
+    new RegExp(source, flags);
+    const effectiveFlags = flags.replaceAll(STATEFUL_FLAGS_REG_EXP, "");
+    regExp = new RegExp(source, effectiveFlags.includes(CASE_INSENSITIVE_FLAG) ? effectiveFlags : `${effectiveFlags}${CASE_INSENSITIVE_FLAG}`);
+  } catch (error) {
+    return {
+      error: t(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { reason: getRegExpErrorReason(error), regExp: entry })
+    };
   }
+  return {
+    matcher: {
+      isMatch: (path) => regExp.test(path)
+    }
+  };
+}
+function escapeCharacterClassCharacter(character) {
+  return /[-\\\]^[]/.test(character) ? `\\${character}` : character;
 }
-function getDefaultRegExp(type) {
+function getCharacterClassSource(glob, openIndex) {
+  let index = openIndex + 1;
+  let isNegated = false;
+  if (glob[index] === "!" || glob[index] === "^") {
+    isNegated = true;
+    index++;
+  }
+  let content = "";
+  if (glob[index] === "]") {
+    content += String.raw`\]`;
+    index++;
+  }
+  while (index < glob.length) {
+    const character = glob.charAt(index);
+    if (character === "]") {
+      return {
+        endIndex: index + 1,
+        isValid: true,
+        source: `[${isNegated ? "^/" : ""}${content}]`
+      };
+    }
+    if (character === "\\") {
+      index++;
+      if (index >= glob.length) {
+        break;
+      }
+      content += escapeCharacterClassCharacter(glob.charAt(index));
+    } else {
+      content += character === "-" ? character : escapeCharacterClassCharacter(character);
+    }
+    index++;
+  }
+  return { error: t(($) => $.obsidianDevUtils.pathSettings.unclosedCharacterClass), isValid: false };
+}
+function getDefaultMatcher(type) {
   switch (type) {
     /* v8 ignore stop */
     case "Exclude" /* Exclude */: {
-      return NEVER_MATCH_REG_EXP;
+      return NEVER_MATCHER;
     }
     case "Include" /* Include */: {
-      return ALWAYS_MATCH_REG_EXP;
+      return ALWAYS_MATCHER;
     }
     default: {
       assertNever(type);
     }
   }
 }
-function makeRegExp(paths, defaultRegExp) {
-  if (paths.length === 0) {
-    return defaultRegExp;
+function getGlobSource(glob) {
+  let source = "";
+  let index = 0;
+  while (index < glob.length) {
+    const character = glob.charAt(index);
+    switch (character) {
+      case "?": {
+        source += "[^/]";
+        index++;
+        break;
+      }
+      case "[": {
+        const characterClass = getCharacterClassSource(glob, index);
+        if (!characterClass.isValid) {
+          return characterClass;
+        }
+        source += characterClass.source;
+        index = characterClass.endIndex;
+        break;
+      }
+      case "*": {
+        if (!glob.startsWith(GLOBSTAR, index)) {
+          source += "[^/]*";
+          index++;
+          break;
+        }
+        const isSegmentStart = index === 0 || glob[index - 1] === "/";
+        if (isSegmentStart && glob.startsWith(GLOBSTAR_FOLDERS, index)) {
+          source += "(?:[^/]*/)*";
+          index += GLOBSTAR_FOLDERS.length;
+        } else if (isSegmentStart && index + GLOBSTAR.length === glob.length) {
+          source += ".*";
+          index += GLOBSTAR.length;
+        } else {
+          source += "[^/]*";
+          index += GLOBSTAR.length;
+        }
+        break;
+      }
+      case "\\": {
+        index++;
+        if (index >= glob.length) {
+          return { error: t(($) => $.obsidianDevUtils.pathSettings.trailingEscape), isValid: false };
+        }
+        source += escapeRegExp(glob.charAt(index));
+        index++;
+        break;
+      }
+      default: {
+        source += escapeRegExp(character);
+        index++;
+        break;
+      }
+    }
   }
-  const regExpStringCombined = paths.map((path) => {
-    if (path === "/") {
-      return defaultRegExp.source;
+  return { isValid: true, source };
+}
+function getRegExpErrorReason(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const match = /^Invalid regular expression: \/.*\/[a-z]*: (?<reason>.*)$/s.exec(message);
+  return match?.groups?.["reason"] ?? message;
+}
+function hasUnescapedGlobCharacter(entry) {
+  for (let index = 0; index < entry.length; index++) {
+    const character = entry.charAt(index);
+    if (character === "\\") {
+      index++;
+    } else if (GLOB_CHARACTERS.has(character)) {
+      return true;
     }
-    if (path.startsWith("/") && path.endsWith("/")) {
-      return path.slice(1, -1);
+  }
+  return false;
+}
+function makeMatchers(paths, defaultMatcher) {
+  if (paths.length === 0) {
+    return [defaultMatcher];
+  }
+  const matchers = [];
+  for (const path of paths) {
+    const { matcher } = compileEntry(path, defaultMatcher);
+    if (!matcher) {
+      return null;
     }
-    path = trimEnd({
-      $string: path,
-      suffix: "/"
-    });
-    return `^${escapeRegExp(path)}(/|$)`;
-  }).map((regExpString) => `(${regExpString})`).join("|");
-  try {
-    return new RegExp(regExpStringCombined);
-  } catch {
-    return null;
+    matchers.push(matcher);
   }
+  return matchers;
 }
 export {
   PathSettings,
   pathsValidator
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/path-settings.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides classes and validators for managing include/exclude path settings.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\n\nimport {\n  ALWAYS_MATCH_REG_EXP,\n  escapeRegExp,\n  isValidRegExp,\n  NEVER_MATCH_REG_EXP\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { trimEnd } from '@mnaoumov/typescript-lib/string';\nimport { assertNever } from '@mnaoumov/typescript-lib/type-guards';\n\nimport { t } from './i18n/i18n.ts';\n\nenum PathSettingType {\n  Exclude = 'Exclude',\n  Include = 'Include'\n}\n\nclass PathSetting {\n  public get array(): string[] {\n    return this._array;\n  }\n\n  public set array(value: string[]) {\n    this._array = value.filter(Boolean);\n    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;\n  }\n\n  private _array: string[] = [];\n  private readonly defaultRegExp: RegExp;\n  private regExp: RegExp;\n\n  public constructor(private readonly type: PathSettingType) {\n    this.defaultRegExp = getDefaultRegExp(type);\n    this.regExp = this.defaultRegExp;\n  }\n\n  public isPathIgnored(path: string): boolean {\n    /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n    switch (this.type) {\n      /* v8 ignore stop */\n      case PathSettingType.Exclude: {\n        return this.regExp.test(path);\n      }\n      case PathSettingType.Include: {\n        return !this.regExp.test(path);\n      }\n      default: {\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.type);\n      }\n        /* v8 ignore stop */\n    }\n  }\n}\n\n/**\n * A class for managing include/exclude path settings.\n */\nexport class PathSettings {\n  /**\n   * Gets the exclude paths.\n   *\n   * @returns The exclude paths.\n   */\n  public get excludePaths(): string[] {\n    return this._excludePaths.array;\n  }\n\n  /**\n   * Sets the exclude paths.\n   *\n   * @param value - The exclude paths.\n   */\n  public set excludePaths(value: string[]) {\n    this._excludePaths.array = value;\n  }\n\n  /**\n   * Gets the include paths.\n   *\n   * @returns The include paths.\n   */\n  public get includePaths(): string[] {\n    return this._includePaths.array;\n  }\n\n  /**\n   * Sets the include paths.\n   *\n   * @param value - The include paths.\n   */\n  public set includePaths(value: string[]) {\n    this._includePaths.array = value;\n  }\n\n  private readonly _excludePaths = new PathSetting(PathSettingType.Exclude);\n  private readonly _includePaths = new PathSetting(PathSettingType.Include);\n\n  /**\n   * Checks if a path is ignored by the include/exclude path settings.\n   *\n   * @param path - The path to check.\n   * @returns `true` if the path is ignored, `false` otherwise.\n   */\n  public isPathIgnored(path: string): boolean {\n    return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);\n  }\n}\n\n/**\n * Validates include/exclude path entries, reporting the first entry that is not a parseable regular expression.\n *\n * An entry that starts and ends with `/` is a regular expression literal; every other entry is a plain path and is\n * always valid. An invalid entry does not throw when assigned to {@link PathSettings} — the whole list falls back to\n * its default pattern instead — so this validator is what surfaces the problem to the user.\n *\n * @param paths - The path entries to validate.\n * @returns A message naming the first invalid entry, or nothing when every entry is valid.\n */\nexport function pathsValidator(paths: string[]): MaybeReturn<string> {\n  for (const path of paths) {\n    if (path.startsWith('/') && path.endsWith('/') && !isValidRegExp(path.slice(1, -1))) {\n      return t(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });\n    }\n  }\n}\n\nfunction getDefaultRegExp(type: PathSettingType): RegExp {\n  /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n  switch (type) {\n    /* v8 ignore stop */\n    case PathSettingType.Exclude: {\n      return NEVER_MATCH_REG_EXP;\n    }\n    case PathSettingType.Include: {\n      return ALWAYS_MATCH_REG_EXP;\n    }\n    default: {\n      /* v8 ignore start -- Exhaustive switch guard. */\n      assertNever(type);\n    }\n      /* v8 ignore stop */\n  }\n}\n\nfunction makeRegExp(paths: string[], defaultRegExp: RegExp): null | RegExp {\n  if (paths.length === 0) {\n    return defaultRegExp;\n  }\n\n  const regExpStringCombined = paths.map((path) => {\n    if (path === '/') {\n      return defaultRegExp.source;\n    }\n\n    if (path.startsWith('/') && path.endsWith('/')) {\n      return path.slice(1, -1);\n    }\n\n    path = trimEnd({\n      $string: path,\n      suffix: '/'\n    });\n    return `^${escapeRegExp(path)}(/|$)`;\n  })\n    .map((regExpString) => `(${regExpString})`)\n    .join('|');\n\n  try {\n    return new RegExp(regExpStringCombined);\n  } catch {\n    // A partially typed regex literal (`/^Inbox\\/`) is not parseable.\n    // Report it instead of throwing from a settings setter, which would break both the settings UI and the save path.\n    return null;\n  }\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/path-settings.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides classes and validators for managing include/exclude path settings.\n *\n * An entry takes one of three forms, and every form matches case-insensitively:\n *\n * - A regular expression literal, `/pattern/flags`. Its own flags are honoured and `i` is always added. `g` and `y` are\n *   accepted and dropped, since they make `RegExp.test` stateful and say nothing about which paths match.\n * - A glob, an entry holding an unescaped `*`, `?` or `[`. `*` matches within one path segment, `**` across segments,\n *   `?` one character and `[abc]` / `[!abc]` a character class. A glob with no `/` matches a file or folder NAME at any\n *   depth, as in `.gitignore` (`*.pdf` matches `a/b/c.pdf`); one with a `/` is anchored to the vault root\n *   (`Attachments/*.pdf`). A trailing `/` makes it match folders only.\n * - A plain path, every other entry, which matches that path and everything inside it. A literal `*`, `?`, `[` or `\\` in\n *   a plain path or a glob is written escaped (`\\*`).\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\n\nimport { escapeRegExp } from '@mnaoumov/typescript-lib/reg-exp';\nimport { assertNever } from '@mnaoumov/typescript-lib/type-guards';\n\nimport { t } from './i18n/i18n.ts';\n\nenum PathSettingType {\n  Exclude = 'Exclude',\n  Include = 'Include'\n}\n\ntype CharacterClassSourceResult = InvalidSourceResult | ValidCharacterClassSourceResult;\n\ninterface CompileResult {\n  readonly error?: string;\n  readonly matcher?: PathMatcher;\n}\n\ntype GlobSourceResult = InvalidSourceResult | ValidGlobSourceResult;\n\ninterface InvalidSourceResult {\n  readonly error: string;\n  readonly isValid: false;\n}\n\ninterface PathMatcher {\n  isMatch: (path: string, isFolder: boolean) => boolean;\n}\n\ninterface ValidCharacterClassSourceResult extends ValidGlobSourceResult {\n  readonly endIndex: number;\n}\n\ninterface ValidGlobSourceResult {\n  readonly isValid: true;\n  readonly source: string;\n}\n\nconst REG_EXP_ENTRY_REG_EXP = /^\\/.*\\/[a-z]*$/s;\nconst CASE_INSENSITIVE_FLAG = 'i';\nconst STATEFUL_FLAGS_REG_EXP = /[gy]/g;\nconst GLOB_CHARACTERS = new Set(['?', '[', '*']);\nconst GLOBSTAR = '**';\nconst GLOBSTAR_FOLDERS = '**/';\n\nconst ALWAYS_MATCHER: PathMatcher = {\n  isMatch: () => true\n};\n\nconst NEVER_MATCHER: PathMatcher = {\n  isMatch: () => false\n};\n\nclass PathSetting {\n  public get array(): string[] {\n    return this._array;\n  }\n\n  public set array(value: string[]) {\n    this._array = value.filter(Boolean);\n    this.matchers = makeMatchers(this._array, this.defaultMatcher) ?? [this.defaultMatcher];\n  }\n\n  private _array: string[] = [];\n  private readonly defaultMatcher: PathMatcher;\n  private matchers: PathMatcher[];\n\n  public constructor(private readonly type: PathSettingType) {\n    this.defaultMatcher = getDefaultMatcher(type);\n    this.matchers = [this.defaultMatcher];\n  }\n\n  public isPathIgnored(path: string, isFolder: boolean): boolean {\n    const isMatch = this.matchers.some((matcher) => matcher.isMatch(path, isFolder));\n    /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n    switch (this.type) {\n      /* v8 ignore stop */\n      case PathSettingType.Exclude: {\n        return isMatch;\n      }\n      case PathSettingType.Include: {\n        return !isMatch;\n      }\n      default: {\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.type);\n      }\n        /* v8 ignore stop */\n    }\n  }\n}\n\n/**\n * A class for managing include/exclude path settings.\n *\n * See the module documentation for the entry syntax: plain paths, globs and regular expression literals, all matched\n * case-insensitively.\n */\nexport class PathSettings {\n  /**\n   * Gets the exclude paths.\n   *\n   * @returns The exclude paths.\n   */\n  public get excludePaths(): string[] {\n    return this._excludePaths.array;\n  }\n\n  /**\n   * Sets the exclude paths.\n   *\n   * @param value - The exclude paths.\n   */\n  public set excludePaths(value: string[]) {\n    this._excludePaths.array = value;\n  }\n\n  /**\n   * Gets the include paths.\n   *\n   * @returns The include paths.\n   */\n  public get includePaths(): string[] {\n    return this._includePaths.array;\n  }\n\n  /**\n   * Sets the include paths.\n   *\n   * @param value - The include paths.\n   */\n  public set includePaths(value: string[]) {\n    this._includePaths.array = value;\n  }\n\n  private readonly _excludePaths = new PathSetting(PathSettingType.Exclude);\n  private readonly _includePaths = new PathSetting(PathSettingType.Include);\n\n  /**\n   * Checks if a path is ignored by the include/exclude path settings.\n   *\n   * @param path - The path to check.\n   * @param isFolder - Whether the path is a folder. Only a folder-only glob (one ending in `/`) reads it: such a glob\n   * always matches the contents of a matching folder, and matches the folder itself only when this is `true`.\n   * @returns `true` if the path is ignored, `false` otherwise.\n   */\n  public isPathIgnored(path: string, isFolder = false): boolean {\n    return this._includePaths.isPathIgnored(path, isFolder) || this._excludePaths.isPathIgnored(path, isFolder);\n  }\n}\n\n/**\n * Validates include/exclude path entries, reporting the first entry that is not a valid regular expression or glob.\n *\n * An invalid entry does not throw when assigned to {@link PathSettings} — the whole list falls back to its default\n * pattern instead — so this validator is what surfaces the problem to the user. The message names the entry and the\n * reason it is invalid.\n *\n * @param paths - The path entries to validate.\n * @returns A message naming the first invalid entry, or nothing when every entry is valid.\n */\nexport function pathsValidator(paths: string[]): MaybeReturn<string> {\n  for (const path of paths) {\n    const { error } = compileEntry(path, NEVER_MATCHER);\n    if (error !== undefined) {\n      return error;\n    }\n  }\n}\n\nfunction compileEntry(entry: string, defaultMatcher: PathMatcher): CompileResult {\n  if (entry === '/') {\n    return { matcher: defaultMatcher };\n  }\n\n  if (REG_EXP_ENTRY_REG_EXP.test(entry)) {\n    const flagsSeparatorIndex = entry.lastIndexOf('/');\n    return compileRegExpEntry(entry, entry.slice(1, flagsSeparatorIndex), entry.slice(flagsSeparatorIndex + 1));\n  }\n\n  return hasUnescapedGlobCharacter(entry) ? compileGlobEntry(entry) : compilePlainPathEntry(entry);\n}\n\nfunction compileGlobEntry(glob: string): CompileResult {\n  const isFolderOnly = glob.endsWith('/');\n  const body = glob.replace(/\\/+$/, '');\n  const globSource = getGlobSource(body);\n  if (!globSource.isValid) {\n    return {\n      error: t(($) => $.obsidianDevUtils.pathSettings.invalidGlob, { glob, reason: globSource.error })\n    };\n  }\n  const { source } = globSource;\n\n  const prefix = body.includes('/') ? '^' : '(?:^|/)';\n\n  let selfRegExp: RegExp;\n  let contentsRegExp: RegExp;\n  try {\n    selfRegExp = new RegExp(`${prefix}${source}$`, CASE_INSENSITIVE_FLAG);\n    contentsRegExp = new RegExp(`${prefix}${source}/`, CASE_INSENSITIVE_FLAG);\n  } catch (error_) {\n    // An out-of-order character class range (`[z-a]`) is the one invalid glob only the engine can tell.\n    return {\n      error: t(($) => $.obsidianDevUtils.pathSettings.invalidGlob, { glob, reason: getRegExpErrorReason(error_) })\n    };\n  }\n\n  return {\n    matcher: {\n      isMatch: (path, isFolder) => contentsRegExp.test(path) || ((isFolder || !isFolderOnly) && selfRegExp.test(path))\n    }\n  };\n}\n\nfunction compilePlainPathEntry(path: string): CompileResult {\n  const unescapedPath = path.replaceAll(/\\\\(?<character>.)/gs, '$<character>').replace(/\\/+$/, '');\n  const regExp = new RegExp(`^${escapeRegExp(unescapedPath)}(?:/|$)`, CASE_INSENSITIVE_FLAG);\n  return {\n    matcher: {\n      isMatch: (pathToCheck) => regExp.test(pathToCheck)\n    }\n  };\n}\n\nfunction compileRegExpEntry(entry: string, source: string, flags: string): CompileResult {\n  let regExp: RegExp;\n  try {\n    // Compiled with the flags as written first, so an unknown or repeated flag is reported rather than ignored.\n    new RegExp(source, flags);\n    const effectiveFlags = flags.replaceAll(STATEFUL_FLAGS_REG_EXP, '');\n    regExp = new RegExp(source, effectiveFlags.includes(CASE_INSENSITIVE_FLAG) ? effectiveFlags : `${effectiveFlags}${CASE_INSENSITIVE_FLAG}`);\n  } catch (error) {\n    // A partially typed regex literal (`/^Inbox\\/`) is not parseable.\n    // Report it instead of throwing from a settings setter, which would break both the settings UI and the save path.\n    return {\n      error: t(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { reason: getRegExpErrorReason(error), regExp: entry })\n    };\n  }\n\n  return {\n    matcher: {\n      isMatch: (path) => regExp.test(path)\n    }\n  };\n}\n\nfunction escapeCharacterClassCharacter(character: string): string {\n  return /[-\\\\\\]^[]/.test(character) ? `\\\\${character}` : character;\n}\n\nfunction getCharacterClassSource(glob: string, openIndex: number): CharacterClassSourceResult {\n  let index = openIndex + 1;\n  let isNegated = false;\n  if (glob[index] === '!' || glob[index] === '^') {\n    isNegated = true;\n    index++;\n  }\n\n  let content = '';\n  if (glob[index] === ']') {\n    content += String.raw`\\]`;\n    index++;\n  }\n\n  while (index < glob.length) {\n    const character = glob.charAt(index);\n    if (character === ']') {\n      return {\n        endIndex: index + 1,\n        isValid: true,\n        source: `[${isNegated ? '^/' : ''}${content}]`\n      };\n    }\n\n    if (character === '\\\\') {\n      index++;\n      if (index >= glob.length) {\n        break;\n      }\n      content += escapeCharacterClassCharacter(glob.charAt(index));\n    } else {\n      content += character === '-' ? character : escapeCharacterClassCharacter(character);\n    }\n    index++;\n  }\n\n  return { error: t(($) => $.obsidianDevUtils.pathSettings.unclosedCharacterClass), isValid: false };\n}\n\nfunction getDefaultMatcher(type: PathSettingType): PathMatcher {\n  /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n  switch (type) {\n    /* v8 ignore stop */\n    case PathSettingType.Exclude: {\n      return NEVER_MATCHER;\n    }\n    case PathSettingType.Include: {\n      return ALWAYS_MATCHER;\n    }\n    default: {\n      /* v8 ignore start -- Exhaustive switch guard. */\n      assertNever(type);\n    }\n      /* v8 ignore stop */\n  }\n}\n\nfunction getGlobSource(glob: string): GlobSourceResult {\n  let source = '';\n  let index = 0;\n\n  while (index < glob.length) {\n    const character = glob.charAt(index);\n    switch (character) {\n      case '?': {\n        source += '[^/]';\n        index++;\n        break;\n      }\n      case '[': {\n        const characterClass = getCharacterClassSource(glob, index);\n        if (!characterClass.isValid) {\n          return characterClass;\n        }\n        source += characterClass.source;\n        index = characterClass.endIndex;\n        break;\n      }\n      case '*': {\n        if (!glob.startsWith(GLOBSTAR, index)) {\n          source += '[^/]*';\n          index++;\n          break;\n        }\n\n        const isSegmentStart = index === 0 || glob[index - 1] === '/';\n        if (isSegmentStart && glob.startsWith(GLOBSTAR_FOLDERS, index)) {\n          // `**/` is zero or more whole folders.\n          source += '(?:[^/]*/)*';\n          index += GLOBSTAR_FOLDERS.length;\n        } else if (isSegmentStart && index + GLOBSTAR.length === glob.length) {\n          // A trailing `/**` is everything inside the folder.\n          source += '.*';\n          index += GLOBSTAR.length;\n        } else {\n          // Any other `**` is an ordinary `*`, as in `.gitignore`.\n          source += '[^/]*';\n          index += GLOBSTAR.length;\n        }\n        break;\n      }\n      case '\\\\': {\n        index++;\n        if (index >= glob.length) {\n          return { error: t(($) => $.obsidianDevUtils.pathSettings.trailingEscape), isValid: false };\n        }\n        source += escapeRegExp(glob.charAt(index));\n        index++;\n        break;\n      }\n      default: {\n        source += escapeRegExp(character);\n        index++;\n        break;\n      }\n    }\n  }\n\n  return { isValid: true, source };\n}\n\nfunction getRegExpErrorReason(error: unknown): string {\n  /* v8 ignore start -- The RegExp constructor only ever throws a SyntaxError. */\n  const message = error instanceof Error ? error.message : String(error);\n  /* v8 ignore stop */\n  // V8 phrases it `Invalid regular expression: /<source>/<flags>: <reason>`; the entry is already named.\n  const match = /^Invalid regular expression: \\/.*\\/[a-z]*: (?<reason>.*)$/s.exec(message);\n  return match?.groups?.['reason'] ?? message;\n}\n\nfunction hasUnescapedGlobCharacter(entry: string): boolean {\n  for (let index = 0; index < entry.length; index++) {\n    const character = entry.charAt(index);\n    if (character === '\\\\') {\n      index++;\n    } else if (GLOB_CHARACTERS.has(character)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction makeMatchers(paths: string[], defaultMatcher: PathMatcher): null | PathMatcher[] {\n  if (paths.length === 0) {\n    return [defaultMatcher];\n  }\n\n  const matchers: PathMatcher[] = [];\n  for (const path of paths) {\n    const { matcher } = compileEntry(path, defaultMatcher);\n    if (!matcher) {\n      return null;\n    }\n    matchers.push(matcher);\n  }\n  return matchers;\n}\n"],"mappings":"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","names":[]}

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

@@ -48,13 +48,15 @@
  *
  * Payload validation is opt-in per method through {@link https://standardschema.dev | Standard Schema}, so
  * zod / valibot / arktype / a hand-written validator all plug in and none of them is a dependency here. It
- * runs only while the `obsidian-dev-utils:PluginApi` debugger is enabled, so production pays nothing.
+ * runs only while the `obsidian-lib:validate-plugin-api-payloads` debug switch is on (off by default, see
+ * {@link getValidatePluginApiPayloadsDebugSwitch}), so production pays nothing. The `obsidian-dev-utils:PluginApi`
+ * debugger controls logging only: turning it on changes no behavior.
  *
  * The contract itself — its types and the schema builders — is not Obsidian-specific and lives in
  * `@mnaoumov/typescript-lib/api-contract` (`ApiContract`, `createArgumentsSchema`, `createTypeGuardSchema`,
  * `defineApiContract`). This module owns what is: the registry keyed by plugin id, the revocable handles, the
- * debug gate and the validation errors. A contract's KEYS drive the shape check that decides whether a published
- * record is usable at all; its schemas are only ever consulted while debugging.
+ * debug switch and the validation errors. A contract's KEYS drive the shape check that decides whether a published
+ * record is usable at all; its schemas are only ever consulted while the switch is on.
  *
  * Why the shape check is a `typeof` rather than a schema over the whole API object. In zod 4 `z.function()`
  * returns a function FACTORY, not a schema, so it cannot be a `z.object()` member directly. There is a known
@@ -62,12 +64,12 @@
  * `z.infer` types for a function member. It does not buy runtime validation here, though: `z.custom` is a
  * boolean predicate that returns its input unchanged, so the validating wrapper `implement` builds is
  * discarded and the check collapses back to "is it callable". Keeping that wrapper would need a further
- * `.transform()`, and would then move validation onto every call instead of behind the debug gate, and bind
+ * `.transform()`, and would then move validation onto every call instead of behind the debug switch, and bind
  * the contract to zod specifically — which is exactly what reaching through Standard Schema avoids. So the
  * declared method names are checked with `typeof`, and the payloads are validated per method instead.
  *
  * @remarks
- * Every plugin bundles its OWN copy of `obsidian-dev-utils`, so a registry record is a wire format between
+ * Every plugin bundles its OWN copy of this library (or of the older `obsidian-dev-utils`), so a registry record is a wire format between
  * different library versions and must stay backward-compatible forever. Nothing crossing it may be
  * `instanceof`-checked — reads are structural, and only plain data objects and plain functions are stored.
  *
@@ -81,6 +83,7 @@
  */
 import type { ApiContract, ApiMethodContract, ApiMethodName, ApiMethods, TypedApiContract } from '@mnaoumov/typescript-lib/api-contract';
 import type { AsyncEventSource } from '@mnaoumov/typescript-lib/async-events';
+import type { DebugSwitch } from '@mnaoumov/typescript-lib/debug-switches';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { App, Component, Plugin } from 'obsidian';
 /**
@@ -413,8 +416,8 @@ export declare class PluginApiRevokedError extends PluginApiUnavailableError {
 /**
  * Thrown when a published API's payload fails the schema its contract declares.
  *
- * Only ever thrown while the `obsidian-dev-utils:PluginApi` debugger is enabled — in production the methods
- * are not wrapped at all.
+ * Only ever thrown while the `obsidian-lib:validate-plugin-api-payloads` debug switch is on (see
+ * {@link getValidatePluginApiPayloadsDebugSwitch}) — otherwise no payload is validated at all.
  */
 export declare class PluginApiValidationError extends Error {
     /**
@@ -451,6 +454,20 @@ export declare class PluginApiValidationError extends Error {
  * @returns The API, or `null` when no live record satisfies the range and the contract.
  */
 export declare function findPluginApi<TApi extends object>(params: FindPluginApiParams<NoInfer<TApi>>): null | TApi;
+/**
+ * Gets the debug switch that decides whether a plugin-API call's payloads are validated against the contract.
+ *
+ * Its id is `obsidian-lib:validate-plugin-api-payloads` and it is off by default. While it is on, every call
+ * through a handle from {@link watchPluginApi} or {@link findPluginApi} checks its arguments and its return value
+ * against the method's declared schemas and throws a {@link PluginApiValidationError} on a mismatch. The
+ * `obsidian-dev-utils:PluginApi` debugger does not affect it: that only logs.
+ *
+ * The switch is registered on every read, which is idempotent, and whenever an API is published, watched or looked
+ * up, so a debug-settings UI lists it as soon as any plugin API is in play.
+ *
+ * @returns The debug switch.
+ */
+export declare function getValidatePluginApiPayloadsDebugSwitch(): DebugSwitch;
 /**
  * Publishes a plugin's API so other plugins can consume it, keyed by the plugin's `manifest.id` and revoked
  * automatically when the plugin unloads.