@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/cjs/linters/over-exposure.d.cts

@@ -0,0 +1,357 @@
+/// <reference path="../index.d.cts" />
+/**
+ * @file
+ *
+ * Over-exposure analyzer.
+ *
+ * Finds declarations exposed more broadly than their references require, so the exposure can be
+ * tightened:
+ *
+ * - `export`ed symbols referenced only within their own file — the `export` can be dropped.
+ * - `public` class members referenced only inside their own class — they can be `private`.
+ * - `public` class members referenced only inside their own class and its subclasses — they can be
+ *   `protected`.
+ * - `protected` class members referenced only inside their own class — they can be `private`.
+ *
+ * The analysis is whole-program and type-aware: it uses the TypeScript language service's
+ * find-all-references to locate every use of each declaration, then classifies the tightest
+ * exposure that still covers all references. Because `findReferences` does not link a string-literal
+ * argument back to a member declaration when the parameter is a conditional/mapped key type (e.g.
+ * `bind(component, 'someSetting')` where the key is typed `ConditionalKeys<Settings, …>`), member
+ * analysis additionally treats a string literal whose text equals the member name as a reference —
+ * but only when its contextual type is a string-literal type (or union of them) all of whose members
+ * are keys of the declaring class, so incidental same-named strings (`console.log('name')`) are not
+ * miscounted. Members invoked by the framework via registration
+ * rather than by visible references (Obsidian lifecycle hooks, settings-tab `display`, etc.) are
+ * excluded via {@link LIFECYCLE_ALLOWLIST}, as are `override` and `static` members whose exposure is
+ * constrained by a base declaration. ECMAScript hard-private members (`#name`) are also excluded —
+ * they are already maximally private and cannot carry a visibility modifier. A declaration carrying
+ * a TSDoc (`/** … *\/`) documentation comment is likewise excluded — whether a top-level `export` or
+ * a class member, documenting it is a deliberate signal that it is part of the intended public API,
+ * regardless of where it currently happens to be referenced.
+ *
+ * A member referenced only from test files is reported with {@link OverExposureFinding.isForcedByTestOnly}
+ * set, surfacing members widened purely for testability — the canonical case for extracting logic
+ * into an independently testable component instead.
+ *
+ * Beyond reporting, passing `shouldFix` to {@link findOverExposure} / {@link analyzeOverExposure}
+ * rewrites the source in place: dropping the `export` keyword, or replacing/inserting a `private`
+ * or `protected` modifier. Each finding then carries {@link OverExposureFinding.wasFixed} /
+ * {@link OverExposureFinding.skipReason}. Changes that cannot be safely automated — those forced
+ * only by test references, decorated members, or an `export` shared with a still-exported sibling —
+ * are reported as skipped and left untouched.
+ *
+ * Additionally passing `shouldForce` (only meaningful together with `shouldFix`) tightens the
+ * declarations held wide purely by test references too — the production half of the canonical
+ * test-only migration: the member becomes `private` / the `export` is dropped, leaving only the
+ * test to switch to a cast-based access. Decorated members and exports shared with a still-exported
+ * sibling stay skipped even under `shouldForce`, because no edit can be applied safely.
+ */
+import type { CompilerOptions, LanguageService, LanguageServiceHost } from 'typescript' with { 'resolution-mode': 'import' };
+/**
+ * Parameters for {@link analyzeOverExposure}.
+ */
+export interface AnalyzeOverExposureParams {
+    /**
+    The language service to query for references and types.
+     */
+    readonly languageService: LanguageService;
+    /**
+     * Optional callback invoked once per analyzed source file, before that file is processed. The
+     * whole-program reference analysis is slow, so this lets callers report live progress instead of
+     * appearing to hang.
+     */
+    readonly onProgress?: (progress: OverExposureProgress) => void;
+    /**
+     * When `true`, each fixable finding is tightened in place via {@link writeFile} (which must then
+     * be provided), and the returned findings carry {@link OverExposureFinding.wasFixed} /
+     * {@link OverExposureFinding.skipReason}. When `false` or omitted, the analysis only reports.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+    /**
+     * When `true` (only meaningful together with {@link shouldFix}), declarations held wide purely by
+     * test references are tightened too, instead of being skipped with a `test-only`
+     * {@link OverExposureFinding.skipReason}. Decorated members and exports shared with a
+     * still-exported sibling stay skipped regardless, because no edit can be applied safely.
+     *
+     * @default `false`
+     */
+    readonly shouldForce?: boolean | undefined;
+    /**
+     * Absolute (canonical) path of the project's `src` folder. Only declarations in non-test files
+     * under this folder are analyzed; declarations elsewhere (test files, dependencies) are ignored
+     * but still counted as reference sites.
+     */
+    readonly srcFolder: string;
+    /**
+     * Writes the tightened contents of a changed file back to disk. Required when {@link shouldFix}
+     * is `true`; ignored otherwise.
+     *
+     * @param path - Absolute path of the file to write (original casing, as stored in the program).
+     * @param content - The full new file contents.
+     */
+    readonly writeFile?: (path: string, content: string) => void;
+}
+/**
+ * Parameters for {@link createLanguageServiceHost}.
+ */
+export interface CreateLanguageServiceHostParams {
+    /**
+    The compiler options.
+     */
+    readonly compilerOptions: CompilerOptions;
+    /**
+    The files to include in the program.
+     */
+    readonly fileNames: readonly string[];
+    /**
+    The file-system operations used to read sources.
+     */
+    readonly fileSystem: OverExposureFileSystem;
+}
+/**
+ * Parameters for {@link createProjectLanguageService}.
+ */
+export interface CreateProjectLanguageServiceParams {
+    /**
+    Absolute path to the project's `tsconfig.json`.
+     */
+    readonly tsConfigPath: string;
+}
+/**
+ * The exposure level a declaration currently has.
+ */
+export type CurrentExposure = 'export' | 'protected' | 'public';
+/**
+ * Parameters for {@link findOverExposure}.
+ */
+export interface FindOverExposureParams {
+    /**
+     * Optional callback invoked once per analyzed source file, for live progress reporting. Forwarded
+     * to {@link analyzeOverExposure}.
+     */
+    readonly onProgress?: (progress: OverExposureProgress) => void;
+    /**
+    Absolute path to the project root (the folder containing `tsconfig.json` and `src`).
+     */
+    readonly projectFolder: string;
+    /**
+     * When `true`, fixable findings are tightened in place on disk (the `export` keyword is dropped,
+     * or a `private` / `protected` modifier is inserted/replaced). When `false` or omitted, the
+     * project is only analyzed.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+    /**
+     * When `true` (only meaningful together with {@link shouldFix}), declarations held wide purely by
+     * test references are tightened too, instead of being skipped. Decorated members and exports
+     * shared with a still-exported sibling stay skipped regardless. Forwarded to
+     * {@link analyzeOverExposure}.
+     *
+     * @default `false`
+     */
+    readonly shouldForce?: boolean | undefined;
+}
+/**
+ * Options for {@link formatOverExposureFindings}.
+ */
+export interface FormatOverExposureFindingsOptions {
+    /**
+     * When set, file paths in the report are rendered relative to this folder (typically the current
+     * working directory) instead of as absolute paths. Paths outside the folder stay absolute.
+     */
+    readonly baseFolder?: string;
+}
+/**
+ * The subset of file-system operations the language-service host needs. Injecting this (rather than
+ * always using `typescript`'s `sys`) lets tests drive the analyzer against in-memory sources with no
+ * real file-system access.
+ */
+export interface OverExposureFileSystem {
+    /**
+     * Checks whether a directory exists.
+     *
+     * @param path - Directory path.
+     * @returns `true` when the directory exists.
+     */
+    directoryExists: (path: string) => boolean;
+    /**
+     * Checks whether a file exists.
+     *
+     * @param path - File path.
+     * @returns `true` when the file exists.
+     */
+    fileExists: (path: string) => boolean;
+    /**
+     * Resolves the directory that relative paths are resolved against.
+     *
+     * @returns The current working directory.
+     */
+    getCurrentDirectory: () => string;
+    /**
+     * Lists the immediate subdirectories of a directory.
+     *
+     * @param path - Directory path.
+     * @returns The immediate subdirectory names.
+     */
+    getDirectories: (path: string) => string[];
+    /**
+     * Lists the files under a directory, filtered by extension and include/exclude patterns.
+     *
+     * @param path - Root directory.
+     * @param extensions - Extensions to include.
+     * @param exclude - Patterns to exclude.
+     * @param include - Patterns to include.
+     * @param depth - Maximum recursion depth.
+     * @returns The matching file paths.
+     */
+    readDirectory: (path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number) => string[];
+    /**
+     * Reads a file as text.
+     *
+     * @param path - File path.
+     * @returns The file contents, or `undefined` when absent.
+     */
+    readFile: (path: string) => string | undefined;
+}
+/**
+ * A single over-exposed declaration.
+ */
+export interface OverExposureFinding {
+    /**
+    1-based column of the declaration's name.
+     */
+    readonly column: number;
+    /**
+    The current exposure level.
+     */
+    readonly currentExposure: CurrentExposure;
+    /**
+    Absolute path of the file declaring the symbol.
+     */
+    readonly filePath: string;
+    /**
+    `true` when the declaration has no references at all (besides itself).
+     */
+    readonly hasNoReferences: boolean;
+    /**
+     * `true` when the declaration would qualify for a tighter exposure if not for references coming
+     * exclusively from test files — i.e. it is exposed purely for testability.
+     */
+    readonly isForcedByTestOnly: boolean;
+    /**
+    `true` for a class member, `false` for a top-level export.
+     */
+    readonly isMember: boolean;
+    /**
+    1-based line of the declaration's name.
+     */
+    readonly line: number;
+    /**
+    The declared name.
+     */
+    readonly name: string;
+    /**
+     * In a fix run, why this finding was left untouched instead of tightened; `null` when it was
+     * fixed or when the analysis only reported (`shouldFix` off).
+     */
+    readonly skipReason: null | OverExposureSkipReason;
+    /**
+    The exposure the declaration could be tightened to.
+     */
+    readonly suggestedExposure: SuggestedExposure;
+    /**
+    `true` when a fix run tightened this declaration in place. Always `false` in a report run.
+     */
+    readonly wasFixed: boolean;
+}
+/**
+ * Progress reported while analyzing a project, one event per analyzed source file.
+ */
+export interface OverExposureProgress {
+    /**
+    Number of source files fully analyzed before the current one (0-based).
+     */
+    readonly analyzedFileCount: number;
+    /**
+    Absolute (canonical) path of the source file about to be analyzed.
+     */
+    readonly currentFilePath: string;
+    /**
+    Total number of source files that will be analyzed.
+     */
+    readonly totalFileCount: number;
+}
+/**
+ * Why a fix run left a finding untouched:
+ *
+ * - `decorated` — the member carries a decorator, so the modifier insertion point is ambiguous.
+ * - `shared-export` — the `export` keyword is shared with a still-exported sibling declarator.
+ * - `test-only` — the declaration is exposed purely for tests, so tightening would break the test.
+ */
+export type OverExposureSkipReason = 'decorated' | 'shared-export' | 'test-only';
+/**
+ * The (tighter) exposure level a declaration could be reduced to.
+ */
+export type SuggestedExposure = 'file-local' | 'private' | 'protected';
+/**
+ * Lifecycle and framework members invoked by Obsidian or a base class via registration rather than
+ * by references the language service can see. Tightening these would break the framework contract,
+ * so they are never reported.
+ */
+export declare const LIFECYCLE_ALLOWLIST: ReadonlySet<string>;
+/**
+ * Analyzes a project (already loaded into a language service) for over-exposed declarations, and —
+ * when {@link AnalyzeOverExposureParams.shouldFix} is set — tightens every fixable finding in place
+ * via {@link AnalyzeOverExposureParams.writeFile}. Findings that cannot be safely automated (exposed
+ * only for tests, decorated, or sharing an `export` keyword with a still-exported sibling) carry a
+ * {@link OverExposureFinding.skipReason} and are left untouched — unless
+ * {@link AnalyzeOverExposureParams.shouldForce} is set, which additionally tightens the test-only
+ * findings (decorated and shared-export ones still stay skipped).
+ *
+ * @param params - The {@link AnalyzeOverExposureParams}.
+ * @returns The over-exposed declarations, in discovery order.
+ */
+export declare function analyzeOverExposure(params: AnalyzeOverExposureParams): OverExposureFinding[];
+/**
+ * Builds a {@link LanguageServiceHost} backed by an explicit file list and file system.
+ *
+ * @param params - The {@link CreateLanguageServiceHostParams}.
+ * @returns The language-service host.
+ */
+export declare function createLanguageServiceHost(params: CreateLanguageServiceHostParams): LanguageServiceHost;
+/**
+ * Builds a language service over every file in a project's `tsconfig.json`.
+ *
+ * @param params - The {@link CreateProjectLanguageServiceParams}.
+ * @returns A language service ready for {@link analyzeOverExposure}.
+ */
+export declare function createProjectLanguageService(params: CreateProjectLanguageServiceParams): LanguageService;
+/**
+ * Finds over-exposed declarations in a project on disk. When
+ * {@link FindOverExposureParams.shouldFix} is set, each fixable finding is also tightened in place
+ * (rewriting the affected source files via `typescript`'s `sys.writeFile`).
+ *
+ * @param params - The {@link FindOverExposureParams}.
+ * @returns The over-exposed declarations.
+ */
+export declare function findOverExposure(params: FindOverExposureParams): OverExposureFinding[];
+/**
+ * Formats over-exposure findings as a human-readable report, using the grouped layout of ESLint's
+ * `stylish` formatter. Findings are grouped by file and sorted by line: each file is rendered as a
+ * `path` header line, followed by one indented `  line:column  change -- reason` row per finding (the
+ * `line:column` is right-padded so the rows align within a file). Terminals such as VS Code render
+ * each indented `line:column` as a clickable link — resolved against the file header above it — that
+ * jumps straight to the declaration. File groups are separated by a blank line. In a fix run (findings
+ * carrying {@link OverExposureFinding.wasFixed} / {@link OverExposureFinding.skipReason}) each change
+ * row is suffixed with `[fixed]` or `[skipped: …]`, and the trailing summary appends the fixed/skipped
+ * counts.
+ *
+ * @param findings - The findings to format.
+ * @param options - The {@link FormatOverExposureFindingsOptions}.
+ * @returns The report text. Empty-finding input yields a single "no findings" line.
+ */
+export declare function formatOverExposureFindings(findings: readonly OverExposureFinding[], options?: FormatOverExposureFindingsOptions): string;

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

@@ -0,0 +1,148 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 nano_staged_config_exports = {};
+__export(nano_staged_config_exports, {
+  getNanoStagedConfig: () => getNanoStagedConfig,
+  obsidianDevUtilsConfig: () => obsidianDevUtilsConfig
+});
+module.exports = __toCommonJS(nano_staged_config_exports);
+var import_node_process = __toESM(__extractDefault(require('node:process')), 1);
+var import_env_toggle = require('./env-toggle.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 WRITER_TASKS = {
+  "*.{ts,tsx,mts}": [
+    `${PACKAGE_MANAGER_RUN_COMMAND} lint:fix --`,
+    `${PACKAGE_MANAGER_RUN_COMMAND} format --`
+  ],
+  "*.md": [
+    `${PACKAGE_MANAGER_RUN_COMMAND} lint:md:fix --`
+  ]
+};
+const obsidianDevUtilsConfig = partitionSpellcheck(WRITER_TASKS);
+const NANO_STAGED_ENV_VARIABLE = "NANO_STAGED";
+function getNanoStagedConfig(options) {
+  (0, import_env_toggle.loadEnvFileIfExists)();
+  if ((0, import_env_toggle.isEnvVariableOff)(NANO_STAGED_ENV_VARIABLE)) {
+    import_node_process.default.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).
+`);
+    import_node_process.default.exit(0);
+  }
+  const additionalWriterTasks = options?.additionalWriterTasks ?? {};
+  if (Object.keys(additionalWriterTasks).length === 0) {
+    return obsidianDevUtilsConfig;
+  }
+  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(WRITER_TASKS, pattern));
+  if (duplicatePattern !== void 0) {
+    throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);
+  }
+  return partitionSpellcheck({ ...WRITER_TASKS, ...additionalWriterTasks });
+}
+function partitionSpellcheck(writerTasks) {
+  const patterns = Object.keys(writerTasks);
+  const patternWithSlash = patterns.find((pattern) => pattern.includes("/"));
+  if (patternWithSlash !== void 0) {
+    throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);
+  }
+  const complementPattern = `!(${patterns.map((pattern) => `${pattern}!(?)`).join("|")})*`;
+  const config = {
+    [complementPattern]: [SPELLCHECK_COMMAND]
+  };
+  for (const [pattern, commands] of Object.entries(writerTasks)) {
+    config[pattern] = [...commands, SPELLCHECK_COMMAND];
+  }
+  return config;
+}
+// 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"]
}


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

@@ -0,0 +1,54 @@
+/// <reference path="./index.d.cts" />
+/**
+ * @file
+ *
+ * Shared nano-staged configuration for pre-commit hooks.
+ */
+/**
+ * Options for {@link getNanoStagedConfig}.
+ */
+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.
+     */
+    readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;
+}
+/**
+ * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.
+ *
+ * Only includes tools that can operate on individual files. Whole-project checks
+ * (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.
+ *
+ * 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[]>;
+/**
+ * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.
+ *
+ * Loads a gitignored `.env` if present, then — when `NANO_STAGED` is set to an off value (`0`, `false`,
+ * `off`, or `no`) — prints a notice and exits the process successfully so the pre-commit checks are
+ * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the
+ * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}, or — when
+ * `additionalWriterTasks` are given — the same configuration re-partitioned with those writers added.
+ *
+ * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one
+ * every npm script gets — but both share the same notion of an off value, via {@link isEnvVariableOff}.
+ *
+ * This is a function rather than module-level code so importing the package barrel never triggers the
+ * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry. Resolving the
+ * package manager is the one thing that does run at module scope, and it does neither of those two
+ * things — it only probes for a lockfile.
+ *
+ * @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[]>;

package/dist/lib/cjs/npm-publish.cjs

@@ -0,0 +1,93 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var npm_publish_exports = {};
+__export(npm_publish_exports, {
+  publish: () => publish
+});
+module.exports = __toCommonJS(npm_publish_exports);
+var import_root = require('./root.cjs');
+async function publish(isBeta) {
+  const tag = isBeta ? "beta" : "latest";
+  await (0, import_root.execFromRoot)(["npm", "publish", "--tag", tag]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  publish
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL25wbS1wdWJsaXNoLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQ29udGFpbnMgdXRpbGl0eSBmdW5jdGlvbnMgZm9yIE5QTSBwdWJsaXNoLlxuICovXG5cbmltcG9ydCB7IGV4ZWNGcm9tUm9vdCB9IGZyb20gJy4vcm9vdC50cyc7XG5cbi8qKlxuICogUHVibGlzaCB0byBOUE0uXG4gKlxuICogQXV0aGVudGljYXRpb24gaXMgaW50ZW50aW9uYWxseSBub3QgaGFuZGxlZCBoZXJlLiBUaGUgcHVibGlzaCBpcyBleHBlY3RlZCB0byBydW4gZnJvbSBhIENJIGpvYlxuICogY29uZmlndXJlZCBhcyBhIHtAbGluayBodHRwczovL2RvY3MubnBtanMuY29tL3RydXN0ZWQtcHVibGlzaGVycyB8IHRydXN0ZWQgcHVibGlzaGVyfSBvbiBucG1qcy5jb20sXG4gKiB3aGVyZSB0aGUgbnBtIENMSSBleGNoYW5nZXMgdGhlIGpvYidzIHNob3J0LWxpdmVkIE9JREMgdG9rZW4gZm9yIGEgcHVibGlzaCBncmFudCBvbiBpdHMgb3duLiBObyBOUE1cbiAqIHRva2VuIGlzIHJlYWQsIHdyaXR0ZW4sIG9yIHN0b3JlZCwgYW5kIHRoZSBwdWJsaXNoZWQgcGFja2FnZSBnZXRzIHByb3ZlbmFuY2UgZm9yIGZyZWUuXG4gKlxuICogUmVxdWlyZXMgbnBtIGAxMS41LjFgIG9yIGxhdGVyLlxuICpcbiAqIEBwYXJhbSBpc0JldGEgLSBXaGV0aGVyIHRvIHB1Ymxpc2ggdG8gdGhlIGJldGEgTlBNIHJlZ2lzdHJ5LlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcHVibGlzaChpc0JldGE/OiBib29sZWFuKTogUHJvbWlzZTx2b2lkPiB7XG4gIGNvbnN0IHRhZyA9IGlzQmV0YSA/ICdiZXRhJyA6ICdsYXRlc3QnO1xuICBhd2FpdCBleGVjRnJvbVJvb3QoWyducG0nLCAncHVibGlzaCcsICctLXRhZycsIHRhZ10pO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQU1BLGtCQUE2QjtBQWM3QixlQUFzQixRQUFRLFFBQWlDO0FBQzdELFFBQU0sTUFBTSxTQUFTLFNBQVM7QUFDOUIsWUFBTSwwQkFBYSxDQUFDLE9BQU8sV0FBVyxTQUFTLEdBQUcsQ0FBQztBQUNyRDsiLAogICJuYW1lcyI6IFtdCn0K