@mnaoumov/typescript-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/cjs/linters/eslint-rules/prefer-logical-operator-over-ternary.cjs

@@ -0,0 +1,170 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+"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 prefer_logical_operator_over_ternary_exports = {};
+__export(prefer_logical_operator_over_ternary_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  UNICORN_RULE_NAME: () => UNICORN_RULE_NAME,
+  preferLogicalOperatorOverTernary: () => preferLogicalOperatorOverTernary
+});
+module.exports = __toCommonJS(prefer_logical_operator_over_ternary_exports);
+var import_eslint_plugin_unicorn = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('eslint-plugin-unicorn')), 1);
+const UNICORN_RULE_NAME = "prefer-logical-operator-over-ternary";
+const MESSAGE_ID = "prefer-logical-operator-over-ternary/error";
+const unicornRule = getUnicornRule();
+const preferLogicalOperatorOverTernary = {
+  create(context) {
+    const reportingContext = Object.create(context, {
+      report: {
+        value(descriptor) {
+          context.report(withLiteralBranchFix(descriptor, context.sourceCode));
+        }
+      }
+    });
+    return unicornRule.create(reportingContext);
+  },
+  meta: {
+    ...unicornRule.meta,
+    docs: {
+      description: "Prefer a logical operator over a ternary, fixing a boolean literal branch in TypeScript too"
+    }
+  }
+};
+function getBooleanLiteralValue(node) {
+  return node.type === "Literal" && typeof node.value === "boolean" ? node.value : void 0;
+}
+function getUnicornRule() {
+  const rule = import_eslint_plugin_unicorn.default.rules?.[UNICORN_RULE_NAME];
+  if (!rule || typeof rule === "function") {
+    throw new Error(`eslint-plugin-unicorn no longer defines the ${UNICORN_RULE_NAME} rule.`);
+  }
+  return rule;
+}
+function needsParentheses(node, operator) {
+  switch (node.type) {
+    case "ArrayExpression":
+    case "AwaitExpression":
+    case "CallExpression":
+    case "ChainExpression":
+    case "Identifier":
+    case "Literal":
+    case "MemberExpression":
+    case "NewExpression":
+    case "ObjectExpression":
+    case "TaggedTemplateExpression":
+    case "TemplateLiteral":
+    case "ThisExpression":
+    case "UnaryExpression": {
+      return false;
+    }
+    case "BinaryExpression": {
+      return operator === "!";
+    }
+    case "LogicalExpression": {
+      return operator === "!" || node.operator === "??" || operator === "&&" && node.operator === "||";
+    }
+    default: {
+      return true;
+    }
+  }
+}
+function toOperandText(node, operator, sourceCode) {
+  const text = sourceCode.getText(node);
+  return needsParentheses(node, operator) ? `(${text})` : text;
+}
+function withLiteralBranchFix(descriptor, sourceCode) {
+  const { fix, messageId, node, suggest } = descriptor;
+  if (messageId !== MESSAGE_ID || fix || suggest) {
+    return descriptor;
+  }
+  const conditionalExpression = node;
+  const { alternate, consequent, test } = conditionalExpression;
+  const consequentValue = getBooleanLiteralValue(consequent);
+  const alternateValue = getBooleanLiteralValue(alternate);
+  const literalValue = consequentValue ?? alternateValue;
+  if (literalValue === void 0 || consequentValue !== void 0 && alternateValue !== void 0 || sourceCode.getCommentsInside(conditionalExpression).length > 0) {
+    return descriptor;
+  }
+  const isConsequentLiteral = consequentValue !== void 0;
+  const other = isConsequentLiteral ? alternate : consequent;
+  const shouldNegateTest = isConsequentLiteral !== literalValue;
+  const operator = literalValue ? "||" : "&&";
+  const testText = shouldNegateTest ? `!${toOperandText(test, "!", sourceCode)}` : toOperandText(test, operator, sourceCode);
+  const otherText = toOperandText(other, operator, sourceCode);
+  return {
+    ...descriptor,
+    fix(fixer) {
+      return fixer.replaceText(conditionalExpression, `${testText} ${operator} ${otherText}`);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  UNICORN_RULE_NAME,
+  preferLogicalOperatorOverTernary
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/linters/eslint-rules/prefer-logical-operator-over-ternary.ts"],"sourcesContent":["/**\n * @file\n *\n * ESLint rule: prefer-logical-operator-over-ternary\n *\n * `unicorn/prefer-logical-operator-over-ternary`, with the fix it withholds in a TypeScript file.\n *\n * Unicorn reports a ternary with one boolean branch (`a ? false : b`) and fixes it to a logical expression\n * (`!a && b`), but only outside TypeScript. `unicorn/prefer-ternary` fixes `if (a) { return false; } return b;` into\n * exactly that ternary, so in a TypeScript file `lint:fix` produced an error it then could not fix, and every site\n * had to be rewritten by hand. This rule reports what unicorn reports and adds the fix where one branch is a boolean\n * literal. The rewrite is exact at runtime: with a negated test (`a ? false : b` → `!a && b`, `a ? b : true` →\n * `!a || b`) for any test, and otherwise (`a ? true : b` → `a || b`, `a ? b : false` → `a && b`) because unicorn\n * reports that shape only for a test it has proven boolean.\n */\n\nimport type { Rule } from 'eslint';\nimport type {\n  ConditionalExpression,\n  Expression,\n  Node\n} from 'estree';\n\nimport eslintPluginUnicorn from 'eslint-plugin-unicorn';\n\n/**\n * The id of the unicorn rule this rule delegates to, inside the `unicorn` namespace.\n */\nexport const UNICORN_RULE_NAME = 'prefer-logical-operator-over-ternary';\n\n/**\n * The message id unicorn reports a ternary under when a logical operator could replace it.\n */\nexport const MESSAGE_ID = 'prefer-logical-operator-over-ternary/error';\n\ntype LogicalOperator = '&&' | '||';\n\ntype UnicornReportDescriptor = Rule.ReportDescriptorOptions & UnicornReportDescriptorFields;\n\ninterface UnicornReportDescriptorFields {\n  readonly messageId?: string;\n  readonly node: Node;\n}\n\nconst unicornRule = getUnicornRule();\n\n/**\n * ESLint rule reporting what `unicorn/prefer-logical-operator-over-ternary` reports, fixing a ternary with a boolean\n * literal branch in a TypeScript file too.\n */\nexport const preferLogicalOperatorOverTernary: Rule.RuleModule = {\n  create(context) {\n    const reportingContext: Rule.RuleContext = Object.create(context, {\n      report: {\n        value(descriptor: Rule.ReportDescriptor): void {\n          context.report(withLiteralBranchFix(descriptor, context.sourceCode));\n        }\n      }\n    });\n\n    return unicornRule.create(reportingContext);\n  },\n  meta: {\n    ...unicornRule.meta,\n    docs: {\n      description: 'Prefer a logical operator over a ternary, fixing a boolean literal branch in TypeScript too'\n    }\n  }\n};\n\nfunction getBooleanLiteralValue(node: Node): boolean | undefined {\n  return node.type === 'Literal' && typeof node.value === 'boolean' ? node.value : undefined;\n}\n\nfunction getUnicornRule(): Rule.RuleModule {\n  const rule = eslintPluginUnicorn.rules?.[UNICORN_RULE_NAME];\n\n  /* v8 ignore start -- Guards an upgrade of eslint-plugin-unicorn that drops or renames the rule. */\n  if (!rule || typeof rule === 'function') {\n    throw new Error(`eslint-plugin-unicorn no longer defines the ${UNICORN_RULE_NAME} rule.`);\n  }\n  /* v8 ignore stop */\n\n  return rule;\n}\n\nfunction needsParentheses(node: Expression, operator: '!' | LogicalOperator): boolean {\n  switch (node.type) {\n    case 'ArrayExpression':\n    case 'AwaitExpression':\n    case 'CallExpression':\n    case 'ChainExpression':\n    case 'Identifier':\n    case 'Literal':\n    case 'MemberExpression':\n    case 'NewExpression':\n    case 'ObjectExpression':\n    case 'TaggedTemplateExpression':\n    case 'TemplateLiteral':\n    case 'ThisExpression':\n    case 'UnaryExpression': {\n      return false;\n    }\n    case 'BinaryExpression': {\n      return operator === '!';\n    }\n    case 'LogicalExpression': {\n      return operator === '!' || node.operator === '??' || (operator === '&&' && node.operator === '||');\n    }\n    default: {\n      return true;\n    }\n  }\n}\n\nfunction toOperandText(node: Expression, operator: '!' | LogicalOperator, sourceCode: Rule.RuleContext['sourceCode']): string {\n  const text = sourceCode.getText(node);\n  return needsParentheses(node, operator) ? `(${text})` : text;\n}\n\nfunction withLiteralBranchFix(descriptor: Rule.ReportDescriptor, sourceCode: Rule.RuleContext['sourceCode']): Rule.ReportDescriptor {\n  const { fix, messageId, node, suggest } = descriptor as UnicornReportDescriptor;\n\n  // Unicorn fixes the shape itself outside TypeScript, and offers suggestions for the shapes it cannot fix.\n  if (messageId !== MESSAGE_ID || fix || suggest) {\n    return descriptor;\n  }\n\n  // Unicorn reports this message on the ternary itself.\n  const conditionalExpression = node as ConditionalExpression;\n  const { alternate, consequent, test } = conditionalExpression;\n  const consequentValue = getBooleanLiteralValue(consequent);\n  const alternateValue = getBooleanLiteralValue(alternate);\n  const literalValue = consequentValue ?? alternateValue;\n\n  if (\n    literalValue === undefined\n    || (consequentValue !== undefined && alternateValue !== undefined)\n    || sourceCode.getCommentsInside(conditionalExpression).length > 0\n  ) {\n    return descriptor;\n  }\n\n  const isConsequentLiteral = consequentValue !== undefined;\n  const other = isConsequentLiteral ? alternate : consequent;\n  const shouldNegateTest = isConsequentLiteral !== literalValue;\n  const operator: LogicalOperator = literalValue ? '||' : '&&';\n  const testText = shouldNegateTest ? `!${toOperandText(test, '!', sourceCode)}` : toOperandText(test, operator, sourceCode);\n  const otherText = toOperandText(other, operator, sourceCode);\n\n  return {\n    ...descriptor,\n    fix(fixer): Rule.Fix {\n      return fixer.replaceText(conditionalExpression, `${testText} ${operator} ${otherText}`);\n    }\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,mCAAgC;AAKzB,MAAM,oBAAoB;AAK1B,MAAM,aAAa;AAW1B,MAAM,cAAc,eAAe;AAM5B,MAAM,mCAAoD;AAAA,EAC/D,OAAO,SAAS;AACd,UAAM,mBAAqC,OAAO,OAAO,SAAS;AAAA,MAChE,QAAQ;AAAA,QACN,MAAM,YAAyC;AAC7C,kBAAQ,OAAO,qBAAqB,YAAY,QAAQ,UAAU,CAAC;AAAA,QACrE;AAAA,MACF;AAAA,IACF,CAAC;AAED,WAAO,YAAY,OAAO,gBAAgB;AAAA,EAC5C;AAAA,EACA,MAAM;AAAA,IACJ,GAAG,YAAY;AAAA,IACf,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,EACF;AACF;AAEA,SAAS,uBAAuB,MAAiC;AAC/D,SAAO,KAAK,SAAS,aAAa,OAAO,KAAK,UAAU,YAAY,KAAK,QAAQ;AACnF;AAEA,SAAS,iBAAkC;AACzC,QAAM,OAAO,6BAAAA,QAAoB,QAAQ,iBAAiB;AAG1D,MAAI,CAAC,QAAQ,OAAO,SAAS,YAAY;AACvC,UAAM,IAAI,MAAM,+CAA+C,iBAAiB,QAAQ;AAAA,EAC1F;AAGA,SAAO;AACT;AAEA,SAAS,iBAAiB,MAAkB,UAA0C;AACpF,UAAQ,KAAK,MAAM;AAAA,IACjB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK,mBAAmB;AACtB,aAAO;AAAA,IACT;AAAA,IACA,KAAK,oBAAoB;AACvB,aAAO,aAAa;AAAA,IACtB;AAAA,IACA,KAAK,qBAAqB;AACxB,aAAO,aAAa,OAAO,KAAK,aAAa,QAAS,aAAa,QAAQ,KAAK,aAAa;AAAA,IAC/F;AAAA,IACA,SAAS;AACP,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,SAAS,cAAc,MAAkB,UAAiC,YAAoD;AAC5H,QAAM,OAAO,WAAW,QAAQ,IAAI;AACpC,SAAO,iBAAiB,MAAM,QAAQ,IAAI,IAAI,IAAI,MAAM;AAC1D;AAEA,SAAS,qBAAqB,YAAmC,YAAmE;AAClI,QAAM,EAAE,KAAK,WAAW,MAAM,QAAQ,IAAI;AAG1C,MAAI,cAAc,cAAc,OAAO,SAAS;AAC9C,WAAO;AAAA,EACT;AAGA,QAAM,wBAAwB;AAC9B,QAAM,EAAE,WAAW,YAAY,KAAK,IAAI;AACxC,QAAM,kBAAkB,uBAAuB,UAAU;AACzD,QAAM,iBAAiB,uBAAuB,SAAS;AACvD,QAAM,eAAe,mBAAmB;AAExC,MACE,iBAAiB,UACb,oBAAoB,UAAa,mBAAmB,UACrD,WAAW,kBAAkB,qBAAqB,EAAE,SAAS,GAChE;AACA,WAAO;AAAA,EACT;AAEA,QAAM,sBAAsB,oBAAoB;AAChD,QAAM,QAAQ,sBAAsB,YAAY;AAChD,QAAM,mBAAmB,wBAAwB;AACjD,QAAM,WAA4B,eAAe,OAAO;AACxD,QAAM,WAAW,mBAAmB,IAAI,cAAc,MAAM,KAAK,UAAU,CAAC,KAAK,cAAc,MAAM,UAAU,UAAU;AACzH,QAAM,YAAY,cAAc,OAAO,UAAU,UAAU;AAE3D,SAAO;AAAA,IACL,GAAG;AAAA,IACH,IAAI,OAAiB;AACnB,aAAO,MAAM,YAAY,uBAAuB,GAAG,QAAQ,IAAI,QAAQ,IAAI,SAAS,EAAE;AAAA,IACxF;AAAA,EACF;AACF;","names":["eslintPluginUnicorn"]}

package/dist/lib/cjs/linters/eslint-rules/prefer-logical-operator-over-ternary.d.cts

@@ -0,0 +1,30 @@
+/// <reference path="../../library-references.d.cts" />
+/**
+ * @file
+ *
+ * ESLint rule: prefer-logical-operator-over-ternary
+ *
+ * `unicorn/prefer-logical-operator-over-ternary`, with the fix it withholds in a TypeScript file.
+ *
+ * Unicorn reports a ternary with one boolean branch (`a ? false : b`) and fixes it to a logical expression
+ * (`!a && b`), but only outside TypeScript. `unicorn/prefer-ternary` fixes `if (a) { return false; } return b;` into
+ * exactly that ternary, so in a TypeScript file `lint:fix` produced an error it then could not fix, and every site
+ * had to be rewritten by hand. This rule reports what unicorn reports and adds the fix where one branch is a boolean
+ * literal. The rewrite is exact at runtime: with a negated test (`a ? false : b` → `!a && b`, `a ? b : true` →
+ * `!a || b`) for any test, and otherwise (`a ? true : b` → `a || b`, `a ? b : false` → `a && b`) because unicorn
+ * reports that shape only for a test it has proven boolean.
+ */
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+ * The id of the unicorn rule this rule delegates to, inside the `unicorn` namespace.
+ */
+export declare const UNICORN_RULE_NAME = "prefer-logical-operator-over-ternary";
+/**
+ * The message id unicorn reports a ternary under when a logical operator could replace it.
+ */
+export declare const MESSAGE_ID = "prefer-logical-operator-over-ternary/error";
+/**
+ * ESLint rule reporting what `unicorn/prefer-logical-operator-over-ternary` reports, fixing a ternary with a boolean
+ * literal branch in a TypeScript file too.
+ */
+export declare const preferLogicalOperatorOverTernary: Rule.RuleModule;

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

@@ -37,11 +37,15 @@ __export(nano_staged_config_exports, {
   obsidianDevUtilsConfig: () => obsidianDevUtilsConfig
 });
 module.exports = __toCommonJS(nano_staged_config_exports);
+var import_node_path = require('node:path');
 var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
 var import_env_toggle = require('./env-toggle.cjs');
+var import_exec = require('./exec.cjs');
 var import_package_manager = require('./package-manager.cjs');
 const PACKAGE_MANAGER_RUN_COMMAND = (0, import_package_manager.getPackageManagerRunCommand)().join(" ");
 const SPELLCHECK_COMMAND = `${PACKAGE_MANAGER_RUN_COMMAND} spellcheck --`;
+const EXECUTABLE_PATH_RESERVE = 260;
+const TOKENIZER_UNSAFE_CHARACTERS_REG_EXP = /[\s"']/g;
 const WRITER_TASKS = {
   "*.{ts,tsx,mts}": [
     `${PACKAGE_MANAGER_RUN_COMMAND} lint:fix --`,
@@ -70,6 +74,27 @@ function getNanoStagedConfig(options) {
   }
   return partitionSpellcheck({ ...WRITER_TASKS, ...additionalWriterTasks });
 }
+function batchCommandArguments(prefix, commandArguments) {
+  const emptyLength = (0, import_exec.getEffectiveCommandLineLength)("");
+  const budget = (0, import_exec.getMaxBatchCommandLength)() - EXECUTABLE_PATH_RESERVE - (0, import_exec.getEffectiveCommandLineLength)(prefix);
+  const batches = [];
+  let batch = [];
+  let batchLength = 0;
+  for (const commandArgument of commandArguments) {
+    const argumentLength = (0, import_exec.getEffectiveCommandLineLength)(` "${commandArgument}"`) - emptyLength;
+    if (batch.length > 0 && batchLength + argumentLength > budget) {
+      batches.push(batch);
+      batch = [];
+      batchLength = 0;
+    }
+    batch.push(commandArgument);
+    batchLength += argumentLength;
+  }
+  if (batch.length > 0) {
+    batches.push(batch);
+  }
+  return batches;
+}
 function partitionSpellcheck(writerTasks) {
   const patterns = Object.keys(writerTasks);
   const patternWithSlash = patterns.find((pattern) => pattern.includes("/"));
@@ -78,16 +103,30 @@ function partitionSpellcheck(writerTasks) {
   }
   const complementPattern = `!(${patterns.map((pattern) => `${pattern}!(?)`).join("|")})*`;
   const config = {
-    [complementPattern]: [SPELLCHECK_COMMAND]
+    [complementPattern]: toBatchedTask([SPELLCHECK_COMMAND])
   };
   for (const [pattern, commands] of Object.entries(writerTasks)) {
-    config[pattern] = [...commands, SPELLCHECK_COMMAND];
+    config[pattern] = toBatchedTask([...commands, SPELLCHECK_COMMAND]);
   }
   return config;
 }
+function toBatchedTask(commands) {
+  return ({ filenames }) => {
+    const commandArguments = filenames.map((filename) => toCommandArgument(filename));
+    return commands.flatMap((command) => batchCommandArguments(command, commandArguments).map((batch) => `${command} ${batch.join(" ")}`));
+  };
+}
+function toCommandArgument(filename) {
+  const relativePath = (0, import_node_path.relative)(import_node_process.default.cwd(), filename);
+  let commandArgument = (relativePath.startsWith("..") || (0, import_node_path.isAbsolute)(relativePath) ? filename : relativePath).replaceAll("\\", "/");
+  if (commandArgument.startsWith("-")) {
+    commandArgument = `./${commandArgument}`;
+  }
+  return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, "?");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getNanoStagedConfig,
   obsidianDevUtilsConfig
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/nano-staged-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared nano-staged configuration for pre-commit hooks.\n */\n\nimport process from 'node:process';\n\nimport {\n  isEnvVariableOff,\n  loadEnvFileIfExists\n} from './env-toggle.ts';\nimport { getPackageManagerRunCommand } from './package-manager.ts';\n\n/**\n * Options for {@link getNanoStagedConfig}.\n */\nexport interface GetNanoStagedConfigOptions {\n  /**\n   * Repo-specific file-rewriting tasks, keyed by the nano-staged pattern that claims their files.\n   *\n   * Each gets spellcheck appended and its files removed from the spellcheck-only key, exactly like the shared\n   * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern.\n   */\n  readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;\n}\n\n/**\n * The `<manager> run` prefix every task below is built on, resolved once for the process.\n *\n * Detection probes for a lockfile beside `package.json`, so it is a handful of `existsSync` calls and\n * nothing more \u2014 no `.env` read and no `process.exit`, which is what lets it sit at module scope.\n */\nconst PACKAGE_MANAGER_RUN_COMMAND = getPackageManagerRunCommand().join(' ');\n\nconst SPELLCHECK_COMMAND = `${PACKAGE_MANAGER_RUN_COMMAND} spellcheck --`;\n\n/**\n * The tasks that REWRITE a staged file, keyed by the nano-staged pattern that claims it.\n *\n * `lint:fix` and `format` both rewrite the file, so they have to share one key: nano-staged runs its\n * per-pattern groups under `Promise.all` (`run()` in `nano-staged/lib/cmd-runner.js`), and sequences only\n * the commands INSIDE a single key's array (`runTask()`, a `for ... of await`). Split across two keys they\n * race, whichever finishes last wins, and the commit stages bytes that neither tool would have produced on\n * its own.\n *\n * So do NOT express a directory exclusion by giving one of these two its own negated key -- that silently\n * takes the ordering away. An exclusion belongs in the excluded tool's own config, where ESLint's\n * `globalIgnores` already puts it: a path ESLint ignores is reported as a warning and exits 0 when it is\n * passed explicitly, so it costs a console line rather than a failed commit and needs no key here.\n */\nconst WRITER_TASKS: Readonly<Record<string, readonly string[]>> = {\n  '*.{ts,tsx,mts}': [\n    `${PACKAGE_MANAGER_RUN_COMMAND} lint:fix --`,\n    `${PACKAGE_MANAGER_RUN_COMMAND} format --`\n  ],\n  '*.md': [\n    `${PACKAGE_MANAGER_RUN_COMMAND} lint:md:fix --`\n  ]\n};\n\n/**\n * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.\n *\n * Only includes tools that can operate on individual files. Whole-project checks\n * (TypeScript compilation, unit tests) are left to CI.\n *\n * Commands run through the package manager that owns the tree \u2014 `npm run ... --`, `bun run ... --`, and\n * so on \u2014 so nano-staged file paths are forwarded as CLI arguments.\n *\n * Spellcheck is partitioned across the keys rather than given a catch-all `'*'` key (see\n * `partitionSpellcheck`). A repo adding a file-rewriting task of its own passes it to\n * {@link getNanoStagedConfig} as `additionalWriterTasks` rather than spreading this object and adding a key,\n * which would reintroduce the overlap for that key's files.\n */\nexport const obsidianDevUtilsConfig: Record<string, string[]> = partitionSpellcheck(WRITER_TASKS);\n\nconst NANO_STAGED_ENV_VARIABLE = 'NANO_STAGED';\n\n/**\n * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.\n *\n * Loads a gitignored `.env` if present, then \u2014 when `NANO_STAGED` is set to an off value (`0`, `false`,\n * `off`, or `no`) \u2014 prints a notice and exits the process successfully so the pre-commit checks are\n * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the\n * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}, or \u2014 when\n * `additionalWriterTasks` are given \u2014 the same configuration re-partitioned with those writers added.\n *\n * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one\n * every npm script gets \u2014 but both share the same notion of an off value, via {@link isEnvVariableOff}.\n *\n * This is a function rather than module-level code so importing the package barrel never triggers the\n * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry. Resolving the\n * package manager is the one thing that does run at module scope, and it does neither of those two\n * things \u2014 it only probes for a lockfile.\n *\n * @param options - The optional options.\n * @returns The nano-staged task configuration. Does not return when the opt-out is active.\n */\nexport function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): Record<string, string[]> {\n  loadEnvFileIfExists();\n\n  if (isEnvVariableOff(NANO_STAGED_ENV_VARIABLE)) {\n    process.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).\\n`);\n    process.exit(0);\n  }\n\n  const additionalWriterTasks = options?.additionalWriterTasks ?? {};\n  if (Object.keys(additionalWriterTasks).length === 0) {\n    return obsidianDevUtilsConfig;\n  }\n\n  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(WRITER_TASKS, pattern));\n  if (duplicatePattern !== undefined) {\n    throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);\n  }\n\n  return partitionSpellcheck({ ...WRITER_TASKS, ...additionalWriterTasks });\n}\n\n/**\n * Builds a nano-staged configuration in which spellcheck never reads a file while another task rewrites it.\n *\n * The same `Promise.all` that forces two writers into one key makes a catch-all `'*'` spellcheck key run\n * CONCURRENTLY with every writer key, so cspell would read a file that ESLint or dprint is rewriting in\n * place -- a spurious finding on a half-written file, or a pass over content that is not what gets\n * committed. So the staged files are PARTITIONED instead:\n *\n * - every writer key gets spellcheck appended as its LAST command, so it reads that key's files after they\n *   have been rewritten;\n * - one complement key spellchecks exactly the files no writer key claims.\n *\n * The complement is written in nano-staged's own glob dialect, which compiles `!(...)` to a lookahead that\n * is NOT anchored at the end of the path: `!(*.md)*` would exclude `notes.md.bak` too. A nested `!(?)`\n * compiles to `(?!.)`, which IS an end anchor, so each alternative is suffixed with it. A writer pattern\n * containing `/` would switch nano-staged into globstar mode, where `*` stops crossing directories and the\n * construction no longer holds -- hence the throw. The unit test pins the partition against the installed\n * nano-staged compiler, so a release that changes its dialect fails there rather than in a commit.\n *\n * @param writerTasks - The file-rewriting tasks, keyed by the pattern that claims their files.\n * @returns The configuration, with the spellcheck step partitioned across the keys.\n */\nfunction partitionSpellcheck(writerTasks: Readonly<Record<string, readonly string[]>>): Record<string, string[]> {\n  const patterns = Object.keys(writerTasks);\n  const patternWithSlash = patterns.find((pattern) => pattern.includes('/'));\n  if (patternWithSlash !== undefined) {\n    throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);\n  }\n\n  const complementPattern = `!(${patterns.map((pattern) => `${pattern}!(?)`).join('|')})*`;\n  const config: Record<string, string[]> = {\n    [complementPattern]: [SPELLCHECK_COMMAND]\n  };\n\n  for (const [pattern, commands] of Object.entries(writerTasks)) {\n    config[pattern] = [...commands, SPELLCHECK_COMMAND];\n  }\n\n  return config;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,0BAAoB;AAEpB,wBAGO;AACP,6BAA4C;AAqB5C,MAAM,kCAA8B,oDAA4B,EAAE,KAAK,GAAG;AAE1E,MAAM,qBAAqB,GAAG,2BAA2B;AAgBzD,MAAM,eAA4D;AAAA,EAChE,kBAAkB;AAAA,IAChB,GAAG,2BAA2B;AAAA,IAC9B,GAAG,2BAA2B;AAAA,EAChC;AAAA,EACA,QAAQ;AAAA,IACN,GAAG,2BAA2B;AAAA,EAChC;AACF;AAgBO,MAAM,yBAAmD,oBAAoB,YAAY;AAEhG,MAAM,2BAA2B;AAsB1B,SAAS,oBAAoB,SAAgE;AAClG,6CAAoB;AAEpB,UAAI,oCAAiB,wBAAwB,GAAG;AAC9C,wBAAAA,QAAQ,OAAO,MAAM,yBAAyB,wBAAwB;AAAA,CAAa;AACnF,wBAAAA,QAAQ,KAAK,CAAC;AAAA,EAChB;AAEA,QAAM,wBAAwB,SAAS,yBAAyB,CAAC;AACjE,MAAI,OAAO,KAAK,qBAAqB,EAAE,WAAW,GAAG;AACnD,WAAO;AAAA,EACT;AAEA,QAAM,mBAAmB,OAAO,KAAK,qBAAqB,EAAE,KAAK,CAAC,YAAY,OAAO,OAAO,cAAc,OAAO,CAAC;AAClH,MAAI,qBAAqB,QAAW;AAClC,UAAM,IAAI,MAAM,+BAA+B,gBAAgB,uCAAuC;AAAA,EACxG;AAEA,SAAO,oBAAoB,EAAE,GAAG,cAAc,GAAG,sBAAsB,CAAC;AAC1E;AAwBA,SAAS,oBAAoB,aAAoF;AAC/G,QAAM,WAAW,OAAO,KAAK,WAAW;AACxC,QAAM,mBAAmB,SAAS,KAAK,CAAC,YAAY,QAAQ,SAAS,GAAG,CAAC;AACzE,MAAI,qBAAqB,QAAW;AAClC,UAAM,IAAI,MAAM,+BAA+B,gBAAgB,gEAAgE;AAAA,EACjI;AAEA,QAAM,oBAAoB,KAAK,SAAS,IAAI,CAAC,YAAY,GAAG,OAAO,MAAM,EAAE,KAAK,GAAG,CAAC;AACpF,QAAM,SAAmC;AAAA,IACvC,CAAC,iBAAiB,GAAG,CAAC,kBAAkB;AAAA,EAC1C;AAEA,aAAW,CAAC,SAAS,QAAQ,KAAK,OAAO,QAAQ,WAAW,GAAG;AAC7D,WAAO,OAAO,IAAI,CAAC,GAAG,UAAU,kBAAkB;AAAA,EACpD;AAEA,SAAO;AACT;",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/nano-staged-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared nano-staged configuration for pre-commit hooks.\n */\n\nimport {\n  isAbsolute,\n  relative\n} from 'node:path';\nimport process from 'node:process';\n\nimport {\n  isEnvVariableOff,\n  loadEnvFileIfExists\n} from './env-toggle.ts';\nimport {\n  getEffectiveCommandLineLength,\n  getMaxBatchCommandLength\n} from './exec.ts';\nimport { getPackageManagerRunCommand } from './package-manager.ts';\n\n/**\n * Options for {@link getNanoStagedConfig}.\n */\nexport interface GetNanoStagedConfigOptions {\n  /**\n   * Repo-specific file-rewriting tasks, keyed by the nano-staged pattern that claims their files.\n   *\n   * Each gets spellcheck appended and its files removed from the spellcheck-only key, exactly like the shared\n   * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern. Each command is a\n   * prefix the staged paths are appended to, in batches, like the shared ones (`npm run lint:fix --`).\n   */\n  readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;\n}\n\n/**\n * A nano-staged configuration whose every key is a {@link NanoStagedTask}.\n */\nexport type NanoStagedConfig = Record<string, NanoStagedTask>;\n\n/**\n * A function-valued nano-staged task: it receives the staged files its pattern claims and returns the\n * commands to run over them, in order.\n */\nexport type NanoStagedTask = (context: NanoStagedTaskContext) => string[];\n\n/**\n * What nano-staged passes to a function-valued task.\n */\nexport interface NanoStagedTaskContext {\n  /**\n   * The absolute paths of the staged files the task's pattern claims.\n   */\n  readonly filenames: readonly string[];\n}\n\n/**\n * The `<manager> run` prefix every task below is built on, resolved once for the process.\n *\n * Detection probes for a lockfile beside `package.json`, so it is a handful of `existsSync` calls and\n * nothing more \u2014 no `.env` read and no `process.exit`, which is what lets it sit at module scope.\n */\nconst PACKAGE_MANAGER_RUN_COMMAND = getPackageManagerRunCommand().join(' ');\n\nconst SPELLCHECK_COMMAND = `${PACKAGE_MANAGER_RUN_COMMAND} spellcheck --`;\n\n/**\n * Room left in every batch for the resolved path of the package manager's executable.\n *\n * nano-staged runs `npm` as the absolute path of `npm.cmd` (`<comspec> /D /S /C \"<path>\" \"<arg>\" \u2026`), which\n * the batch cannot see, so a full Windows `MAX_PATH` is set aside for it.\n */\nconst EXECUTABLE_PATH_RESERVE = 260;\n\n/**\n * The characters nano-staged's command tokenizer cannot carry inside an argument.\n *\n * A function-valued task returns its commands as STRINGS, and nano-staged splits each one with\n * `stringArgvToArray`, which emits a quoted token twice (once bare, once with its quotes) and has no escape.\n * So a path holding whitespace or a quote cannot be passed as itself.\n */\nconst TOKENIZER_UNSAFE_CHARACTERS_REG_EXP = /[\\s\"']/g;\n\n/**\n * The tasks that REWRITE a staged file, keyed by the nano-staged pattern that claims it.\n *\n * `lint:fix` and `format` both rewrite the file, so they have to share one key: nano-staged runs its\n * per-pattern groups under `Promise.all` (`run()` in `nano-staged/lib/cmd-runner.js`), and sequences only\n * the commands INSIDE a single key's array (`runTask()`, a `for ... of await`). Split across two keys they\n * race, whichever finishes last wins, and the commit stages bytes that neither tool would have produced on\n * its own.\n *\n * So do NOT express a directory exclusion by giving one of these two its own negated key -- that silently\n * takes the ordering away. An exclusion belongs in the excluded tool's own config, where ESLint's\n * `globalIgnores` already puts it: a path ESLint ignores is reported as a warning and exits 0 when it is\n * passed explicitly, so it costs a console line rather than a failed commit and needs no key here.\n */\nconst WRITER_TASKS: Readonly<Record<string, readonly string[]>> = {\n  '*.{ts,tsx,mts}': [\n    `${PACKAGE_MANAGER_RUN_COMMAND} lint:fix --`,\n    `${PACKAGE_MANAGER_RUN_COMMAND} format --`\n  ],\n  '*.md': [\n    `${PACKAGE_MANAGER_RUN_COMMAND} lint:md:fix --`\n  ]\n};\n\n/**\n * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.\n *\n * Only includes tools that can operate on individual files. Whole-project checks\n * (TypeScript compilation, unit tests) are left to CI.\n *\n * Commands run through the package manager that owns the tree \u2014 `npm run ... --`, `bun run ... --`, and\n * so on \u2014 so nano-staged file paths are forwarded as CLI arguments, batched to fit the command line (see\n * `toBatchedTask`).\n *\n * Spellcheck is partitioned across the keys rather than given a catch-all `'*'` key (see\n * `partitionSpellcheck`). A repo adding a file-rewriting task of its own passes it to\n * {@link getNanoStagedConfig} as `additionalWriterTasks` rather than spreading this object and adding a key,\n * which would reintroduce the overlap for that key's files.\n */\nexport const obsidianDevUtilsConfig: NanoStagedConfig = partitionSpellcheck(WRITER_TASKS);\n\nconst NANO_STAGED_ENV_VARIABLE = 'NANO_STAGED';\n\n/**\n * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.\n *\n * Loads a gitignored `.env` if present, then \u2014 when `NANO_STAGED` is set to an off value (`0`, `false`,\n * `off`, or `no`) \u2014 prints a notice and exits the process successfully so the pre-commit checks are\n * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the\n * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}, or \u2014 when\n * `additionalWriterTasks` are given \u2014 the same configuration re-partitioned with those writers added.\n *\n * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one\n * every npm script gets \u2014 but both share the same notion of an off value, via {@link isEnvVariableOff}.\n *\n * This is a function rather than module-level code so importing the package barrel never triggers the\n * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry. Resolving the\n * package manager is the one thing that does run at module scope, and it does neither of those two\n * things \u2014 it only probes for a lockfile.\n *\n * @param options - The optional options.\n * @returns The nano-staged task configuration. Does not return when the opt-out is active.\n */\nexport function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): NanoStagedConfig {\n  loadEnvFileIfExists();\n\n  if (isEnvVariableOff(NANO_STAGED_ENV_VARIABLE)) {\n    process.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).\\n`);\n    process.exit(0);\n  }\n\n  const additionalWriterTasks = options?.additionalWriterTasks ?? {};\n  if (Object.keys(additionalWriterTasks).length === 0) {\n    return obsidianDevUtilsConfig;\n  }\n\n  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(WRITER_TASKS, pattern));\n  if (duplicatePattern !== undefined) {\n    throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);\n  }\n\n  return partitionSpellcheck({ ...WRITER_TASKS, ...additionalWriterTasks });\n}\n\n/**\n * Splits command arguments into batches that each fit one command line after a given prefix.\n *\n * Each argument is costed as nano-staged passes it on Windows \u2014 quoted, then `^`-escaped by `cmd.exe`'s\n * rules \u2014 through {@link getEffectiveCommandLineLength}, and the budget is {@link getMaxBatchCommandLength},\n * which already holds back the reserve for the `npm` \u2192 `cmd.exe` \u2192 `.bin` shim chain re-expanding the\n * arguments. An argument too long for any batch still gets a batch of its own: it fails loudly there, which\n * dropping it would not.\n *\n * @param prefix - The command the arguments are appended to.\n * @param commandArguments - The arguments to split.\n * @returns The batches, in order, together holding every argument once.\n */\nfunction batchCommandArguments(prefix: string, commandArguments: readonly string[]): string[][] {\n  const emptyLength = getEffectiveCommandLineLength('');\n  const budget = getMaxBatchCommandLength() - EXECUTABLE_PATH_RESERVE - getEffectiveCommandLineLength(prefix);\n  const batches: string[][] = [];\n  let batch: string[] = [];\n  let batchLength = 0;\n\n  for (const commandArgument of commandArguments) {\n    const argumentLength = getEffectiveCommandLineLength(` \"${commandArgument}\"`) - emptyLength;\n    if (batch.length > 0 && batchLength + argumentLength > budget) {\n      batches.push(batch);\n      batch = [];\n      batchLength = 0;\n    }\n    batch.push(commandArgument);\n    batchLength += argumentLength;\n  }\n\n  if (batch.length > 0) {\n    batches.push(batch);\n  }\n\n  return batches;\n}\n\n/**\n * Builds a nano-staged configuration in which spellcheck never reads a file while another task rewrites it.\n *\n * The same `Promise.all` that forces two writers into one key makes a catch-all `'*'` spellcheck key run\n * CONCURRENTLY with every writer key, so cspell would read a file that ESLint or dprint is rewriting in\n * place -- a spurious finding on a half-written file, or a pass over content that is not what gets\n * committed. So the staged files are PARTITIONED instead:\n *\n * - every writer key gets spellcheck appended as its LAST command, so it reads that key's files after they\n *   have been rewritten;\n * - one complement key spellchecks exactly the files no writer key claims.\n *\n * The complement is written in nano-staged's own glob dialect, which compiles `!(...)` to a lookahead that\n * is NOT anchored at the end of the path: `!(*.md)*` would exclude `notes.md.bak` too. A nested `!(?)`\n * compiles to `(?!.)`, which IS an end anchor, so each alternative is suffixed with it. A writer pattern\n * containing `/` would switch nano-staged into globstar mode, where `*` stops crossing directories and the\n * construction no longer holds -- hence the throw. The unit test pins the partition against the installed\n * nano-staged compiler, so a release that changes its dialect fails there rather than in a commit.\n *\n * @param writerTasks - The file-rewriting tasks, keyed by the pattern that claims their files.\n * @returns The configuration, with the spellcheck step partitioned across the keys.\n */\nfunction partitionSpellcheck(writerTasks: Readonly<Record<string, readonly string[]>>): NanoStagedConfig {\n  const patterns = Object.keys(writerTasks);\n  const patternWithSlash = patterns.find((pattern) => pattern.includes('/'));\n  if (patternWithSlash !== undefined) {\n    throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);\n  }\n\n  const complementPattern = `!(${patterns.map((pattern) => `${pattern}!(?)`).join('|')})*`;\n  const config: NanoStagedConfig = {\n    [complementPattern]: toBatchedTask([SPELLCHECK_COMMAND])\n  };\n\n  for (const [pattern, commands] of Object.entries(writerTasks)) {\n    config[pattern] = toBatchedTask([...commands, SPELLCHECK_COMMAND]);\n  }\n\n  return config;\n}\n\n/**\n * Builds a task that runs each command over every staged file it receives, in as many batches as the command\n * line needs.\n *\n * nano-staged appends a string task's files to ONE command, so a commit staging a few hundred files ran\n * `npm run lint:fix -- <every path>` and failed on Windows with `The command line is too long.`, refusing\n * exactly the whole-repo commits that most need the hook. A function-valued task builds its own commands\n * instead, and these are batched against the same budget `exec()` uses (see `batchCommandArguments`).\n *\n * The commands keep their order: every batch of the first command runs before any batch of the second,\n * because nano-staged runs one key's commands one after another, so a writer still finishes before the next\n * writer, and spellcheck still reads the rewritten files.\n *\n * @param commands - The command prefixes, in the order they run.\n * @returns The task.\n */\nfunction toBatchedTask(commands: readonly string[]): NanoStagedTask {\n  return ({ filenames }) => {\n    const commandArguments = filenames.map((filename) => toCommandArgument(filename));\n    return commands.flatMap((command) => batchCommandArguments(command, commandArguments).map((batch) => `${command} ${batch.join(' ')}`));\n  };\n}\n\n/**\n * Turns a staged file's absolute path into the argument a batched task passes for it.\n *\n * The path is made relative to the working directory, where nano-staged and the task both run, which roughly\n * halves its length and so the number of batches; a path outside it stays absolute. A relative path starting\n * with `-` gets `./`, so no tool reads it as an option.\n *\n * Whitespace and quotes become `?`, because nano-staged's tokenizer cannot carry them (see\n * {@link TOKENIZER_UNSAFE_CHARACTERS_REG_EXP}). Every tool the tasks run (ESLint, dprint, cspell,\n * markdownlint-cli2) takes its paths as globs, and `?` matches exactly the one character it replaced, so the\n * file is still found; a sibling differing only in that character would match too, which costs a lint of an\n * extra file, not a missed one.\n *\n * @param filename - The absolute path of the staged file.\n * @returns The argument.\n */\nfunction toCommandArgument(filename: string): string {\n  const relativePath = relative(process.cwd(), filename);\n  let commandArgument = (relativePath.startsWith('..') || isAbsolute(relativePath) ? filename : relativePath).replaceAll('\\\\', '/');\n  if (commandArgument.startsWith('-')) {\n    commandArgument = `./${commandArgument}`;\n  }\n  return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, '?');\n}\n"],
  "mappings": "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",
  "names": ["process"]
}


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

@@ -12,10 +12,29 @@ export interface GetNanoStagedConfigOptions {
      * Repo-specific file-rewriting tasks, keyed by the nano-staged pattern that claims their files.
      *
      * Each gets spellcheck appended and its files removed from the spellcheck-only key, exactly like the shared
-     * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern.
+     * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern. Each command is a
+     * prefix the staged paths are appended to, in batches, like the shared ones (`npm run lint:fix --`).
      */
     readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;
 }
+/**
+ * A nano-staged configuration whose every key is a {@link NanoStagedTask}.
+ */
+export type NanoStagedConfig = Record<string, NanoStagedTask>;
+/**
+ * A function-valued nano-staged task: it receives the staged files its pattern claims and returns the
+ * commands to run over them, in order.
+ */
+export type NanoStagedTask = (context: NanoStagedTaskContext) => string[];
+/**
+ * What nano-staged passes to a function-valued task.
+ */
+export interface NanoStagedTaskContext {
+    /**
+     * The absolute paths of the staged files the task's pattern claims.
+     */
+    readonly filenames: readonly string[];
+}
 /**
  * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.
  *
@@ -23,14 +42,15 @@ export interface GetNanoStagedConfigOptions {
  * (TypeScript compilation, unit tests) are left to CI.
  *
  * Commands run through the package manager that owns the tree — `npm run ... --`, `bun run ... --`, and
- * so on — so nano-staged file paths are forwarded as CLI arguments.
+ * so on — so nano-staged file paths are forwarded as CLI arguments, batched to fit the command line (see
+ * `toBatchedTask`).
  *
  * Spellcheck is partitioned across the keys rather than given a catch-all `'*'` key (see
  * `partitionSpellcheck`). A repo adding a file-rewriting task of its own passes it to
  * {@link getNanoStagedConfig} as `additionalWriterTasks` rather than spreading this object and adding a key,
  * which would reintroduce the overlap for that key's files.
  */
-export declare const obsidianDevUtilsConfig: Record<string, string[]>;
+export declare const obsidianDevUtilsConfig: NanoStagedConfig;
 /**
  * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.
  *
@@ -51,4 +71,4 @@ export declare const obsidianDevUtilsConfig: Record<string, string[]>;
  * @param options - The optional options.
  * @returns The nano-staged task configuration. Does not return when the opt-out is active.
  */
-export declare function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): Record<string, string[]>;
+export declare function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): NanoStagedConfig;

package/dist/lib/esm/docs-site/api-doc-documented-files.d.mts

@@ -0,0 +1,31 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Which source files the API reference documents, shared by the source walk and by the cross-site linker, so a
+ * link to another package's site never names a page that site's generator skipped.
+ */
+/**
+ * Checks whether a directory's subtree is documented.
+ *
+ * @param name - The directory's name.
+ * @returns `false` for a `@types`, `styles` or `test-helpers` directory.
+ */
+export declare function isDocumentedDirectoryName(name: string): boolean;
+/**
+ * Checks whether a source file is documented, judged by its name alone.
+ *
+ * Excludes: `*.test.ts` (incl. `*.browser.test.ts` / `*.integration.test.ts`), `*.d.ts`, `index.ts`, `__merged.ts`,
+ * `setup.ts` and `*-setup.ts`.
+ *
+ * @param name - The file's name.
+ * @returns Whether the file is documented.
+ */
+export declare function isDocumentedFileName(name: string): boolean;
+/**
+ * Checks whether a module, given by its path relative to the source folder, has documentation pages.
+ *
+ * @param modulePath - The POSIX path relative to the source folder, without its extension (`linters/eslint`).
+ * @returns Whether the generator documents that module.
+ */
+export declare function isDocumentedModulePath(modulePath: string): boolean;

package/dist/lib/esm/docs-site/api-doc-documented-files.mjs

@@ -0,0 +1,25 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+const EXCLUDED_DIR_SEGMENTS = /* @__PURE__ */ new Set(["@types", "styles", "test-helpers"]);
+const EXCLUDED_FILE_NAMES = /* @__PURE__ */ new Set(["__merged.ts", "index.ts", "setup.ts"]);
+function isDocumentedDirectoryName(name) {
+  return !EXCLUDED_DIR_SEGMENTS.has(name);
+}
+function isDocumentedFileName(name) {
+  return name.endsWith(".ts") && !name.endsWith(".d.ts") && !EXCLUDED_FILE_NAMES.has(name) && !name.endsWith("-setup.ts") && !name.endsWith(".test.ts");
+}
+function isDocumentedModulePath(modulePath) {
+  const segments = modulePath.split("/");
+  const directoryNames = segments.slice(0, -1);
+  const fileName = `${segments.slice(-1).join("")}.ts`;
+  return directoryNames.every((directoryName) => isDocumentedDirectoryName(directoryName)) && isDocumentedFileName(fileName);
+}
+export {
+  isDocumentedDirectoryName,
+  isDocumentedFileName,
+  isDocumentedModulePath
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/docs-site/api-doc-package-sites.d.mts

@@ -7,7 +7,8 @@
  * A type is recognized by where its declaration lives, not by its name: a declaration under
  * `node_modules/<package>/dist/lib/{esm,cjs}/<path>.d.{mts,cts}` of a package in
  * {@link ApiDocSettings.packageSites} is the page `<site>api/<path>/<Type>/`, built with the generator's own slug
- * rules, because that site was generated from the same tree.
+ * rules, because that site was generated from the same tree. A module that generator skips (`@types`, `index`,
+ * `*-setup`, ...) has no page, so a type declared there is not linked.
  */
 /**
  * The documentation sites of the `@mnaoumov` packages, which each site links to unless told otherwise.

package/dist/lib/esm/docs-site/api-doc-package-sites.mjs

@@ -37,6 +37,7 @@ ensureBrowserProcess();
 })();
 
 import { getMandatoryNamedGroup } from "@mnaoumov/typescript-lib/reg-exp";
+import { isDocumentedModulePath } from "./api-doc-documented-files.mjs";
 import { toRouteSegmentPreserveCase } from "./api-doc-route-segments.mjs";
 import { getApiDocSettings } from "./api-doc-settings.mjs";
 const PACKAGE_DECLARATION_REG_EXP = /\/node_modules\/(?<Package>(?:@[^/]+\/)?[^/]+)\/dist\/lib\/(?:cjs|esm)\/(?<Path>.+?)(?:\.d\.[cm]?ts)?$/;
@@ -76,7 +77,7 @@ function toPackageTypeUrl(params) {
   }
   const packageName = getMandatoryNamedGroup(match, "Package");
   const path = getMandatoryNamedGroup(match, "Path");
-  if (packageName === settings.packageName) {
+  if (packageName === settings.packageName || !isDocumentedModulePath(path)) {
     return void 0;
   }
   const site = settings.packageSites.get(packageName);
@@ -88,4 +89,4 @@ export {
   getPackageTypeUrl,
   registerPackageDeclaration
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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