@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/forbidden-patterns.mjs

@@ -0,0 +1,108 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { loadEnvFileIfExists } from "./env-toggle.mjs";
+const FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE = "FORBIDDEN_PATTERNS_FILE";
+const REG_EXP_LITERAL_REG_EXP = /^\/(?<source>.+)\/(?<flags>[a-z]*)$/;
+const STATEFUL_FLAGS_REG_EXP = /[gy]/g;
+function findForbiddenPatternMatches(text, patterns) {
+  const matches = [];
+  for (const line of text.split(/\r?\n/)) {
+    for (const pattern of patterns) {
+      const match = pattern.exec(line);
+      if (match) {
+        matches.push({ line, match: match[0] });
+        break;
+      }
+    }
+  }
+  return matches;
+}
+async function readForbiddenPatterns() {
+  loadEnvFileIfExists();
+  const filePath = (process.env[FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE] ?? "").trim();
+  if (filePath === "") {
+    return [];
+  }
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (error) {
+    throw new Error(`${FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names ${filePath}, which cannot be read.`, { cause: error });
+  }
+  const patterns = [];
+  for (const [index, rawLine] of content.split(/\r?\n/).entries()) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    try {
+      patterns.push(toRegExp(line));
+    } catch (error) {
+      throw new Error(`Line ${String(index + 1)} of the forbidden-patterns file ${filePath} is not a valid regular expression.`, { cause: error });
+    }
+  }
+  return patterns;
+}
+function toRegExp(line) {
+  const groups = REG_EXP_LITERAL_REG_EXP.exec(line)?.groups;
+  if (!groups) {
+    return new RegExp(line);
+  }
+  const source = ensureNonNullable(groups["source"]);
+  const flags = ensureNonNullable(groups["flags"]);
+  return new RegExp(source, flags.replaceAll(STATEFUL_FLAGS_REG_EXP, ""));
+}
+export {
+  FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE,
+  findForbiddenPatternMatches,
+  readForbiddenPatterns
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/forbidden-patterns.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * An UNPUBLISHED list of patterns that a release must never publish, read from a file the repository does not\n * contain.\n *\n * The list exists for vocabulary that is private to one maintainer's machine \u2014 an internal tracker's ids, the\n * short names of their projects \u2014 and which a commit subject can carry straight into a generated changelog\n * section. Neither of the two obvious homes works for it: a literal in this library would ship the list to every\n * consumer on npm, and a checked-in per-repository config would publish it in every public repository that used\n * it, permanently. So the list is named by the {@link FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} environment variable\n * (which a gitignored `.env` can set), points at a file outside the repository, and is a no-op wherever it is not\n * set \u2014 a consumer who has not configured it sees no change at all.\n *\n * The file holds one pattern per line. Blank lines and lines starting with `#` are ignored. A line written as a\n * regular expression literal \u2014 `/\\bfoo\\b/i` \u2014 takes the flags it names; any other line is a case-sensitive\n * regular expression source. The global and sticky flags are dropped, since a match here is a yes/no question\n * asked of one line at a time.\n */\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { readFile } from 'node:fs/promises';\nimport process from 'node:process';\n\nimport { loadEnvFileIfExists } from './env-toggle.ts';\n\n/**\n * The environment variable naming the forbidden-patterns file.\n */\nexport const FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE = 'FORBIDDEN_PATTERNS_FILE';\n\n/**\n * One line of text that a forbidden pattern matched.\n */\nexport interface ForbiddenPatternMatch {\n  /**\n   * The line that carries the match.\n   */\n  readonly line: string;\n\n  /**\n   * The text the pattern matched within {@link line}.\n   */\n  readonly match: string;\n}\n\nconst REG_EXP_LITERAL_REG_EXP = /^\\/(?<source>.+)\\/(?<flags>[a-z]*)$/;\nconst STATEFUL_FLAGS_REG_EXP = /[gy]/g;\n\n/**\n * Finds every line of `text` that one of `patterns` matches.\n *\n * @param text - The text to scan, line by line.\n * @param patterns - The patterns, as {@link readForbiddenPatterns} returned them.\n * @returns One {@link ForbiddenPatternMatch} per offending line, naming the first pattern that matched it.\n */\nexport function findForbiddenPatternMatches(text: string, patterns: readonly RegExp[]): ForbiddenPatternMatch[] {\n  const matches: ForbiddenPatternMatch[] = [];\n\n  for (const line of text.split(/\\r?\\n/)) {\n    for (const pattern of patterns) {\n      const match = pattern.exec(line);\n      if (match) {\n        matches.push({ line, match: match[0] });\n        break;\n      }\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Reads the forbidden patterns from the file {@link FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names, loading the\n * optional `.env` first.\n *\n * An unset or blank variable means no list is configured, and yields no patterns. A variable that IS set but\n * names a file that cannot be read throws instead of yielding none: a guard that switches itself off because\n * its list moved is precisely the silent failure it exists to prevent.\n *\n * @returns A {@link Promise} that resolves to the compiled patterns.\n * @throws If the named file cannot be read, or one of its lines is not a valid regular expression.\n */\nexport async function readForbiddenPatterns(): Promise<RegExp[]> {\n  loadEnvFileIfExists();\n  const filePath = (process.env[FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE] ?? '').trim();\n  if (filePath === '') {\n    return [];\n  }\n\n  let content: string;\n  try {\n    content = await readFile(filePath, 'utf-8');\n  } catch (error) {\n    throw new Error(`${FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names ${filePath}, which cannot be read.`, { cause: error });\n  }\n\n  const patterns: RegExp[] = [];\n  for (const [index, rawLine] of content.split(/\\r?\\n/).entries()) {\n    const line = rawLine.trim();\n    if (line === '' || line.startsWith('#')) {\n      continue;\n    }\n\n    try {\n      patterns.push(toRegExp(line));\n    } catch (error) {\n      throw new Error(`Line ${String(index + 1)} of the forbidden-patterns file ${filePath} is not a valid regular expression.`, { cause: error });\n    }\n  }\n\n  return patterns;\n}\n\nfunction toRegExp(line: string): RegExp {\n  const groups = REG_EXP_LITERAL_REG_EXP.exec(line)?.groups;\n  if (!groups) {\n    return new RegExp(line);\n  }\n\n  const source = ensureNonNullable(groups['source']);\n  const flags = ensureNonNullable(groups['flags']);\n  return new RegExp(source, flags.replaceAll(STATEFUL_FLAGS_REG_EXP, ''));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,yBAAyB;AAClC,SAAS,gBAAgB;AACzB,OAAO,aAAa;AAEpB,SAAS,2BAA2B;AAK7B,MAAM,uCAAuC;AAiBpD,MAAM,0BAA0B;AAChC,MAAM,yBAAyB;AASxB,SAAS,4BAA4B,MAAc,UAAsD;AAC9G,QAAM,UAAmC,CAAC;AAE1C,aAAW,QAAQ,KAAK,MAAM,OAAO,GAAG;AACtC,eAAW,WAAW,UAAU;AAC9B,YAAM,QAAQ,QAAQ,KAAK,IAAI;AAC/B,UAAI,OAAO;AACT,gBAAQ,KAAK,EAAE,MAAM,OAAO,MAAM,CAAC,EAAE,CAAC;AACtC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAaA,eAAsB,wBAA2C;AAC/D,sBAAoB;AACpB,QAAM,YAAY,QAAQ,IAAI,oCAAoC,KAAK,IAAI,KAAK;AAChF,MAAI,aAAa,IAAI;AACnB,WAAO,CAAC;AAAA,EACV;AAEA,MAAI;AACJ,MAAI;AACF,cAAU,MAAM,SAAS,UAAU,OAAO;AAAA,EAC5C,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,GAAG,oCAAoC,UAAU,QAAQ,2BAA2B,EAAE,OAAO,MAAM,CAAC;AAAA,EACtH;AAEA,QAAM,WAAqB,CAAC;AAC5B,aAAW,CAAC,OAAO,OAAO,KAAK,QAAQ,MAAM,OAAO,EAAE,QAAQ,GAAG;AAC/D,UAAM,OAAO,QAAQ,KAAK;AAC1B,QAAI,SAAS,MAAM,KAAK,WAAW,GAAG,GAAG;AACvC;AAAA,IACF;AAEA,QAAI;AACF,eAAS,KAAK,SAAS,IAAI,CAAC;AAAA,IAC9B,SAAS,OAAO;AACd,YAAM,IAAI,MAAM,QAAQ,OAAO,QAAQ,CAAC,CAAC,mCAAmC,QAAQ,uCAAuC,EAAE,OAAO,MAAM,CAAC;AAAA,IAC7I;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,SAAS,MAAsB;AACtC,QAAM,SAAS,wBAAwB,KAAK,IAAI,GAAG;AACnD,MAAI,CAAC,QAAQ;AACX,WAAO,IAAI,OAAO,IAAI;AAAA,EACxB;AAEA,QAAM,SAAS,kBAAkB,OAAO,QAAQ,CAAC;AACjD,QAAM,QAAQ,kBAAkB,OAAO,OAAO,CAAC;AAC/C,SAAO,IAAI,OAAO,QAAQ,MAAM,WAAW,wBAAwB,EAAE,CAAC;AACxE;",
  "names": []
}


package/dist/lib/esm/formatters/dprint.d.mts

@@ -0,0 +1,33 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Format the source code.
+ */
+/**
+ * Parameters for the {@link format} function.
+ */
+export interface FormatOptions {
+    /**
+     * The `dprint.json` used when the project has none of its own. Without it, a project with no `dprint.json`
+     * fails.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+    /**
+     * Optional file paths to format. If omitted, formats the entire project.
+     */
+    readonly paths?: string[] | undefined;
+    /**
+     * Whether to rewrite the source code.
+     *
+     * @default `true`
+     */
+    readonly rewrite?: boolean | undefined;
+}
+/**
+ * Format the source code.
+ *
+ * @param options - The {@link FormatOptions}.
+ * @returns A {@link Promise} that resolves when the source code has been formatted.
+ */
+export declare function format(options?: FormatOptions): Promise<void>;

package/dist/lib/esm/formatters/dprint.mjs

@@ -0,0 +1,75 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { assertNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { existsSync } from "node:fs";
+import { resolveToolCommand } from "../package-manager.mjs";
+import { RepoPaths } from "../repo-paths.mjs";
+import {
+  execFromRoot,
+  getRootFolder,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+async function format(options) {
+  const { defaultConfigFilePath, paths, rewrite = true } = options ?? {};
+  const rootFolder = getRootFolder();
+  assertNonNullable(rootFolder, "Root folder not found");
+  let dprintJsonPath = resolvePathFromRootSafe({ path: RepoPaths.DprintJson });
+  if (!existsSync(dprintJsonPath) && defaultConfigFilePath) {
+    dprintJsonPath = defaultConfigFilePath;
+  }
+  if (!existsSync(dprintJsonPath)) {
+    throw new Error("dprint.json not found");
+  }
+  const command = rewrite ? "fmt" : "check";
+  const targets = paths?.length ? paths : ["**/*"];
+  await execFromRoot([...resolveToolCommand({ tool: "dprint" }), command, "--config", dprintJsonPath, { batchedArguments: targets }]);
+}
+export {
+  format
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/formatters/index.d.mts

@@ -0,0 +1,2 @@
+/// <reference path="../index.d.mts" />
+export * as 'dprint' from './dprint.mjs';

package/dist/lib/esm/formatters/index.mjs

@@ -0,0 +1,52 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import * as dprint from "./dprint.mjs";
+export {
+  dprint
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2Zvcm1hdHRlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnZHByaW50JyBmcm9tICcuL2RwcmludC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLFlBQVksWUFBYzsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/fs.d.mts

@@ -0,0 +1,80 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for file system operations.
+ */
+import type { Dirent, ObjectEncodingOptions, PathLike } from 'node:fs';
+/**
+ * Options for controlling the format of the result when returning buffers.
+ *
+ * `directory` is used instead of `folder` to preserve compatibility with `node:fs` module.
+ */
+export type BufferResultOptions = 'buffer' | BufferResultObjectOptions;
+/**
+ * Options for controlling the format of the result when returning Dirent objects.
+ */
+export type DirentResultOptions = DirentResultBaseOptions & ObjectEncodingOptions;
+/**
+ * Options for controlling the format of the result when returning strings.
+ */
+export type StringResultOptions = ObjectEncodingOptions & StringResultBaseOptions | undefined;
+interface BufferResultObjectOptions {
+    /**
+     * Should be set to "buffer" to return buffers.
+     */
+    readonly encoding: 'buffer';
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `false` to return buffers.
+     */
+    readonly withFileTypes?: false;
+}
+interface DirentResultBaseOptions {
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `true` to return Dirent objects.
+     */
+    readonly withFileTypes: true;
+}
+interface StringResultBaseOptions {
+    /**
+     * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Should be set to `false` to return strings.
+     */
+    readonly withFileTypes?: false;
+}
+/**
+ * Reads the contents of a directory and returns an array of strings with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. If not provided, returns strings.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths.
+ */
+export declare function readdirPosix(path: PathLike, options?: StringResultOptions): Promise<string[]>;
+/**
+ * Reads the contents of a directory and returns an array of buffers with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. Specify "buffer" to return buffers.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted buffers.
+ */
+export declare function readdirPosix(path: PathLike, options: BufferResultOptions): Promise<Buffer[]>;
+/**
+ * Reads the contents of a directory and returns an array of Dirent objects with POSIX paths.
+ *
+ * @param path - The path to the directory.
+ * @param options - Options to control the format of the result. Specify `withFileTypes: true` to return Dirent objects.
+ * @returns A {@link Promise} that resolves with an array of POSIX-formatted Dirent objects.
+ */
+export declare function readdirPosix(path: PathLike, options: DirentResultOptions): Promise<Dirent[]>;
+export {};

package/dist/lib/esm/fs.mjs

@@ -0,0 +1,89 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  toPosixBuffer,
+  toPosixPath
+} from "@mnaoumov/typescript-lib/path";
+import { assertNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { readdir } from "node:fs/promises";
+async function readdirPosix(path, options = {}) {
+  if (isStringResultOptions(options)) {
+    const paths = await readdir(path, options);
+    return paths.map((entryPath) => toPosixPath(entryPath));
+  }
+  if (isBufferResultOptions(options)) {
+    const buffers = await readdir(path, options);
+    return buffers.map((buffer) => toPosixBuffer(buffer));
+  }
+  const dirents = await readdir(path, options);
+  for (const dirent of dirents) {
+    dirent.name = toPosixPath(dirent.name);
+    dirent.parentPath = toPosixPath(dirent.parentPath);
+  }
+  return dirents;
+}
+function isBufferResultOptions(options) {
+  assertNonNullable(options);
+  if (options === "buffer") {
+    return true;
+  }
+  const commonOptions = options;
+  return commonOptions.withFileTypes !== true && commonOptions.encoding === "buffer";
+}
+function isStringResultOptions(options) {
+  assertNonNullable(options);
+  if (options === "buffer") {
+    return false;
+  }
+  const commonOptions = options;
+  return !(commonOptions.encoding === "buffer" || commonOptions.withFileTypes === true);
+}
+export {
+  readdirPosix
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/fs.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for file system operations.\n */\n\nimport type {\n  Dirent,\n  ObjectEncodingOptions,\n  PathLike\n} from 'node:fs';\n\nimport {\n  toPosixBuffer,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { readdir } from 'node:fs/promises';\n\n/**\n * Options for controlling the format of the result when returning buffers.\n *\n * `directory` is used instead of `folder` to preserve compatibility with `node:fs` module.\n */\nexport type BufferResultOptions = 'buffer' | BufferResultObjectOptions;\n\n/**\n * Options for controlling the format of the result when returning Dirent objects.\n */\nexport type DirentResultOptions = DirentResultBaseOptions & ObjectEncodingOptions;\n\n/**\n * Options for controlling the format of the result when returning strings.\n */\nexport type StringResultOptions =\n  | ObjectEncodingOptions & StringResultBaseOptions\n  | undefined;\n\ninterface BufferResultObjectOptions {\n  /**\n   * Should be set to \"buffer\" to return buffers.\n   */\n  readonly encoding: 'buffer';\n\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `false` to return buffers.\n   */\n  readonly withFileTypes?: false;\n}\n\n/**\n * Common options for controlling the format of the result.\n */\ninterface CommonOptions {\n  /**\n   * Encoding to use when returning strings.\n   */\n  readonly encoding?: 'buffer' | NodeJS.BufferEncoding;\n\n  /**\n   * Set `true` to return Dirent objects or `false` to return strings or buffers.\n   */\n  readonly withFileTypes?: boolean;\n}\n\ninterface DirentResultBaseOptions {\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `true` to return Dirent objects.\n   */\n  readonly withFileTypes: true;\n}\n\ninterface StringResultBaseOptions {\n  /**\n   * Whether to include subdirectories when reading the directory. If not provided, defaults to `false`.\n   */\n  readonly recursive?: boolean;\n\n  /**\n   * Should be set to `false` to return strings.\n   */\n  readonly withFileTypes?: false;\n}\n\n/**\n * Reads the contents of a directory and returns an array of strings with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. If not provided, returns strings.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths.\n */\nexport async function readdirPosix(path: PathLike, options?: StringResultOptions): Promise<string[]>;\n/**\n * Reads the contents of a directory and returns an array of buffers with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. Specify \"buffer\" to return buffers.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted buffers.\n */\nexport async function readdirPosix(path: PathLike, options: BufferResultOptions): Promise<Buffer[]>;\n/**\n * Reads the contents of a directory and returns an array of Dirent objects with POSIX paths.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result. Specify `withFileTypes: true` to return Dirent objects.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted Dirent objects.\n */\nexport async function readdirPosix(path: PathLike, options: DirentResultOptions): Promise<Dirent[]>;\n/**\n * Reads the contents of a directory and converts file paths or buffer results to POSIX format.\n *\n * @param path - The path to the directory.\n * @param options - Options to control the format of the result.\n * @returns A {@link Promise} that resolves with an array of POSIX-formatted file paths, buffers, or Dirent objects.\n */\nexport async function readdirPosix(\n  path: PathLike,\n  options: BufferResultOptions | DirentResultOptions | StringResultOptions = {}\n): Promise<Buffer[] | Dirent[] | string[]> {\n  if (isStringResultOptions(options)) {\n    const paths = await readdir(path, options);\n    return paths.map((entryPath) => toPosixPath(entryPath));\n  }\n\n  if (isBufferResultOptions(options)) {\n    const buffers = await readdir(path, options);\n    return buffers.map((buffer) => toPosixBuffer(buffer));\n  }\n\n  const dirents = await readdir(path, options);\n  for (const dirent of dirents) {\n    dirent.name = toPosixPath(dirent.name);\n    dirent.parentPath = toPosixPath(dirent.parentPath);\n  }\n\n  return dirents;\n}\n\n/**\n * Type guard to check if the options are for returning buffers.\n *\n * @param options - The options to check.\n * @returns `true` if the options are for returning buffers, otherwise `false`.\n */\nfunction isBufferResultOptions(options: BufferResultOptions | DirentResultOptions | StringResultOptions): options is BufferResultOptions {\n  assertNonNullable(options);\n\n  if (options === 'buffer') {\n    return true;\n  }\n\n  const commonOptions = options as CommonOptions;\n\n  // The encoding check never fails in practice: isStringResultOptions already handles non-buffer encoding before this is called.\n  return commonOptions.withFileTypes !== true && commonOptions.encoding === 'buffer';\n}\n\n/**\n * Type guard to check if the options are for returning strings.\n *\n * @param options - The options to check.\n * @returns `true` if the options are for returning strings, otherwise `false`.\n */\nfunction isStringResultOptions(options: BufferResultOptions | DirentResultOptions | StringResultOptions): options is StringResultOptions {\n  assertNonNullable(options);\n\n  if (options === 'buffer') {\n    return false;\n  }\n\n  const commonOptions = options as CommonOptions;\n\n  return !((commonOptions.encoding === 'buffer') || (commonOptions.withFileTypes === true));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,eAAe;AA4GxB,eAAsB,aACpB,MACA,UAA2E,CAAC,GACnC;AACzC,MAAI,sBAAsB,OAAO,GAAG;AAClC,UAAM,QAAQ,MAAM,QAAQ,MAAM,OAAO;AACzC,WAAO,MAAM,IAAI,CAAC,cAAc,YAAY,SAAS,CAAC;AAAA,EACxD;AAEA,MAAI,sBAAsB,OAAO,GAAG;AAClC,UAAM,UAAU,MAAM,QAAQ,MAAM,OAAO;AAC3C,WAAO,QAAQ,IAAI,CAAC,WAAW,cAAc,MAAM,CAAC;AAAA,EACtD;AAEA,QAAM,UAAU,MAAM,QAAQ,MAAM,OAAO;AAC3C,aAAW,UAAU,SAAS;AAC5B,WAAO,OAAO,YAAY,OAAO,IAAI;AACrC,WAAO,aAAa,YAAY,OAAO,UAAU;AAAA,EACnD;AAEA,SAAO;AACT;AAQA,SAAS,sBAAsB,SAA0G;AACvI,oBAAkB,OAAO;AAEzB,MAAI,YAAY,UAAU;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAGtB,SAAO,cAAc,kBAAkB,QAAQ,cAAc,aAAa;AAC5E;AAQA,SAAS,sBAAsB,SAA0G;AACvI,oBAAkB,OAAO;AAEzB,MAAI,YAAY,UAAU;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAEtB,SAAO,EAAG,cAAc,aAAa,YAAc,cAAc,kBAAkB;AACrF;",
  "names": []
}


package/dist/lib/esm/gate.d.mts

@@ -0,0 +1,93 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * The branch gate: the verification sequence that `updateVersion` runs as its release preflight, available
+ * as a command of its own.
+ *
+ * Four of the preflight's checks — `format:check`, `spellcheck`, `find-overexposed` and `test:coverage` —
+ * are reachable by no other routine command. So the natural branch gate (build, lint, test) can be green
+ * while the release is still going to fail, and the failure arrives at release time rather than in seconds
+ * on the branch.
+ *
+ * This module exists so the two are the same code rather than two lists that agree today: `updateVersion`
+ * calls {@link gate}, and a check added here is reachable from both. What the gate deliberately leaves to
+ * the release path is the clean-repo assertion — a branch gate is run on a dirty tree, which is the whole
+ * point of running it before committing — and the integration suite, which is the one preflight step that
+ * already has a routine command of its own (`npm run test:integration`) and so is not in the class this
+ * module exists for.
+ *
+ * The tests run ONCE, through `test:coverage` where the project defines it and through `test` otherwise.
+ * Running both, as this did until 2026-09-05, was a duplicate everywhere it mattered: a project scopes its
+ * two test scripts to the same vitest projects — every repo in this workspace passes the same `projects`
+ * array to both — so `test:coverage` is `test` plus the threshold flags, over the identical files. It buys
+ * no fail-fast either, because the coverage run fails on exactly the failures the plain run would have
+ * caught. The one thing lost is the ability to switch off only the coverage half: `TEST_COVERAGE=0` now
+ * turns off the gate's whole test step rather than demoting it to `test`.
+ */
+/**
+ * Options for {@link gate}.
+ */
+export interface GateOptions {
+    /**
+     * Whether to run the build. The build is not a verification check — it is kept in the gate because it is
+     * the only step that type-checks the project, and a green lint is not a type-check.
+     *
+     * @default `true`
+     */
+    readonly shouldBuild?: boolean;
+    /**
+     * Whether to run the verification checks. When `false`, only the build runs, which is what
+     * `npm run version -- --no-checks` does.
+     *
+     * @default `true`
+     */
+    readonly shouldRunChecks?: boolean;
+    /**
+     * Whether to run the integration test suite. Off by default, on two reasons that are about COST rather
+     * than about contention — desktop runs stopped contending in `obsidian-integration-testing` 5.0.0, which
+     * gives every run its own user-data dir and CDP port, and the Android emulator that is still shared is
+     * serialized by that package's own `android` setup lock, which waits rather than failing.
+     *
+     * The reasons that do hold: `test:integration` is the one preflight step reachable by a routine command
+     * of its own, unlike the four this gate exists for; and in a project whose suite includes an Android
+     * test it boots an AVD and an Appium server, then queues behind any other Android run for up to that
+     * lock's hour-long acquisition timeout. A command whose whole selling point is answering in seconds must
+     * not start one unasked. The release path opts in, so nothing is skipped before a publish.
+     *
+     * @default `false`
+     */
+    readonly shouldRunIntegrationTests?: boolean;
+}
+/**
+ * Runs the verification sequence that `npm run version` runs as its preflight.
+ *
+ * The order is deliberate. The lockfile check ({@link assertPackageLockIntegrity}) comes first, because it
+ * is an in-process JSON read that takes well under a second. Then come the checks that finish in seconds (`format:check`, `spellcheck`, `lint:md`) run
+ * first, so a typo fails the gate immediately instead of after the coverage run. Each step is dispatched
+ * through the package manager, so a project overriding one of these scripts gets its own version, and each
+ * step carries its own environment off switch.
+ *
+ * Every step but `build` is run with {@link npmRunOptional}, so it is skipped when the project does not define
+ * it: a project that chose no formatter, spell checker, markdown linter or linter has nothing to check there,
+ * and requiring those scripts made `npm run version` die on its first step in exactly those projects. `build`
+ * stays required, because a release with nothing built has nothing to ship. The test step is the one place that reads that skip: `test:coverage` is preferred, and
+ * `test` runs only as its fallback, so the suite is never run twice. The unit tests stay ahead of
+ * `test:integration` for the same fastest-first reason — a broken unit test should fail before an
+ * integration suite is started, not after.
+ *
+ * @param options - The {@link GateOptions} controlling which steps run.
+ * @returns A {@link Promise} that resolves when every step has passed.
+ */
+export declare function gate(options?: GateOptions): Promise<void>;
+/**
+ * Parses the command-line arguments for the gate script.
+ *
+ * The two `--no-` flags switch off steps that are on; `--integration` is the one that switches a step ON,
+ * because {@link GateOptions.shouldRunIntegrationTests} is off by default for cost. It exists so that
+ * default is a choice the caller can make per run rather than one only a programmatic caller can reach.
+ *
+ * @param $arguments - The command-line arguments to parse.
+ * @returns The parsed {@link GateOptions}.
+ */
+export declare function parseGateArguments($arguments: string[]): GateOptions;