obsidian-dev-utils 88.6.0 → 88.8.0

package/dist/lib/cjs/script-utils/linters/markdownlint.cjs

@@ -136,6 +136,7 @@ var import_debug = require('../../debug.cjs');
 var import_obsidian_plugin_repo_paths = require('../../obsidian/plugin/obsidian-plugin-repo-paths.cjs');
 var import_path = require('../../path.cjs');
 var import_type_guards = require('../../type-guards.cjs');
+var import_git = require('../git.cjs');
 var import_obsidian_dev_utils_repo_paths = require('../obsidian-dev-utils-repo-paths.cjs');
 var import_root = require('../root.cjs');
 var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
@@ -181,13 +182,7 @@ async function lint(options) {
   const targets = paths?.length ? paths : [import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.CurrentFolder];
   await (0, import_root.execFromRoot)(["npx", "markdownlint-cli2", ...shouldFix ? ["--fix"] : [], { batchedArgs: targets }]);
   const rootFolder = (0, import_root.getRootFolder)() ?? process.cwd();
-  const mdFiles = paths?.length ? paths.map((p) => (0, import_node_path.relative)(rootFolder, p).replace(/\\/g, "/") || p) : await (0, import_async.toArray)((0, import_promises.glob)(["**/*.md"], {
-    exclude: [
-      ".git/**",
-      "dist/**",
-      "**/node_modules/**"
-    ]
-  }));
+  const mdFiles = paths?.length ? paths.map((p) => (0, import_node_path.relative)(rootFolder, p).replace(/\\/g, "/") || p) : await getMarkdownFiles();
   await (0, import_root.execFromRoot)([
     "npx",
     "linkinator",
@@ -204,8 +199,22 @@ async function lint(options) {
     { batchedArgs: mdFiles }
   ]);
 }
+const MARKDOWN_PATHSPEC = "*.md";
+async function getMarkdownFiles() {
+  const nonIgnoredFiles = await (0, import_git.getNonIgnoredFiles)({ patterns: [MARKDOWN_PATHSPEC] });
+  if (nonIgnoredFiles) {
+    return nonIgnoredFiles;
+  }
+  return await (0, import_async.toArray)((0, import_promises.glob)(["**/*.md"], {
+    exclude: [
+      ".git/**",
+      "dist/**",
+      "**/node_modules/**"
+    ]
+  }));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   lint
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/script-utils/linters/markdownlint.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (() => {\n      if (typeof __filename === 'string') {\n        const localRequire = require;\n        const url = localRequire('node:url');\n        if (typeof url.pathToFileURL === 'function') {\n          return url.pathToFileURL(__filename).href;\n        }\n      }\n\n      if (typeof window !== 'undefined') {\n        return activeWindow.location.href;\n      }\n\n      // Fallback to an empty string if the environment is unknown\n      return '';\n    })();\n/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob\n} from 'node:fs/promises';\nimport { relative } from 'node:path';\n\nimport { toArray } from '../../async.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport { ObsidianPluginRepoPaths } from '../../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  getFolderName,\n  join\n} from '../../path.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\nimport { ObsidianDevUtilsRepoPaths } from '../obsidian-dev-utils-repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * Optional file paths to lint. If omitted, lints the entire project.\n   */\n  readonly paths?: string[] | undefined;\n\n  /**\n   * Whether to fix linting issues automatically.\n   *\n   * @default `false`\n   */\n  readonly shouldFix?: boolean | undefined;\n}\n\n/**\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n *\n * @param options - The {@link LintOptions}.\n */\nexport async function lint(options?: LintOptions): Promise<void> {\n  const { paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigJsonc,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigYaml,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigCjs,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigMjs,\n    ObsidianPluginRepoPaths.MarkdownlintConfigJsonc,\n    ObsidianPluginRepoPaths.MarkdownlintConfigJson,\n    ObsidianPluginRepoPaths.MarkdownlintConfigYaml,\n    ObsidianPluginRepoPaths.MarkdownlintConfigYml,\n    ObsidianPluginRepoPaths.MarkdownlintConfigCjs,\n    ObsidianPluginRepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const configFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!configFileExist) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    const packageFolder = getRootFolder(getFolderName(import.meta.url));\n    assertNonNullable(packageFolder, 'Package folder not found');\n    await cp(\n      join(packageFolder, ObsidianDevUtilsRepoPaths.DistTemplates, ObsidianDevUtilsRepoPaths.MarkdownlintCli2ConfigMjs),\n      resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.MarkdownlintCli2ConfigMjs })\n    );\n  }\n\n  /* v8 ignore start -- The paths-provided branches are only exercised by consumer projects passing file lists. */\n  const targets = paths?.length ? paths : [ObsidianPluginRepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot(['npx', 'markdownlint-cli2', ...(shouldFix ? ['--fix'] : []), { batchedArgs: targets }]);\n\n  /* v8 ignore start -- The paths-provided branch is only exercised by consumer projects passing file lists. */\n  const rootFolder = getRootFolder() ?? process.cwd();\n  const mdFiles = paths?.length\n    ? paths.map((p) => relative(rootFolder, p).replace(/\\\\/g, '/') || p)\n    : await toArray(glob(['**/*.md'], {\n      exclude: [\n        '.git/**',\n        'dist/**',\n        '**/node_modules/**'\n      ]\n    }));\n  /* v8 ignore stop */\n  await execFromRoot([\n    'npx',\n    'linkinator',\n    '--retry',\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5',\n    '--url-rewrite-search',\n    'https://www\\\\.npmjs\\\\.com/package/',\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    { batchedArgs: mdFiles }\n  ]);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,qBAA2B;AAC3B,sBAGO;AACP,uBAAyB;AAEzB,mBAAwB;AACxB,mBAA+B;AAC/B,wCAAwC;AACxC,kBAGO;AACP,yBAAkC;AAClC,2CAA0C;AAC1C,kBAIO;AA1CP,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAM;AAC1D,MAAI,OAAO,eAAe,UAAU;AAClC,UAAM,eAAe;AACrB,UAAM,MAAM,aAAa,UAAU;AACnC,QAAI,OAAO,IAAI,kBAAkB,YAAY;AAC3C,aAAO,IAAI,cAAc,UAAU,EAAE;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,aAAa,SAAS;AAAA,EAC/B;AAGA,SAAO;AACT,GAAG;AAmDP,eAAsB,KAAK,SAAsC;AAC/D,QAAM,EAAE,OAAO,YAAY,MAAM,IAAI,WAAW,CAAC;AACjD,QAAM,cAAc;AAAA,IAClB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,EAC1B;AAEA,QAAM,kBAAkB,YAAY,KAAK,CAAC,eAAe;AACvD,UAAM,qBAAiB,qCAAwB,EAAE,MAAM,WAAW,CAAC;AACnE,eAAO,2BAAW,cAAc;AAAA,EAClC,CAAC;AAED,MAAI,CAAC,iBAAiB;AACpB,qCAAe,mBAAmB,EAAE,uEAAuE;AAC3G,UAAM,oBAAgB,+BAAc,2BAAc,iBAAe,CAAC;AAClE,8CAAkB,eAAe,0BAA0B;AAC3D,cAAM;AAAA,UACJ,kBAAK,eAAe,+DAA0B,eAAe,+DAA0B,yBAAyB;AAAA,UAChH,qCAAwB,EAAE,MAAM,0DAAwB,0BAA0B,CAAC;AAAA,IACrF;AAAA,EACF;AAGA,QAAM,UAAU,OAAO,SAAS,QAAQ,CAAC,0DAAwB,aAAa;AAE9E,YAAM,0BAAa,CAAC,OAAO,qBAAqB,GAAI,YAAY,CAAC,OAAO,IAAI,CAAC,GAAI,EAAE,aAAa,QAAQ,CAAC,CAAC;AAG1G,QAAM,iBAAa,2BAAc,KAAK,QAAQ,IAAI;AAClD,QAAM,UAAU,OAAO,SACnB,MAAM,IAAI,CAAC,UAAM,2BAAS,YAAY,CAAC,EAAE,QAAQ,OAAO,GAAG,KAAK,CAAC,IACjE,UAAM,0BAAQ,sBAAK,CAAC,SAAS,GAAG;AAAA,IAChC,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC,CAAC;AAEJ,YAAM,0BAAa;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,EAAE,aAAa,QAAQ;AAAA,EACzB,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/script-utils/linters/markdownlint.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (() => {\n      if (typeof __filename === 'string') {\n        const localRequire = require;\n        const url = localRequire('node:url');\n        if (typeof url.pathToFileURL === 'function') {\n          return url.pathToFileURL(__filename).href;\n        }\n      }\n\n      if (typeof window !== 'undefined') {\n        return activeWindow.location.href;\n      }\n\n      // Fallback to an empty string if the environment is unknown\n      return '';\n    })();\n/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob\n} from 'node:fs/promises';\nimport { relative } from 'node:path';\n\nimport { toArray } from '../../async.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport { ObsidianPluginRepoPaths } from '../../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  getFolderName,\n  join\n} from '../../path.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\nimport { getNonIgnoredFiles } from '../git.ts';\nimport { ObsidianDevUtilsRepoPaths } from '../obsidian-dev-utils-repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * Optional file paths to lint. If omitted, lints the entire project.\n   */\n  readonly paths?: string[] | undefined;\n\n  /**\n   * Whether to fix linting issues automatically.\n   *\n   * @default `false`\n   */\n  readonly shouldFix?: boolean | undefined;\n}\n\n/**\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n *\n * @param options - The {@link LintOptions}.\n */\nexport async function lint(options?: LintOptions): Promise<void> {\n  const { paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigJsonc,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigYaml,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigCjs,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigMjs,\n    ObsidianPluginRepoPaths.MarkdownlintConfigJsonc,\n    ObsidianPluginRepoPaths.MarkdownlintConfigJson,\n    ObsidianPluginRepoPaths.MarkdownlintConfigYaml,\n    ObsidianPluginRepoPaths.MarkdownlintConfigYml,\n    ObsidianPluginRepoPaths.MarkdownlintConfigCjs,\n    ObsidianPluginRepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const configFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!configFileExist) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    const packageFolder = getRootFolder(getFolderName(import.meta.url));\n    assertNonNullable(packageFolder, 'Package folder not found');\n    await cp(\n      join(packageFolder, ObsidianDevUtilsRepoPaths.DistTemplates, ObsidianDevUtilsRepoPaths.MarkdownlintCli2ConfigMjs),\n      resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.MarkdownlintCli2ConfigMjs })\n    );\n  }\n\n  /* v8 ignore start -- The paths-provided branches are only exercised by consumer projects passing file lists. */\n  const targets = paths?.length ? paths : [ObsidianPluginRepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot(['npx', 'markdownlint-cli2', ...(shouldFix ? ['--fix'] : []), { batchedArgs: targets }]);\n\n  /* v8 ignore start -- The paths-provided branch is only exercised by consumer projects passing file lists. */\n  const rootFolder = getRootFolder() ?? process.cwd();\n  const mdFiles = paths?.length\n    ? paths.map((p) => relative(rootFolder, p).replace(/\\\\/g, '/') || p)\n    : await getMarkdownFiles();\n  /* v8 ignore stop */\n  await execFromRoot([\n    'npx',\n    'linkinator',\n    '--retry',\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5',\n    '--url-rewrite-search',\n    'https://www\\\\.npmjs\\\\.com/package/',\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    { batchedArgs: mdFiles }\n  ]);\n}\n\n/**\n * The git pathspec matching every markdown file in the repository, at any depth.\n */\nconst MARKDOWN_PATHSPEC = '*.md';\n\n/**\n * Lists the markdown files to hand to `linkinator`.\n *\n * `linkinator` takes a file list rather than an ignore configuration, so the gitignored files have to be\n * dropped before it is invoked. Git itself answers that (nested ignore files, `!` negations and all); the\n * hand-maintained glob exclusions below are only the fallback for a checkout without git, and they are the\n * very lists this indirection exists to stop from drifting.\n *\n * @returns A {@link Promise} that resolves with the markdown file paths, relative to the root folder.\n */\nasync function getMarkdownFiles(): Promise<string[]> {\n  const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });\n  if (nonIgnoredFiles) {\n    return nonIgnoredFiles;\n  }\n\n  return await toArray(glob(['**/*.md'], {\n    exclude: [\n      '.git/**',\n      'dist/**',\n      '**/node_modules/**'\n    ]\n  }));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,qBAA2B;AAC3B,sBAGO;AACP,uBAAyB;AAEzB,mBAAwB;AACxB,mBAA+B;AAC/B,wCAAwC;AACxC,kBAGO;AACP,yBAAkC;AAClC,iBAAmC;AACnC,2CAA0C;AAC1C,kBAIO;AA3CP,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAM;AAC1D,MAAI,OAAO,eAAe,UAAU;AAClC,UAAM,eAAe;AACrB,UAAM,MAAM,aAAa,UAAU;AACnC,QAAI,OAAO,IAAI,kBAAkB,YAAY;AAC3C,aAAO,IAAI,cAAc,UAAU,EAAE;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,aAAa,SAAS;AAAA,EAC/B;AAGA,SAAO;AACT,GAAG;AAoDP,eAAsB,KAAK,SAAsC;AAC/D,QAAM,EAAE,OAAO,YAAY,MAAM,IAAI,WAAW,CAAC;AACjD,QAAM,cAAc;AAAA,IAClB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,IACxB,0DAAwB;AAAA,EAC1B;AAEA,QAAM,kBAAkB,YAAY,KAAK,CAAC,eAAe;AACvD,UAAM,qBAAiB,qCAAwB,EAAE,MAAM,WAAW,CAAC;AACnE,eAAO,2BAAW,cAAc;AAAA,EAClC,CAAC;AAED,MAAI,CAAC,iBAAiB;AACpB,qCAAe,mBAAmB,EAAE,uEAAuE;AAC3G,UAAM,oBAAgB,+BAAc,2BAAc,iBAAe,CAAC;AAClE,8CAAkB,eAAe,0BAA0B;AAC3D,cAAM;AAAA,UACJ,kBAAK,eAAe,+DAA0B,eAAe,+DAA0B,yBAAyB;AAAA,UAChH,qCAAwB,EAAE,MAAM,0DAAwB,0BAA0B,CAAC;AAAA,IACrF;AAAA,EACF;AAGA,QAAM,UAAU,OAAO,SAAS,QAAQ,CAAC,0DAAwB,aAAa;AAE9E,YAAM,0BAAa,CAAC,OAAO,qBAAqB,GAAI,YAAY,CAAC,OAAO,IAAI,CAAC,GAAI,EAAE,aAAa,QAAQ,CAAC,CAAC;AAG1G,QAAM,iBAAa,2BAAc,KAAK,QAAQ,IAAI;AAClD,QAAM,UAAU,OAAO,SACnB,MAAM,IAAI,CAAC,UAAM,2BAAS,YAAY,CAAC,EAAE,QAAQ,OAAO,GAAG,KAAK,CAAC,IACjE,MAAM,iBAAiB;AAE3B,YAAM,0BAAa;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,EAAE,aAAa,QAAQ;AAAA,EACzB,CAAC;AACH;AAKA,MAAM,oBAAoB;AAY1B,eAAe,mBAAsC;AACnD,QAAM,kBAAkB,UAAM,+BAAmB,EAAE,UAAU,CAAC,iBAAiB,EAAE,CAAC;AAClF,MAAI,iBAAiB;AACnB,WAAO;AAAA,EACT;AAEA,SAAO,UAAM,0BAAQ,sBAAK,CAAC,SAAS,GAAG;AAAA,IACrC,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC,CAAC;AACJ;",
  "names": []
}


package/dist/lib/cjs/script-utils/nano-staged-config.cjs

@@ -139,8 +139,8 @@ __export(nano_staged_config_exports, {
   obsidianDevUtilsConfig: () => obsidianDevUtilsConfig
 });
 module.exports = __toCommonJS(nano_staged_config_exports);
-var import_node_fs = require('node:fs');
 var import_node_process = __toESM(__extractDefault(require('node:process')), 1);
+var import_env_toggle = require('./env-toggle.cjs');
 const obsidianDevUtilsConfig = {
   /*
    * Lint everything except the `templates/` consumer templates: ESLint globally ignores them, and
@@ -161,23 +161,19 @@ const obsidianDevUtilsConfig = {
     "npm run lint:md:fix --"
   ]
 };
-const NANO_STAGED_OFF_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+const NANO_STAGED_ENV_VARIABLE = "NANO_STAGED";
 function getNanoStagedConfig() {
-  if ((0, import_node_fs.existsSync)(".env")) {
-    import_node_process.default.loadEnvFile(".env");
-  }
-  if (isNanoStagedDisabled(import_node_process.default.env["NANO_STAGED"])) {
-    import_node_process.default.stdout.write("nano-staged: skipped (NANO_STAGED is off).\n");
+  (0, import_env_toggle.loadEnvFileIfExists)();
+  if ((0, import_env_toggle.isEnvVariableOff)(NANO_STAGED_ENV_VARIABLE)) {
+    import_node_process.default.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).
+`);
     import_node_process.default.exit(0);
   }
   return obsidianDevUtilsConfig;
 }
-function isNanoStagedDisabled(value) {
-  return NANO_STAGED_OFF_VALUES.has((value ?? "").trim().toLowerCase());
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getNanoStagedConfig,
   obsidianDevUtilsConfig
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9uYW5vLXN0YWdlZC1jb25maWcudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBTaGFyZWQgbmFuby1zdGFnZWQgY29uZmlndXJhdGlvbiBmb3IgcHJlLWNvbW1pdCBob29rcy5cbiAqL1xuXG5pbXBvcnQgcHJvY2VzcyBmcm9tICdub2RlOnByb2Nlc3MnO1xuXG5pbXBvcnQge1xuICBpc0VudlZhcmlhYmxlT2ZmLFxuICBsb2FkRW52RmlsZUlmRXhpc3RzXG59IGZyb20gJy4vZW52LXRvZ2dsZS50cyc7XG5cbi8qKlxuICogTmFuby1zdGFnZWQgY29uZmlndXJhdGlvbiB0aGF0IHJ1bnMgZmlsZS1iYXNlZCBsaW50LCBmb3JtYXQsIGFuZCBzcGVsbGNoZWNrIG9uIHN0YWdlZCBmaWxlcy5cbiAqXG4gKiBPbmx5IGluY2x1ZGVzIHRvb2xzIHRoYXQgY2FuIG9wZXJhdGUgb24gaW5kaXZpZHVhbCBmaWxlcy4gV2hvbGUtcHJvamVjdCBjaGVja3NcbiAqIChUeXBlU2NyaXB0IGNvbXBpbGF0aW9uLCB1bml0IHRlc3RzKSBhcmUgbGVmdCB0byBDSS5cbiAqXG4gKiBDb21tYW5kcyB1c2UgYG5wbSBydW4gLi4uIC0tYCBzbyBuYW5vLXN0YWdlZCBmaWxlIHBhdGhzIGFyZSBmb3J3YXJkZWQgYXMgQ0xJIGFyZ3VtZW50cy5cbiAqL1xuZXhwb3J0IGNvbnN0IG9ic2lkaWFuRGV2VXRpbHNDb25maWc6IFJlY29yZDxzdHJpbmcsIHN0cmluZ1tdPiA9IHtcbiAgLypcbiAgICogTGludCBldmVyeXRoaW5nIGV4Y2VwdCB0aGUgYHRlbXBsYXRlcy9gIGNvbnN1bWVyIHRlbXBsYXRlczogRVNMaW50IGdsb2JhbGx5IGlnbm9yZXMgdGhlbSwgYW5kXG4gICAqIHRoZXkgc2hpcCB0aGVpciBvd24gY29uc3VtZXItZmFjaW5nIGNvbmZpZy9zY3JpcHRzIHRoYXQgY2Fubm90IHJlc29sdmUgaW4tcmVwbywgc28gcGFzc2luZyBvbmVcbiAgICogYnkgZXhwbGljaXQgcGF0aCBlcnJvcnMgb3V0LiBUaGUgYCEodGVtcGxhdGVzKWAgbmVnYXRpb24gZHJvcHMgYW55IHBhdGggdGhhdCBiZWdpbnMgd2l0aFxuICAgKiBgdGVtcGxhdGVzYC4gRm9ybWF0dGluZyBhbmQgc3BlbGxjaGVja2luZyBzdGlsbCBjb3ZlciBgdGVtcGxhdGVzL2AgdmlhIHRoZSBlbnRyaWVzIGFib3ZlIGFuZCBiZWxvdy5cbiAgICovXG4gICchKHRlbXBsYXRlcykqLnt0cyx0c3gsbXRzfSc6IFtcbiAgICAnbnBtIHJ1biBsaW50OmZpeCAtLSdcbiAgXSxcbiAgJyonOiBbXG4gICAgJ25wbSBydW4gc3BlbGxjaGVjayAtLSdcbiAgXSxcbiAgJyoue3RzLHRzeCxtdHN9JzogW1xuICAgICducG0gcnVuIGZvcm1hdCAtLSdcbiAgXSxcbiAgJyoubWQnOiBbXG4gICAgJ25wbSBydW4gbGludDptZDpmaXggLS0nXG4gIF1cbn07XG5cbmNvbnN0IE5BTk9fU1RBR0VEX0VOVl9WQVJJQUJMRSA9ICdOQU5PX1NUQUdFRCc7XG5cbi8qKlxuICogUmVzb2x2ZXMgdGhlIG5hbm8tc3RhZ2VkIGNvbmZpZ3VyYXRpb24gdG8gdXNlLCBob25vcmluZyBhIHBlci1kZXZlbG9wZXIgb3B0LW91dC5cbiAqXG4gKiBMb2FkcyBhIGdpdGlnbm9yZWQgYC5lbnZgIGlmIHByZXNlbnQsIHRoZW4gXHUyMDE0IHdoZW4gYE5BTk9fU1RBR0VEYCBpcyBzZXQgdG8gYW4gb2ZmIHZhbHVlIChgMGAsIGBmYWxzZWAsXG4gKiBgb2ZmYCwgb3IgYG5vYCkgXHUyMDE0IHByaW50cyBhIG5vdGljZSBhbmQgZXhpdHMgdGhlIHByb2Nlc3Mgc3VjY2Vzc2Z1bGx5IHNvIHRoZSBwcmUtY29tbWl0IGNoZWNrcyBhcmVcbiAqIHNraXBwZWQuIFRoaXMgbWlycm9ycyBodXNreSdzIG93biBgSFVTS1k9MGAgc3dpdGNoLCBidXQgc2NvcGVkIHRvIHRoZSBuYW5vLXN0YWdlZCBzdGVwIChzbyB0aGVcbiAqIGNvbW1pdC1tc2cgaG9vayBzdGlsbCBydW5zKS4gT3RoZXJ3aXNlIGl0IHJldHVybnMge0BsaW5rIG9ic2lkaWFuRGV2VXRpbHNDb25maWd9LlxuICpcbiAqIGBOQU5PX1NUQUdFRGAgaXMgbm90IGFuIG5wbSBzY3JpcHQsIHNvIGl0IGNhcnJpZXMgaXRzIG93biBzd2l0Y2ggcmF0aGVyIHRoYW4gdGhlIHNjcmlwdC1uYW1lLWRlcml2ZWQgb25lXG4gKiBldmVyeSBucG0gc2NyaXB0IGdldHMgXHUyMDE0IGJ1dCBib3RoIHNoYXJlIHRoZSBzYW1lIG5vdGlvbiBvZiBhbiBvZmYgdmFsdWUsIHZpYSB7QGxpbmsgaXNFbnZWYXJpYWJsZU9mZn0uXG4gKlxuICogVGhpcyBpcyBhIGZ1bmN0aW9uIHJhdGhlciB0aGFuIG1vZHVsZS1sZXZlbCBjb2RlIHNvIGltcG9ydGluZyB0aGUgcGFja2FnZSBiYXJyZWwgbmV2ZXIgdHJpZ2dlcnMgdGhlXG4gKiBgLmVudmAgcmVhZCBvciB0aGUgcHJvY2VzcyBleGl0OyBjYWxsIGl0IGZyb20gdGhlIHRoaW4gYHNjcmlwdHMvbmFuby1zdGFnZWQtY29uZmlnLnRzYCBlbnRyeS5cbiAqXG4gKiBAcmV0dXJucyBUaGUgbmFuby1zdGFnZWQgdGFzayBjb25maWd1cmF0aW9uLiBEb2VzIG5vdCByZXR1cm4gd2hlbiB0aGUgb3B0LW91dCBpcyBhY3RpdmUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXROYW5vU3RhZ2VkQ29uZmlnKCk6IFJlY29yZDxzdHJpbmcsIHN0cmluZ1tdPiB7XG4gIGxvYWRFbnZGaWxlSWZFeGlzdHMoKTtcblxuICBpZiAoaXNFbnZWYXJpYWJsZU9mZihOQU5PX1NUQUdFRF9FTlZfVkFSSUFCTEUpKSB7XG4gICAgcHJvY2Vzcy5zdGRvdXQud3JpdGUoYG5hbm8tc3RhZ2VkOiBza2lwcGVkICgke05BTk9fU1RBR0VEX0VOVl9WQVJJQUJMRX0gaXMgb2ZmKS5cXG5gKTtcbiAgICBwcm9jZXNzLmV4aXQoMCk7XG4gIH1cblxuICByZXR1cm4gb2JzaWRpYW5EZXZVdGlsc0NvbmZpZztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQU1BLDBCQUFvQjtBQUVwQix3QkFHTztBQVVBLE1BQU0seUJBQW1EO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPOUQsOEJBQThCO0FBQUEsSUFDNUI7QUFBQSxFQUNGO0FBQUEsRUFDQSxLQUFLO0FBQUEsSUFDSDtBQUFBLEVBQ0Y7QUFBQSxFQUNBLGtCQUFrQjtBQUFBLElBQ2hCO0FBQUEsRUFDRjtBQUFBLEVBQ0EsUUFBUTtBQUFBLElBQ047QUFBQSxFQUNGO0FBQ0Y7QUFFQSxNQUFNLDJCQUEyQjtBQWtCMUIsU0FBUyxzQkFBZ0Q7QUFDOUQsNkNBQW9CO0FBRXBCLFVBQUksb0NBQWlCLHdCQUF3QixHQUFHO0FBQzlDLHdCQUFBQSxRQUFRLE9BQU8sTUFBTSx5QkFBeUIsd0JBQXdCO0FBQUEsQ0FBYTtBQUNuRix3QkFBQUEsUUFBUSxLQUFLLENBQUM7QUFBQSxFQUNoQjtBQUVBLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFsicHJvY2VzcyJdCn0K

package/dist/lib/cjs/script-utils/nano-staged-config.d.cts

@@ -16,11 +16,13 @@ export declare const obsidianDevUtilsConfig: Record<string, string[]>;
 /**
  * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.
  *
- * Loads a gitignored `.env` if present (via Node's own `process.loadEnvFile`, so it behaves the same
- * on every platform and shell), then — when `NANO_STAGED` is set to an off value (`0`, `false`, `off`,
- * or `no`) — prints a notice and exits the process successfully so the pre-commit checks are skipped.
- * This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the commit-msg
- * hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}.
+ * Loads a gitignored `.env` if present, then — when `NANO_STAGED` is set to an off value (`0`, `false`,
+ * `off`, or `no`) — prints a notice and exits the process successfully so the pre-commit checks are
+ * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the
+ * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}.
+ *
+ * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one
+ * every npm script gets — but both share the same notion of an off value, via {@link isEnvVariableOff}.
  *
  * This is a function rather than module-level code so importing the package barrel never triggers the
  * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry.

package/dist/lib/cjs/script-utils/test-runners/index.cjs

@@ -136,14 +136,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var test_runners_exports = {};
 __export(test_runners_exports, {
   "integration-test-plugin": () => integration_test_plugin,
-  vitest: () => vitest
+  vitest: () => vitest,
+  "vitest-config": () => vitest_config
 });
 module.exports = __toCommonJS(test_runners_exports);
 var integration_test_plugin = __toESM(__extractDefault(require('./integration-test-plugin.cjs')), 1);
+var vitest_config = __toESM(__extractDefault(require('./vitest-config.cjs')), 1);
 var vitest = __toESM(__extractDefault(require('./vitest.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "integration-test-plugin": null,
-  vitest
+  vitest,
+  "vitest-config": null
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy90ZXN0LXJ1bm5lcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4nIGZyb20gJy4vaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ3ZpdGVzdCcgZnJvbSAnLi92aXRlc3QudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBLG1DQUFBQTtBQUFBLEVBQUE7QUFBQTtBQUFBO0FBRUEsSUFBQUEsMEJBQTJDO0FBQzNDLGFBQTBCOyIsCiAgIm5hbWVzIjogWyJpbnRlZ3JhdGlvbi10ZXN0LXBsdWdpbiJdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy90ZXN0LXJ1bm5lcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4nIGZyb20gJy4vaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ3ZpdGVzdC1jb25maWcnIGZyb20gJy4vdml0ZXN0LWNvbmZpZy50cyc7XG5leHBvcnQgKiBhcyAndml0ZXN0JyBmcm9tICcuL3ZpdGVzdC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUEsbUNBQUFBO0FBQUEsRUFBQTtBQUFBLHlCQUFBQztBQUFBO0FBQUE7QUFFQSxJQUFBRCwwQkFBMkM7QUFDM0MsSUFBQUMsZ0JBQWlDO0FBQ2pDLGFBQTBCOyIsCiAgIm5hbWVzIjogWyJpbnRlZ3JhdGlvbi10ZXN0LXBsdWdpbiIsICJ2aXRlc3QtY29uZmlnIl0KfQo=

package/dist/lib/cjs/script-utils/test-runners/index.d.cts

@@ -1,3 +1,4 @@
 /// <reference path="../../library.d.cts" />
 export * as 'integration-test-plugin' from './integration-test-plugin.cjs';
+export * as 'vitest-config' from './vitest-config.cjs';
 export * as 'vitest' from './vitest.cjs';

package/dist/lib/cjs/script-utils/test-runners/vitest-config.cjs

@@ -0,0 +1,328 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vitest_config_exports = {};
+__export(vitest_config_exports, {
+  ObsidianPluginVitestConfigContext: () => ObsidianPluginVitestConfigContext,
+  defineObsidianPluginVitestConfig: () => defineObsidianPluginVitestConfig
+});
+module.exports = __toCommonJS(vitest_config_exports);
+var import_node_process = __toESM(__extractDefault(require('node:process')), 1);
+var import_config = require('vitest/config');
+const ANDROID_TIMEOUT_IN_MILLISECONDS = 6e4;
+const BIG_TIMEOUT_IN_MILLISECONDS = 3e4;
+const HOOK_TIMEOUT_MULTIPLIER = 4;
+const PERFORMANCE_TIMEOUT_IN_MILLISECONDS = 6e5;
+const ANDROID_TEST_FILES = "src/**/*.android.integration.test.ts";
+const CROSS_PLATFORM_TEST_FILES = "src/**/*.cross-platform.integration.test.ts";
+const DESKTOP_PERFORMANCE_TEST_FILES = "src/**/*.desktop-performance.integration.test.ts";
+const DESKTOP_TEST_FILES = "src/**/*.desktop.integration.test.ts";
+const INTEGRATION_TEST_FILES = "src/**/*.integration.test.ts";
+const NO_APP_TEST_FILES = "src/**/*.no-app.integration.test.ts";
+const UNIT_TEST_FILES = "src/**/*.test.ts";
+const OBSIDIAN_VERSION_ENV_VARIABLE_NAME = "OBSIDIAN_VERSION";
+const SHARED_EXCLUDE = ["node_modules", "dist"];
+class ObsidianPluginVitestConfigContext {
+  /**
+   * The `integration-tests:android` project, running the mobile-only and cross-platform suites against an
+   * Android emulator through Appium.
+   */
+  android = {
+    environment: "node",
+    environmentOptions: {
+      obsidianTransport: {
+        appiumUrl: "http://localhost:4723",
+        avdName: "obsidian_test",
+        type: "obsidian-android-appium"
+      }
+    },
+    fileParallelism: false,
+    globalSetup: ["obsidian-integration-testing/vitest-global-setup-plugin"],
+    hookTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,
+    include: [ANDROID_TEST_FILES, CROSS_PLATFORM_TEST_FILES],
+    name: "integration-tests:android",
+    setupFiles: ["obsidian-integration-testing/vitest-setup"],
+    testTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS
+  };
+  /**
+   * The per-test budget of the Android integration project, in milliseconds. Booting an emulator and
+   * driving it over Appium is slower than the desktop path, hence its own constant.
+   *
+   * @default `60000`
+   */
+  androidTimeoutInMilliseconds = ANDROID_TIMEOUT_IN_MILLISECONDS;
+  /**
+   * The per-test budget of the regular integration projects, in milliseconds.
+   *
+   * @default `30000`
+   */
+  bigTimeoutInMilliseconds = BIG_TIMEOUT_IN_MILLISECONDS;
+  /**
+   * The coverage `exclude` globs. Push onto it to drop more files from the coverage report.
+   */
+  coverageExclude = [UNIT_TEST_FILES];
+  /**
+   * The `integration-tests:desktop` project, running the desktop-only and cross-platform suites against a
+   * real desktop Obsidian over CDP.
+   */
+  desktop = {
+    environment: "node",
+    fileParallelism: false,
+    globalSetup: ["obsidian-integration-testing/vitest-global-setup-plugin"],
+    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,
+    include: [DESKTOP_TEST_FILES, CROSS_PLATFORM_TEST_FILES],
+    name: "integration-tests:desktop",
+    setupFiles: ["obsidian-integration-testing/vitest-setup"],
+    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS
+  };
+  /**
+   * The `integration-tests:desktop-performance` project, running the at-scale suites. It is declared for
+   * every plugin even when there is no such suite yet — `passWithNoTests` makes an empty project free,
+   * and the matching `test:integration:desktop:performance` script exists fleet-wide.
+   */
+  desktopPerformance = {
+    environment: "node",
+    fileParallelism: false,
+    globalSetup: ["obsidian-integration-testing/vitest-global-setup-plugin"],
+    hookTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS,
+    include: [DESKTOP_PERFORMANCE_TEST_FILES],
+    name: "integration-tests:desktop-performance",
+    setupFiles: ["obsidian-integration-testing/vitest-setup"],
+    testTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS
+  };
+  /**
+   * The multiplier applied to a project's test budget to get its hook budget. A hook typically populates
+   * and opens a vault, so it needs several times what a single test does.
+   *
+   * @default `4`
+   */
+  hookTimeoutMultiplier = HOOK_TIMEOUT_MULTIPLIER;
+  /**
+   * The `integration-tests:no-app` project, running the suites that need no Obsidian instance at all.
+   */
+  noApp = {
+    environment: "node",
+    fileParallelism: false,
+    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,
+    include: [NO_APP_TEST_FILES],
+    name: "integration-tests:no-app",
+    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS
+  };
+  /**
+   * The per-test budget of the performance integration project, in milliseconds. A performance vault is
+   * pre-populated with tens of thousands of notes before Obsidian opens, so both its setup and its tests
+   * need far more time than the regular integration projects.
+   *
+   * @default `600000`
+   */
+  performanceTimeoutInMilliseconds = PERFORMANCE_TIMEOUT_IN_MILLISECONDS;
+  /**
+   * The `unit-tests` project, running the mocked-Obsidian suites in `jsdom`.
+   */
+  unitTests = {
+    environment: "jsdom",
+    exclude: [...SHARED_EXCLUDE, INTEGRATION_TEST_FILES],
+    execArgv: ["--no-webstorage"],
+    include: [UNIT_TEST_FILES],
+    name: "unit-tests",
+    server: {
+      deps: {
+        inline: ["@obsidian-typings", "obsidian-dev-utils"]
+      }
+    },
+    setupFiles: [
+      "obsidian-test-mocks/vitest-setup",
+      "obsidian-test-mocks/obsidian-typings/vitest-setup",
+      "obsidian-dev-utils/vitest-setup"
+    ]
+  };
+  /**
+   * Creates a new context seeded with the standard projects.
+   */
+  constructor() {
+    const obsidianVersion = import_node_process.default.env[OBSIDIAN_VERSION_ENV_VARIABLE_NAME];
+    if (obsidianVersion !== void 0) {
+      this.desktop.environmentOptions = {
+        obsidianTransport: {
+          obsidianVersion,
+          type: "obsidian-cdp"
+        }
+      };
+    }
+  }
+}
+function defineObsidianPluginVitestConfig(options = {}) {
+  const context = new ObsidianPluginVitestConfigContext();
+  if (options.editContext) {
+    options.editContext(context);
+  }
+  const customProjects = options.customProjects?.(context) ?? [];
+  return (0, import_config.defineConfig)({
+    test: {
+      coverage: {
+        exclude: context.coverageExclude,
+        include: ["src/**/*.ts"],
+        provider: "v8",
+        reporter: ["text", "lcov", "html"],
+        reportsDirectory: "./coverage"
+      },
+      exclude: [...SHARED_EXCLUDE],
+      globals: false,
+      include: [UNIT_TEST_FILES],
+      passWithNoTests: true,
+      projects: [
+        {
+          resolve: {
+            alias: {
+              obsidian: "obsidian-test-mocks/obsidian"
+            }
+          },
+          test: context.unitTests
+        },
+        { test: context.noApp },
+        { test: context.desktop },
+        { test: context.desktopPerformance },
+        { test: context.android },
+        ...customProjects
+      ]
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObsidianPluginVitestConfigContext,
+  defineObsidianPluginVitestConfig
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/script-utils/test-runners/vitest-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared vitest configuration for Obsidian plugins.\n *\n * Every plugin in the workspace declares the same five vitest projects \u2014 `unit-tests` plus the\n * `integration-tests:{no-app,desktop,desktop-performance,android}` family \u2014 with the same timeouts,\n * `setupFiles`, and `globalSetup` wiring. Maintaining that per repo means a convention change costs one\n * near-identical edit per plugin, and any repo that is missed drifts silently. This module owns that\n * configuration once, so a plugin's `scripts/vitest-config.ts` collapses to a single call.\n *\n * The seam mirrors {@link https://www.npmjs.com/package/obsidian-dev-utils | the ESLint one}\n * (`defineEslintConfigs`): the factory builds a context holding the standard projects, the caller edits\n * it in place through {@link DefineObsidianPluginVitestConfigOptions.editContext}, and appends any\n * project the base does not know about through\n * {@link DefineObsidianPluginVitestConfigOptions.customProjects}.\n */\n\nimport type {\n  TestProjectConfiguration,\n  TestProjectInlineConfiguration,\n  ViteUserConfig\n} from 'vitest/config';\n\nimport process from 'node:process';\nimport { defineConfig } from 'vitest/config';\n\n/**\n * The `test` section of a single vitest project entry.\n */\nexport type ObsidianPluginVitestProjectConfig = NonNullable<TestProjectInlineConfiguration['test']>;\n\nconst ANDROID_TIMEOUT_IN_MILLISECONDS = 60_000;\nconst BIG_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst HOOK_TIMEOUT_MULTIPLIER = 4;\nconst PERFORMANCE_TIMEOUT_IN_MILLISECONDS = 600_000;\n\nconst ANDROID_TEST_FILES = 'src/**/*.android.integration.test.ts';\nconst CROSS_PLATFORM_TEST_FILES = 'src/**/*.cross-platform.integration.test.ts';\nconst DESKTOP_PERFORMANCE_TEST_FILES = 'src/**/*.desktop-performance.integration.test.ts';\nconst DESKTOP_TEST_FILES = 'src/**/*.desktop.integration.test.ts';\nconst INTEGRATION_TEST_FILES = 'src/**/*.integration.test.ts';\nconst NO_APP_TEST_FILES = 'src/**/*.no-app.integration.test.ts';\nconst UNIT_TEST_FILES = 'src/**/*.test.ts';\n\nconst OBSIDIAN_VERSION_ENV_VARIABLE_NAME = 'OBSIDIAN_VERSION';\nconst SHARED_EXCLUDE = ['node_modules', 'dist'];\n\n/**\n * The options for defining a plugin's vitest configuration.\n */\nexport interface DefineObsidianPluginVitestConfigOptions {\n  /**\n   * A function that builds projects the base configuration does not know about, such as a plugin's own\n   * `integration-tests:demo-vault` project. The returned projects are appended after the standard five.\n   *\n   * @param context - The vitest configuration context.\n   * @returns The extra projects.\n   */\n  customProjects?(context: ObsidianPluginVitestConfigContext): TestProjectConfiguration[];\n\n  /**\n   * A function that edits the vitest configuration context before it is assembled into a configuration.\n   *\n   * @param context - The vitest configuration context.\n   */\n  editContext?(context: ObsidianPluginVitestConfigContext): void;\n}\n\n/**\n * The context for defining a plugin's vitest configuration.\n *\n * Every member is live: the arrays and objects it exposes are the very ones the assembled configuration\n * is built from, so editing them in place through\n * {@link DefineObsidianPluginVitestConfigOptions.editContext} is what customizes the result.\n */\nexport class ObsidianPluginVitestConfigContext {\n  /**\n   * The `integration-tests:android` project, running the mobile-only and cross-platform suites against an\n   * Android emulator through Appium.\n   */\n  public readonly android: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    environmentOptions: {\n      obsidianTransport: {\n        appiumUrl: 'http://localhost:4723',\n        avdName: 'obsidian_test',\n        type: 'obsidian-android-appium'\n      }\n    },\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [ANDROID_TEST_FILES, CROSS_PLATFORM_TEST_FILES],\n    name: 'integration-tests:android',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The per-test budget of the Android integration project, in milliseconds. Booting an emulator and\n   * driving it over Appium is slower than the desktop path, hence its own constant.\n   *\n   * @default `60000`\n   */\n  public readonly androidTimeoutInMilliseconds = ANDROID_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The per-test budget of the regular integration projects, in milliseconds.\n   *\n   * @default `30000`\n   */\n  public readonly bigTimeoutInMilliseconds = BIG_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The coverage `exclude` globs. Push onto it to drop more files from the coverage report.\n   */\n  public readonly coverageExclude: string[] = [UNIT_TEST_FILES];\n\n  /**\n   * The `integration-tests:desktop` project, running the desktop-only and cross-platform suites against a\n   * real desktop Obsidian over CDP.\n   */\n  public readonly desktop: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [DESKTOP_TEST_FILES, CROSS_PLATFORM_TEST_FILES],\n    name: 'integration-tests:desktop',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The `integration-tests:desktop-performance` project, running the at-scale suites. It is declared for\n   * every plugin even when there is no such suite yet \u2014 `passWithNoTests` makes an empty project free,\n   * and the matching `test:integration:desktop:performance` script exists fleet-wide.\n   */\n  public readonly desktopPerformance: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS,\n    include: [DESKTOP_PERFORMANCE_TEST_FILES],\n    name: 'integration-tests:desktop-performance',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The multiplier applied to a project's test budget to get its hook budget. A hook typically populates\n   * and opens a vault, so it needs several times what a single test does.\n   *\n   * @default `4`\n   */\n  public readonly hookTimeoutMultiplier = HOOK_TIMEOUT_MULTIPLIER;\n\n  /**\n   * The `integration-tests:no-app` project, running the suites that need no Obsidian instance at all.\n   */\n  public readonly noApp: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [NO_APP_TEST_FILES],\n    name: 'integration-tests:no-app',\n    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The per-test budget of the performance integration project, in milliseconds. A performance vault is\n   * pre-populated with tens of thousands of notes before Obsidian opens, so both its setup and its tests\n   * need far more time than the regular integration projects.\n   *\n   * @default `600000`\n   */\n  public readonly performanceTimeoutInMilliseconds = PERFORMANCE_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The `unit-tests` project, running the mocked-Obsidian suites in `jsdom`.\n   */\n  public readonly unitTests: ObsidianPluginVitestProjectConfig = {\n    environment: 'jsdom',\n    exclude: [...SHARED_EXCLUDE, INTEGRATION_TEST_FILES],\n    execArgv: ['--no-webstorage'],\n    include: [UNIT_TEST_FILES],\n    name: 'unit-tests',\n    server: {\n      deps: {\n        inline: ['@obsidian-typings', 'obsidian-dev-utils']\n      }\n    },\n    setupFiles: [\n      'obsidian-test-mocks/vitest-setup',\n      'obsidian-test-mocks/obsidian-typings/vitest-setup',\n      'obsidian-dev-utils/vitest-setup'\n    ]\n  };\n\n  /**\n   * Creates a new context seeded with the standard projects.\n   */\n  public constructor() {\n    const obsidianVersion = process.env[OBSIDIAN_VERSION_ENV_VARIABLE_NAME];\n\n    /*\n     * Support is the range [latest public, latest catalyst] and BOTH ends must work (G99), so the version\n     * is a knob rather than a constant. The key is added ONLY when the variable is set: an explicit\n     * `obsidianVersion` makes the harness resolve a concrete version and swap the asar, which is not what\n     * an unpinned run does, so seeding a default here would change the behavior of every plugin.\n     */\n    if (obsidianVersion !== undefined) {\n      this.desktop.environmentOptions = {\n        obsidianTransport: {\n          obsidianVersion,\n          type: 'obsidian-cdp'\n        }\n      };\n    }\n  }\n}\n\n/**\n * Defines the vitest configuration for an Obsidian plugin.\n *\n * @param options - The options for defining the configuration.\n * @returns The vitest configuration.\n */\nexport function defineObsidianPluginVitestConfig(options: DefineObsidianPluginVitestConfigOptions = {}): ViteUserConfig {\n  const context = new ObsidianPluginVitestConfigContext();\n\n  if (options.editContext) {\n    options.editContext(context);\n  }\n\n  const customProjects = options.customProjects?.(context) ?? [];\n\n  return defineConfig({\n    test: {\n      coverage: {\n        exclude: context.coverageExclude,\n        include: ['src/**/*.ts'],\n        provider: 'v8',\n        reporter: ['text', 'lcov', 'html'],\n        reportsDirectory: './coverage'\n      },\n      exclude: [...SHARED_EXCLUDE],\n      globals: false,\n      include: [UNIT_TEST_FILES],\n      passWithNoTests: true,\n      projects: [\n        {\n          resolve: {\n            alias: {\n              obsidian: 'obsidian-test-mocks/obsidian'\n            }\n          },\n          test: context.unitTests\n        },\n        { test: context.noApp },\n        { test: context.desktop },\n        { test: context.desktopPerformance },\n        { test: context.android },\n        ...customProjects\n      ]\n    }\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,0BAAoB;AACpB,oBAA6B;AAO7B,MAAM,kCAAkC;AACxC,MAAM,8BAA8B;AACpC,MAAM,0BAA0B;AAChC,MAAM,sCAAsC;AAE5C,MAAM,qBAAqB;AAC3B,MAAM,4BAA4B;AAClC,MAAM,iCAAiC;AACvC,MAAM,qBAAqB;AAC3B,MAAM,yBAAyB;AAC/B,MAAM,oBAAoB;AAC1B,MAAM,kBAAkB;AAExB,MAAM,qCAAqC;AAC3C,MAAM,iBAAiB,CAAC,gBAAgB,MAAM;AA8BvC,MAAM,kCAAkC;AAAA;AAAA;AAAA;AAAA;AAAA,EAK7B,UAA6C;AAAA,IAC3D,aAAa;AAAA,IACb,oBAAoB;AAAA,MAClB,mBAAmB;AAAA,QACjB,WAAW;AAAA,QACX,SAAS;AAAA,QACT,MAAM;AAAA,MACR;AAAA,IACF;AAAA,IACA,iBAAiB;AAAA,IACjB,aAAa,CAAC,yDAAyD;AAAA,IACvE,aAAa,kCAAkC;AAAA,IAC/C,SAAS,CAAC,oBAAoB,yBAAyB;AAAA,IACvD,MAAM;AAAA,IACN,YAAY,CAAC,2CAA2C;AAAA,IACxD,aAAa;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQgB,+BAA+B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO/B,2BAA2B;AAAA;AAAA;AAAA;AAAA,EAK3B,kBAA4B,CAAC,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA,EAM5C,UAA6C;AAAA,IAC3D,aAAa;AAAA,IACb,iBAAiB;AAAA,IACjB,aAAa,CAAC,yDAAyD;AAAA,IACvE,aAAa,8BAA8B;AAAA,IAC3C,SAAS,CAAC,oBAAoB,yBAAyB;AAAA,IACvD,MAAM;AAAA,IACN,YAAY,CAAC,2CAA2C;AAAA,IACxD,aAAa;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOgB,qBAAwD;AAAA,IACtE,aAAa;AAAA,IACb,iBAAiB;AAAA,IACjB,aAAa,CAAC,yDAAyD;AAAA,IACvE,aAAa;AAAA,IACb,SAAS,CAAC,8BAA8B;AAAA,IACxC,MAAM;AAAA,IACN,YAAY,CAAC,2CAA2C;AAAA,IACxD,aAAa;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQgB,wBAAwB;AAAA;AAAA;AAAA;AAAA,EAKxB,QAA2C;AAAA,IACzD,aAAa;AAAA,IACb,iBAAiB;AAAA,IACjB,aAAa,8BAA8B;AAAA,IAC3C,SAAS,CAAC,iBAAiB;AAAA,IAC3B,MAAM;AAAA,IACN,aAAa;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASgB,mCAAmC;AAAA;AAAA;AAAA;AAAA,EAKnC,YAA+C;AAAA,IAC7D,aAAa;AAAA,IACb,SAAS,CAAC,GAAG,gBAAgB,sBAAsB;AAAA,IACnD,UAAU,CAAC,iBAAiB;AAAA,IAC5B,SAAS,CAAC,eAAe;AAAA,IACzB,MAAM;AAAA,IACN,QAAQ;AAAA,MACN,MAAM;AAAA,QACJ,QAAQ,CAAC,qBAAqB,oBAAoB;AAAA,MACpD;AAAA,IACF;AAAA,IACA,YAAY;AAAA,MACV;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKO,cAAc;AACnB,UAAM,kBAAkB,oBAAAA,QAAQ,IAAI,kCAAkC;AAQtE,QAAI,oBAAoB,QAAW;AACjC,WAAK,QAAQ,qBAAqB;AAAA,QAChC,mBAAmB;AAAA,UACjB;AAAA,UACA,MAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAQO,SAAS,iCAAiC,UAAmD,CAAC,GAAmB;AACtH,QAAM,UAAU,IAAI,kCAAkC;AAEtD,MAAI,QAAQ,aAAa;AACvB,YAAQ,YAAY,OAAO;AAAA,EAC7B;AAEA,QAAM,iBAAiB,QAAQ,iBAAiB,OAAO,KAAK,CAAC;AAE7D,aAAO,4BAAa;AAAA,IAClB,MAAM;AAAA,MACJ,UAAU;AAAA,QACR,SAAS,QAAQ;AAAA,QACjB,SAAS,CAAC,aAAa;AAAA,QACvB,UAAU;AAAA,QACV,UAAU,CAAC,QAAQ,QAAQ,MAAM;AAAA,QACjC,kBAAkB;AAAA,MACpB;AAAA,MACA,SAAS,CAAC,GAAG,cAAc;AAAA,MAC3B,SAAS;AAAA,MACT,SAAS,CAAC,eAAe;AAAA,MACzB,iBAAiB;AAAA,MACjB,UAAU;AAAA,QACR;AAAA,UACE,SAAS;AAAA,YACP,OAAO;AAAA,cACL,UAAU;AAAA,YACZ;AAAA,UACF;AAAA,UACA,MAAM,QAAQ;AAAA,QAChB;AAAA,QACA,EAAE,MAAM,QAAQ,MAAM;AAAA,QACtB,EAAE,MAAM,QAAQ,QAAQ;AAAA,QACxB,EAAE,MAAM,QAAQ,mBAAmB;AAAA,QACnC,EAAE,MAAM,QAAQ,QAAQ;AAAA,QACxB,GAAG;AAAA,MACL;AAAA,IACF;AAAA,EACF,CAAC;AACH;",
  "names": ["process"]
}
