@mnaoumov/typescript-dev-toolkit 2.0.0 → 2.2.0

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

@@ -0,0 +1,134 @@
+/*
+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();
+})();
+
+import eslintPluginUnicorn from "eslint-plugin-unicorn";
+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 = eslintPluginUnicorn.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}`);
+    }
+  };
+}
+export {
+  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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,yBAAyB;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,oBAAoB,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":[]}

package/dist/lib/esm/nano-staged-config.d.mts

@@ -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/nano-staged-config.mjs

@@ -3,14 +3,24 @@ THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
 
+import {
+  isAbsolute,
+  relative
+} from "node:path";
 import process from "node:process";
 import {
   isEnvVariableOff,
   loadEnvFileIfExists
 } from "./env-toggle.mjs";
+import {
+  getEffectiveCommandLineLength,
+  getMaxBatchCommandLength
+} from "./exec.mjs";
 import { getPackageManagerRunCommand } from "./package-manager.mjs";
 const PACKAGE_MANAGER_RUN_COMMAND = 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 --`,
@@ -39,6 +49,27 @@ function getNanoStagedConfig(options) {
   }
   return partitionSpellcheck({ ...WRITER_TASKS, ...additionalWriterTasks });
 }
+function batchCommandArguments(prefix, commandArguments) {
+  const emptyLength = getEffectiveCommandLineLength("");
+  const budget = getMaxBatchCommandLength() - EXECUTABLE_PATH_RESERVE - getEffectiveCommandLineLength(prefix);
+  const batches = [];
+  let batch = [];
+  let batchLength = 0;
+  for (const commandArgument of commandArguments) {
+    const argumentLength = 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("/"));
@@ -47,15 +78,29 @@ 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 = relative(process.cwd(), filename);
+  let commandArgument = (relativePath.startsWith("..") || isAbsolute(relativePath) ? filename : relativePath).replaceAll("\\", "/");
+  if (commandArgument.startsWith("-")) {
+    commandArgument = `./${commandArgument}`;
+  }
+  return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, "?");
+}
 export {
   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": ";;;;;AAMA,OAAO,aAAa;AAEpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,mCAAmC;AAqB5C,MAAM,8BAA8B,4BAA4B,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,sBAAoB;AAEpB,MAAI,iBAAiB,wBAAwB,GAAG;AAC9C,YAAQ,OAAO,MAAM,yBAAyB,wBAAwB;AAAA,CAAa;AACnF,YAAQ,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": []
}

+//# 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": ";;;;;AAMA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,OAAO,aAAa;AAEpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,mCAAmC;AA2C5C,MAAM,8BAA8B,4BAA4B,EAAE,KAAK,GAAG;AAE1E,MAAM,qBAAqB,GAAG,2BAA2B;AAQzD,MAAM,0BAA0B;AAShC,MAAM,sCAAsC;AAgB5C,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;AAiBO,MAAM,yBAA2C,oBAAoB,YAAY;AAExF,MAAM,2BAA2B;AAsB1B,SAAS,oBAAoB,SAAwD;AAC1F,sBAAoB;AAEpB,MAAI,iBAAiB,wBAAwB,GAAG;AAC9C,YAAQ,OAAO,MAAM,yBAAyB,wBAAwB;AAAA,CAAa;AACnF,YAAQ,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;AAeA,SAAS,sBAAsB,QAAgB,kBAAiD;AAC9F,QAAM,cAAc,8BAA8B,EAAE;AACpD,QAAM,SAAS,yBAAyB,IAAI,0BAA0B,8BAA8B,MAAM;AAC1G,QAAM,UAAsB,CAAC;AAC7B,MAAI,QAAkB,CAAC;AACvB,MAAI,cAAc;AAElB,aAAW,mBAAmB,kBAAkB;AAC9C,UAAM,iBAAiB,8BAA8B,KAAK,eAAe,GAAG,IAAI;AAChF,QAAI,MAAM,SAAS,KAAK,cAAc,iBAAiB,QAAQ;AAC7D,cAAQ,KAAK,KAAK;AAClB,cAAQ,CAAC;AACT,oBAAc;AAAA,IAChB;AACA,UAAM,KAAK,eAAe;AAC1B,mBAAe;AAAA,EACjB;AAEA,MAAI,MAAM,SAAS,GAAG;AACpB,YAAQ,KAAK,KAAK;AAAA,EACpB;AAEA,SAAO;AACT;AAwBA,SAAS,oBAAoB,aAA4E;AACvG,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,SAA2B;AAAA,IAC/B,CAAC,iBAAiB,GAAG,cAAc,CAAC,kBAAkB,CAAC;AAAA,EACzD;AAEA,aAAW,CAAC,SAAS,QAAQ,KAAK,OAAO,QAAQ,WAAW,GAAG;AAC7D,WAAO,OAAO,IAAI,cAAc,CAAC,GAAG,UAAU,kBAAkB,CAAC;AAAA,EACnE;AAEA,SAAO;AACT;AAkBA,SAAS,cAAc,UAA6C;AAClE,SAAO,CAAC,EAAE,UAAU,MAAM;AACxB,UAAM,mBAAmB,UAAU,IAAI,CAAC,aAAa,kBAAkB,QAAQ,CAAC;AAChF,WAAO,SAAS,QAAQ,CAAC,YAAY,sBAAsB,SAAS,gBAAgB,EAAE,IAAI,CAAC,UAAU,GAAG,OAAO,IAAI,MAAM,KAAK,GAAG,CAAC,EAAE,CAAC;AAAA,EACvI;AACF;AAkBA,SAAS,kBAAkB,UAA0B;AACnD,QAAM,eAAe,SAAS,QAAQ,IAAI,GAAG,QAAQ;AACrD,MAAI,mBAAmB,aAAa,WAAW,IAAI,KAAK,WAAW,YAAY,IAAI,WAAW,cAAc,WAAW,MAAM,GAAG;AAChI,MAAI,gBAAgB,WAAW,GAAG,GAAG;AACnC,sBAAkB,KAAK,eAAe;AAAA,EACxC;AACA,SAAO,gBAAgB,WAAW,qCAAqC,GAAG;AAC5E;",
  "names": []
}


package/docs-site/api-doc-documented-files/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/docs-site/api-doc-documented-files.cjs",
+  "module": "../../dist/lib/esm/docs-site/api-doc-documented-files.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/docs-site/api-doc-documented-files.d.cts"
+}

package/linters/eslint-rules/prefer-logical-operator-over-ternary/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../../dist/lib/cjs/linters/eslint-rules/prefer-logical-operator-over-ternary.cjs",
+  "module": "../../../dist/lib/esm/linters/eslint-rules/prefer-logical-operator-over-ternary.mjs",
+  "type": "module",
+  "types": "../../../dist/lib/cjs/linters/eslint-rules/prefer-logical-operator-over-ternary.d.cts"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/typescript-dev-toolkit",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Generic TypeScript project tooling: build, lint, format, spellcheck, test, gate and release scripts.",
   "keywords": [
     "typescript",
@@ -278,6 +278,7 @@
     "version": "jiti scripts/version.ts"
   },
   "dependencies": {
+    "@commitlint/config-conventional": "^21.2.3",
     "@commitlint/types": "^21.2.0",
     "@eslint-community/eslint-plugin-eslint-comments": "^4.8.1",
     "@eslint/config-helpers": "^0.7.0",
@@ -314,7 +315,6 @@
     "@astrojs/markdown-satteri": "^0.4.4",
     "@astrojs/starlight": "^0.42.6",
     "@commitlint/cli": "^21.2.2",
-    "@commitlint/config-conventional": "^21.2.2",
     "@mnaoumov/typescript-test-toolkit": "^1.0.0",
     "@resvg/resvg-js": "^2.6.2",
     "@total-typescript/ts-reset": "^0.6.1",