@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/gate.mjs

@@ -0,0 +1,106 @@
+/*
+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 { parseArgs } from "node:util";
+import { isEnvVariableOff } from "./env-toggle.mjs";
+import {
+  npmRun,
+  npmRunOptional,
+  NpmRunOptionalResult
+} from "./npm-run.mjs";
+import { assertPackageLockIntegrity } from "./package-lock-integrity.mjs";
+const PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE = "PACKAGE_LOCK_INTEGRITY";
+async function gate(options = {}) {
+  const {
+    shouldBuild = true,
+    shouldRunChecks = true,
+    shouldRunIntegrationTests = false
+  } = options;
+  if (shouldRunChecks) {
+    if (!isEnvVariableOff(PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE)) {
+      await assertPackageLockIntegrity();
+    }
+    await npmRunOptional("format:check");
+    await npmRunOptional("spellcheck");
+    await npmRunOptional("lint:md");
+  }
+  if (shouldBuild) {
+    await npmRun("build");
+  }
+  if (!shouldRunChecks) {
+    return;
+  }
+  await npmRunOptional("lint");
+  await npmRunOptional("find-overexposed");
+  if (await npmRunOptional("test:coverage") === NpmRunOptionalResult.Skipped) {
+    await npmRunOptional("test");
+  }
+  if (shouldRunIntegrationTests) {
+    await npmRunOptional("test:integration");
+  }
+}
+function parseGateArguments($arguments) {
+  const { values } = parseArgs({
+    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.
+    args: $arguments,
+    options: {
+      "integration": { type: "boolean" },
+      "no-build": { type: "boolean" },
+      "no-checks": { type: "boolean" }
+    }
+  });
+  return {
+    shouldBuild: !(values["no-build"] ?? false),
+    shouldRunChecks: !(values["no-checks"] ?? false),
+    shouldRunIntegrationTests: values.integration ?? false
+  };
+}
+export {
+  gate,
+  parseGateArguments
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/gate.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The branch gate: the verification sequence that `updateVersion` runs as its release preflight, available\n * as a command of its own.\n *\n * Four of the preflight's checks \u2014 `format:check`, `spellcheck`, `find-overexposed` and `test:coverage` \u2014\n * are reachable by no other routine command. So the natural branch gate (build, lint, test) can be green\n * while the release is still going to fail, and the failure arrives at release time rather than in seconds\n * on the branch.\n *\n * This module exists so the two are the same code rather than two lists that agree today: `updateVersion`\n * calls {@link gate}, and a check added here is reachable from both. What the gate deliberately leaves to\n * the release path is the clean-repo assertion \u2014 a branch gate is run on a dirty tree, which is the whole\n * point of running it before committing \u2014 and the integration suite, which is the one preflight step that\n * already has a routine command of its own (`npm run test:integration`) and so is not in the class this\n * module exists for.\n *\n * The tests run ONCE, through `test:coverage` where the project defines it and through `test` otherwise.\n * Running both, as this did until 2026-09-05, was a duplicate everywhere it mattered: a project scopes its\n * two test scripts to the same vitest projects \u2014 every repo in this workspace passes the same `projects`\n * array to both \u2014 so `test:coverage` is `test` plus the threshold flags, over the identical files. It buys\n * no fail-fast either, because the coverage run fails on exactly the failures the plain run would have\n * caught. The one thing lost is the ability to switch off only the coverage half: `TEST_COVERAGE=0` now\n * turns off the gate's whole test step rather than demoting it to `test`.\n */\n\nimport { parseArgs } from 'node:util';\n\nimport { isEnvVariableOff } from './env-toggle.ts';\nimport {\n  npmRun,\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { assertPackageLockIntegrity } from './package-lock-integrity.ts';\n\n/**\n * The off switch for the lockfile check. The check is no npm script, so npm cannot derive a switch from a\n * script name for it, but the name follows the same pattern.\n */\nconst PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE = 'PACKAGE_LOCK_INTEGRITY';\n\n/**\n * Options for {@link gate}.\n */\nexport interface GateOptions {\n  /**\n   * Whether to run the build. The build is not a verification check \u2014 it is kept in the gate because it is\n   * the only step that type-checks the project, and a green lint is not a type-check.\n   *\n   * @default `true`\n   */\n  readonly shouldBuild?: boolean;\n\n  /**\n   * Whether to run the verification checks. When `false`, only the build runs, which is what\n   * `npm run version -- --no-checks` does.\n   *\n   * @default `true`\n   */\n  readonly shouldRunChecks?: boolean;\n\n  /**\n   * Whether to run the integration test suite. Off by default, on two reasons that are about COST rather\n   * than about contention \u2014 desktop runs stopped contending in `obsidian-integration-testing` 5.0.0, which\n   * gives every run its own user-data dir and CDP port, and the Android emulator that is still shared is\n   * serialized by that package's own `android` setup lock, which waits rather than failing.\n   *\n   * The reasons that do hold: `test:integration` is the one preflight step reachable by a routine command\n   * of its own, unlike the four this gate exists for; and in a project whose suite includes an Android\n   * test it boots an AVD and an Appium server, then queues behind any other Android run for up to that\n   * lock's hour-long acquisition timeout. A command whose whole selling point is answering in seconds must\n   * not start one unasked. The release path opts in, so nothing is skipped before a publish.\n   *\n   * @default `false`\n   */\n  readonly shouldRunIntegrationTests?: boolean;\n}\n\n/**\n * Runs the verification sequence that `npm run version` runs as its preflight.\n *\n * The order is deliberate. The lockfile check ({@link assertPackageLockIntegrity}) comes first, because it\n * 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\n * first, so a typo fails the gate immediately instead of after the coverage run. Each step is dispatched\n * through the package manager, so a project overriding one of these scripts gets its own version, and each\n * step carries its own environment off switch.\n *\n * Every step but `build` is run with {@link npmRunOptional}, so it is skipped when the project does not define\n * it: a project that chose no formatter, spell checker, markdown linter or linter has nothing to check there,\n * and requiring those scripts made `npm run version` die on its first step in exactly those projects. `build`\n * 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\n * `test` runs only as its fallback, so the suite is never run twice. The unit tests stay ahead of\n * `test:integration` for the same fastest-first reason \u2014 a broken unit test should fail before an\n * integration suite is started, not after.\n *\n * @param options - The {@link GateOptions} controlling which steps run.\n * @returns A {@link Promise} that resolves when every step has passed.\n */\nexport async function gate(options: GateOptions = {}): Promise<void> {\n  const {\n    shouldBuild = true,\n    shouldRunChecks = true,\n    shouldRunIntegrationTests = false\n  } = options;\n\n  if (shouldRunChecks) {\n    if (!isEnvVariableOff(PACKAGE_LOCK_INTEGRITY_ENV_VARIABLE)) {\n      await assertPackageLockIntegrity();\n    }\n\n    await npmRunOptional('format:check');\n    await npmRunOptional('spellcheck');\n    await npmRunOptional('lint:md');\n  }\n\n  if (shouldBuild) {\n    await npmRun('build');\n  }\n\n  if (!shouldRunChecks) {\n    return;\n  }\n\n  await npmRunOptional('lint');\n  await npmRunOptional('find-overexposed');\n\n  if (await npmRunOptional('test:coverage') === NpmRunOptionalResult.Skipped) {\n    await npmRunOptional('test');\n  }\n\n  if (shouldRunIntegrationTests) {\n    await npmRunOptional('test:integration');\n  }\n}\n\n/**\n * Parses the command-line arguments for the gate script.\n *\n * The two `--no-` flags switch off steps that are on; `--integration` is the one that switches a step ON,\n * because {@link GateOptions.shouldRunIntegrationTests} is off by default for cost. It exists so that\n * default is a choice the caller can make per run rather than one only a programmatic caller can reach.\n *\n * @param $arguments - The command-line arguments to parse.\n * @returns The parsed {@link GateOptions}.\n */\nexport function parseGateArguments($arguments: string[]): GateOptions {\n  const { values } = parseArgs({\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.\n    args: $arguments,\n    options: {\n      'integration': { type: 'boolean' },\n      'no-build': { type: 'boolean' },\n      'no-checks': { type: 'boolean' }\n    }\n  });\n\n  return {\n    shouldBuild: !(values['no-build'] ?? false),\n    shouldRunChecks: !(values['no-checks'] ?? false),\n    shouldRunIntegrationTests: values.integration ?? false\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAS,iBAAiB;AAE1B,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,kCAAkC;AAM3C,MAAM,sCAAsC;AA2D5C,eAAsB,KAAK,UAAuB,CAAC,GAAkB;AACnE,QAAM;AAAA,IACJ,cAAc;AAAA,IACd,kBAAkB;AAAA,IAClB,4BAA4B;AAAA,EAC9B,IAAI;AAEJ,MAAI,iBAAiB;AACnB,QAAI,CAAC,iBAAiB,mCAAmC,GAAG;AAC1D,YAAM,2BAA2B;AAAA,IACnC;AAEA,UAAM,eAAe,cAAc;AACnC,UAAM,eAAe,YAAY;AACjC,UAAM,eAAe,SAAS;AAAA,EAChC;AAEA,MAAI,aAAa;AACf,UAAM,OAAO,OAAO;AAAA,EACtB;AAEA,MAAI,CAAC,iBAAiB;AACpB;AAAA,EACF;AAEA,QAAM,eAAe,MAAM;AAC3B,QAAM,eAAe,kBAAkB;AAEvC,MAAI,MAAM,eAAe,eAAe,MAAM,qBAAqB,SAAS;AAC1E,UAAM,eAAe,MAAM;AAAA,EAC7B;AAEA,MAAI,2BAA2B;AAC7B,UAAM,eAAe,kBAAkB;AAAA,EACzC;AACF;AAYO,SAAS,mBAAmB,YAAmC;AACpE,QAAM,EAAE,OAAO,IAAI,UAAU;AAAA;AAAA,IAE3B,MAAM;AAAA,IACN,SAAS;AAAA,MACP,eAAe,EAAE,MAAM,UAAU;AAAA,MACjC,YAAY,EAAE,MAAM,UAAU;AAAA,MAC9B,aAAa,EAAE,MAAM,UAAU;AAAA,IACjC;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,aAAa,EAAE,OAAO,UAAU,KAAK;AAAA,IACrC,iBAAiB,EAAE,OAAO,WAAW,KAAK;AAAA,IAC1C,2BAA2B,OAAO,eAAe;AAAA,EACnD;AACF;",
  "names": []
}


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

@@ -0,0 +1,37 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * Git-derived file listings for the repo-walking scripts.
+ *
+ * Tooling that walks the repository must skip whatever `.gitignore` skips — otherwise every script grows its
+ * own hand-maintained ignore list, the lists drift apart, and a path that is gitignored but not enumerated
+ * (a nested `node_modules` under a test fixture, say) is walked anyway. Most tools have a native switch for
+ * this; the ones that do not take a file list instead, and that is what this module produces.
+ *
+ * Asking git rather than parsing `.gitignore` is deliberate: it honors nested ignore files, `!` negations,
+ * `.git/info/exclude`, and the user's global excludes, at no cost to us.
+ */
+/**
+ * Options for {@link getNonIgnoredFiles}.
+ */
+export interface GetNonIgnoredFilesOptions {
+    /**
+     * Git pathspecs limiting the listing, e.g. `['*.md']`. When omitted, every non-ignored file is listed.
+     *
+     * @default `[]`
+     */
+    readonly patterns?: readonly string[] | undefined;
+}
+/**
+ * Lists the repository files that `.gitignore` does not exclude.
+ *
+ * Covers both tracked files and untracked-but-not-ignored ones, so a brand-new file is checked before it is
+ * ever committed.
+ *
+ * @param options - The {@link GetNonIgnoredFilesOptions}.
+ * @returns A {@link Promise} that resolves with the matching paths, relative to the root folder and
+ * separated by `/`; or with `null` when git cannot answer — it is not installed, or the project is not a
+ * git repository (a tarball checkout, for instance). Callers fall back to their own listing in that case.
+ */
+export declare function getNonIgnoredFiles(options?: GetNonIgnoredFilesOptions): Promise<null | string[]>;

package/dist/lib/esm/git.mjs

@@ -0,0 +1,72 @@
+/*
+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 { execFromRoot } from "./root.mjs";
+const NUL_SEPARATOR = "\0";
+async function getNonIgnoredFiles(options) {
+  const { patterns = [] } = options ?? {};
+  const command = [
+    "git",
+    "ls-files",
+    "--cached",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    ...patterns.length > 0 ? ["--", ...patterns] : []
+  ];
+  let stdout;
+  try {
+    stdout = await execFromRoot(command, { isQuiet: true });
+  } catch {
+    return null;
+  }
+  return [...new Set(stdout.split(NUL_SEPARATOR).filter((path) => path !== ""))];
+}
+export {
+  getNonIgnoredFiles
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2dpdC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEdpdC1kZXJpdmVkIGZpbGUgbGlzdGluZ3MgZm9yIHRoZSByZXBvLXdhbGtpbmcgc2NyaXB0cy5cbiAqXG4gKiBUb29saW5nIHRoYXQgd2Fsa3MgdGhlIHJlcG9zaXRvcnkgbXVzdCBza2lwIHdoYXRldmVyIGAuZ2l0aWdub3JlYCBza2lwcyBcdTIwMTQgb3RoZXJ3aXNlIGV2ZXJ5IHNjcmlwdCBncm93cyBpdHNcbiAqIG93biBoYW5kLW1haW50YWluZWQgaWdub3JlIGxpc3QsIHRoZSBsaXN0cyBkcmlmdCBhcGFydCwgYW5kIGEgcGF0aCB0aGF0IGlzIGdpdGlnbm9yZWQgYnV0IG5vdCBlbnVtZXJhdGVkXG4gKiAoYSBuZXN0ZWQgYG5vZGVfbW9kdWxlc2AgdW5kZXIgYSB0ZXN0IGZpeHR1cmUsIHNheSkgaXMgd2Fsa2VkIGFueXdheS4gTW9zdCB0b29scyBoYXZlIGEgbmF0aXZlIHN3aXRjaCBmb3JcbiAqIHRoaXM7IHRoZSBvbmVzIHRoYXQgZG8gbm90IHRha2UgYSBmaWxlIGxpc3QgaW5zdGVhZCwgYW5kIHRoYXQgaXMgd2hhdCB0aGlzIG1vZHVsZSBwcm9kdWNlcy5cbiAqXG4gKiBBc2tpbmcgZ2l0IHJhdGhlciB0aGFuIHBhcnNpbmcgYC5naXRpZ25vcmVgIGlzIGRlbGliZXJhdGU6IGl0IGhvbm9ycyBuZXN0ZWQgaWdub3JlIGZpbGVzLCBgIWAgbmVnYXRpb25zLFxuICogYC5naXQvaW5mby9leGNsdWRlYCwgYW5kIHRoZSB1c2VyJ3MgZ2xvYmFsIGV4Y2x1ZGVzLCBhdCBubyBjb3N0IHRvIHVzLlxuICovXG5cbmltcG9ydCB7IGV4ZWNGcm9tUm9vdCB9IGZyb20gJy4vcm9vdC50cyc7XG5cbi8qKlxuICogT3B0aW9ucyBmb3Ige0BsaW5rIGdldE5vbklnbm9yZWRGaWxlc30uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR2V0Tm9uSWdub3JlZEZpbGVzT3B0aW9ucyB7XG4gIC8qKlxuICAgKiBHaXQgcGF0aHNwZWNzIGxpbWl0aW5nIHRoZSBsaXN0aW5nLCBlLmcuIGBbJyoubWQnXWAuIFdoZW4gb21pdHRlZCwgZXZlcnkgbm9uLWlnbm9yZWQgZmlsZSBpcyBsaXN0ZWQuXG4gICAqXG4gICAqIEBkZWZhdWx0IGBbXWBcbiAgICovXG4gIHJlYWRvbmx5IHBhdHRlcm5zPzogcmVhZG9ubHkgc3RyaW5nW10gfCB1bmRlZmluZWQ7XG59XG5cbi8qKlxuICogU2VwYXJhdGVzIHRoZSBwYXRocyBpbiBgZ2l0IGxzLWZpbGVzIC16YCBvdXRwdXQuIFVzaW5nIHRoZSBOVUwgZm9ybSBhdm9pZHMgZ2l0J3MgcXVvdGluZyBvZiBwYXRocyB0aGF0XG4gKiBjb250YWluIHVudXN1YWwgY2hhcmFjdGVycywgd2hpY2ggd291bGQgb3RoZXJ3aXNlIGhhdmUgdG8gYmUgdW5lc2NhcGVkLlxuICovXG5jb25zdCBOVUxfU0VQQVJBVE9SID0gJ1xcMCc7XG5cbi8qKlxuICogTGlzdHMgdGhlIHJlcG9zaXRvcnkgZmlsZXMgdGhhdCBgLmdpdGlnbm9yZWAgZG9lcyBub3QgZXhjbHVkZS5cbiAqXG4gKiBDb3ZlcnMgYm90aCB0cmFja2VkIGZpbGVzIGFuZCB1bnRyYWNrZWQtYnV0LW5vdC1pZ25vcmVkIG9uZXMsIHNvIGEgYnJhbmQtbmV3IGZpbGUgaXMgY2hlY2tlZCBiZWZvcmUgaXQgaXNcbiAqIGV2ZXIgY29tbWl0dGVkLlxuICpcbiAqIEBwYXJhbSBvcHRpb25zIC0gVGhlIHtAbGluayBHZXROb25JZ25vcmVkRmlsZXNPcHRpb25zfS5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgd2l0aCB0aGUgbWF0Y2hpbmcgcGF0aHMsIHJlbGF0aXZlIHRvIHRoZSByb290IGZvbGRlciBhbmRcbiAqIHNlcGFyYXRlZCBieSBgL2A7IG9yIHdpdGggYG51bGxgIHdoZW4gZ2l0IGNhbm5vdCBhbnN3ZXIgXHUyMDE0IGl0IGlzIG5vdCBpbnN0YWxsZWQsIG9yIHRoZSBwcm9qZWN0IGlzIG5vdCBhXG4gKiBnaXQgcmVwb3NpdG9yeSAoYSB0YXJiYWxsIGNoZWNrb3V0LCBmb3IgaW5zdGFuY2UpLiBDYWxsZXJzIGZhbGwgYmFjayB0byB0aGVpciBvd24gbGlzdGluZyBpbiB0aGF0IGNhc2UuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZXROb25JZ25vcmVkRmlsZXMob3B0aW9ucz86IEdldE5vbklnbm9yZWRGaWxlc09wdGlvbnMpOiBQcm9taXNlPG51bGwgfCBzdHJpbmdbXT4ge1xuICBjb25zdCB7IHBhdHRlcm5zID0gW10gfSA9IG9wdGlvbnMgPz8ge307XG4gIGNvbnN0IGNvbW1hbmQgPSBbXG4gICAgJ2dpdCcsXG4gICAgJ2xzLWZpbGVzJyxcbiAgICAnLS1jYWNoZWQnLFxuICAgICctLW90aGVycycsXG4gICAgJy0tZXhjbHVkZS1zdGFuZGFyZCcsXG4gICAgJy16JyxcbiAgICAuLi5wYXR0ZXJucy5sZW5ndGggPiAwID8gWyctLScsIC4uLnBhdHRlcm5zXSA6IFtdXG4gIF07XG5cbiAgbGV0IHN0ZG91dDogc3RyaW5nO1xuICB0cnkge1xuICAgIHN0ZG91dCA9IGF3YWl0IGV4ZWNGcm9tUm9vdChjb21tYW5kLCB7IGlzUXVpZXQ6IHRydWUgfSk7XG4gIH0gY2F0Y2gge1xuICAgIHJldHVybiBudWxsO1xuICB9XG5cbiAgLy8gYC0tY2FjaGVkIC0tb3RoZXJzYCBjYW4gbmFtZSB0aGUgc2FtZSBwYXRoIHR3aWNlIChlLmcuIGEgZmlsZSBzdGFnZWQgZm9yIGRlbGV0aW9uIHRoYXQgaXMgc3RpbGwgb24gZGlzaykuXG4gIHJldHVybiBbLi4ubmV3IFNldChzdGRvdXQuc3BsaXQoTlVMX1NFUEFSQVRPUikuZmlsdGVyKChwYXRoKSA9PiBwYXRoICE9PSAnJykpXTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBY0EsU0FBUyxvQkFBb0I7QUFrQjdCLE1BQU0sZ0JBQWdCO0FBYXRCLGVBQXNCLG1CQUFtQixTQUErRDtBQUN0RyxRQUFNLEVBQUUsV0FBVyxDQUFDLEVBQUUsSUFBSSxXQUFXLENBQUM7QUFDdEMsUUFBTSxVQUFVO0FBQUEsSUFDZDtBQUFBLElBQ0E7QUFBQSxJQUNBO0FBQUEsSUFDQTtBQUFBLElBQ0E7QUFBQSxJQUNBO0FBQUEsSUFDQSxHQUFHLFNBQVMsU0FBUyxJQUFJLENBQUMsTUFBTSxHQUFHLFFBQVEsSUFBSSxDQUFDO0FBQUEsRUFDbEQ7QUFFQSxNQUFJO0FBQ0osTUFBSTtBQUNGLGFBQVMsTUFBTSxhQUFhLFNBQVMsRUFBRSxTQUFTLEtBQUssQ0FBQztBQUFBLEVBQ3hELFFBQVE7QUFDTixXQUFPO0FBQUEsRUFDVDtBQUdBLFNBQU8sQ0FBQyxHQUFHLElBQUksSUFBSSxPQUFPLE1BQU0sYUFBYSxFQUFFLE9BQU8sQ0FBQyxTQUFTLFNBQVMsRUFBRSxDQUFDLENBQUM7QUFDL0U7IiwKICAibmFtZXMiOiBbXQp9Cg==

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

@@ -0,0 +1,35 @@
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+/// <reference lib="es2022" />
+/// <reference lib="esnext.disposable" />
+/// <reference types="node" />
+export * as 'build' from './build.mjs';
+export * as 'bundlers' from './bundlers/index.mjs';
+export * as 'check-project-types' from './check-project-types.mjs';
+export * as 'cli-utils' from './cli-utils.mjs';
+export * as 'code-generator' from './code-generator.mjs';
+export * as 'commitlint-config' from './commitlint-config.mjs';
+export * as 'commitlint-forbidden-patterns' from './commitlint-forbidden-patterns.mjs';
+export * as 'commitlint-spellcheck-header' from './commitlint-spellcheck-header.mjs';
+export * as 'env-toggle' from './env-toggle.mjs';
+export * as 'exec' from './exec.mjs';
+export * as 'forbidden-patterns' from './forbidden-patterns.mjs';
+export * as 'formatters' from './formatters/index.mjs';
+export * as 'fs' from './fs.mjs';
+export * as 'gate' from './gate.mjs';
+export * as 'git' from './git.mjs';
+export * as 'json' from './json.mjs';
+export * as 'library-build' from './library-build.mjs';
+export * as 'linters' from './linters/index.mjs';
+export * as 'nano-staged-config' from './nano-staged-config.mjs';
+export * as 'npm-publish' from './npm-publish.mjs';
+export * as 'npm-run' from './npm-run.mjs';
+export * as 'npm' from './npm.mjs';
+export * as 'package-lock-integrity' from './package-lock-integrity.mjs';
+export * as 'package-manager' from './package-manager.mjs';
+export * as 'released-issues' from './released-issues.mjs';
+export * as 'repo-paths' from './repo-paths.mjs';
+export * as 'root' from './root.mjs';
+export * as 'test-runners' from './test-runners/index.mjs';
+export * as 'validate-declarations' from './validate-declarations.mjs';
+export * as 'version' from './version.mjs';

package/dist/lib/esm/index.mjs

@@ -0,0 +1,110 @@
+/*
+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 build from "./build.mjs";
+import * as bundlers from "./bundlers/index.mjs";
+import * as check_project_types from "./check-project-types.mjs";
+import * as cli_utils from "./cli-utils.mjs";
+import * as code_generator from "./code-generator.mjs";
+import * as commitlint_config from "./commitlint-config.mjs";
+import * as commitlint_forbidden_patterns from "./commitlint-forbidden-patterns.mjs";
+import * as commitlint_spellcheck_header from "./commitlint-spellcheck-header.mjs";
+import * as env_toggle from "./env-toggle.mjs";
+import * as exec from "./exec.mjs";
+import * as forbidden_patterns from "./forbidden-patterns.mjs";
+import * as formatters from "./formatters/index.mjs";
+import * as fs from "./fs.mjs";
+import * as gate from "./gate.mjs";
+import * as git from "./git.mjs";
+import * as json from "./json.mjs";
+import * as library_build from "./library-build.mjs";
+import * as linters from "./linters/index.mjs";
+import * as nano_staged_config from "./nano-staged-config.mjs";
+import * as npm_publish from "./npm-publish.mjs";
+import * as npm_run from "./npm-run.mjs";
+import * as npm from "./npm.mjs";
+import * as package_lock_integrity from "./package-lock-integrity.mjs";
+import * as package_manager from "./package-manager.mjs";
+import * as released_issues from "./released-issues.mjs";
+import * as repo_paths from "./repo-paths.mjs";
+import * as root from "./root.mjs";
+import * as test_runners from "./test-runners/index.mjs";
+import * as validate_declarations from "./validate-declarations.mjs";
+import * as version from "./version.mjs";
+export {
+  build,
+  bundlers,
+  check_project_types as "check-project-types",
+  cli_utils as "cli-utils",
+  code_generator as "code-generator",
+  commitlint_config as "commitlint-config",
+  commitlint_forbidden_patterns as "commitlint-forbidden-patterns",
+  commitlint_spellcheck_header as "commitlint-spellcheck-header",
+  env_toggle as "env-toggle",
+  exec,
+  forbidden_patterns as "forbidden-patterns",
+  formatters,
+  fs,
+  gate,
+  git,
+  json,
+  library_build as "library-build",
+  linters,
+  nano_staged_config as "nano-staged-config",
+  npm,
+  npm_publish as "npm-publish",
+  npm_run as "npm-run",
+  package_lock_integrity as "package-lock-integrity",
+  package_manager as "package-manager",
+  released_issues as "released-issues",
+  repo_paths as "repo-paths",
+  root,
+  test_runners as "test-runners",
+  validate_declarations as "validate-declarations",
+  version
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,102 @@
+/// <reference path="./index.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for JSON.
+ */
+import type { Promisable } from 'type-fest';
+/**
+ * Options for {@link editJson}.
+ */
+export interface EditJsonOptions {
+    /**
+     * If `true`, skips editing if the file does not exist.
+     *
+     * @default `false`
+     */
+    readonly shouldSkipIfMissing?: boolean;
+}
+/**
+ * Parameters for {@link editJson}.
+ *
+ * @typeParam T - The type of the data to be edited.
+ */
+export interface EditJsonParams<T> extends EditJsonOptions {
+    /**
+     * The function to edit the parsed JSON data.
+     *
+     * @param data - The parsed JSON data to edit.
+     */
+    readonly editFunction: (data: T) => Promisable<void>;
+    /**
+     * The path to the JSON file.
+     */
+    readonly path: string;
+}
+/**
+ * Options for {@link editJsonSync}.
+ */
+export type EditJsonSyncOptions = EditJsonOptions;
+/**
+ * Parameters for {@link editJsonSync}.
+ *
+ * @typeParam T - The type of the data to be edited.
+ */
+export interface EditJsonSyncParams<T> extends EditJsonSyncOptions {
+    /**
+     * The function to edit the parsed JSON data.
+     *
+     * @param data - The parsed JSON data to edit.
+     */
+    readonly editFunction: (data: T) => void;
+    /**
+     * The path to the JSON file.
+     */
+    readonly path: string;
+}
+/**
+ * Reads, edits, and writes back a JSON file using a provided edit function.
+ *
+ * @typeParam T - The type of the data to be edited.
+ * @param params - The parameters for the function.
+ * @returns A {@link Promise} that resolves when the file has been edited and written.
+ */
+export declare function editJson<T>(params: EditJsonParams<T>): Promise<void>;
+/**
+ * Reads, edits, and writes back a JSON file using a provided edit function.
+ *
+ * @typeParam T - The type of the data to be edited.
+ * @param params - The parameters for the function.
+ */
+export declare function editJsonSync<T>(params: EditJsonSyncParams<T>): void;
+/**
+ * Reads a JSON file and parses its contents into a JavaScript object of type `T`.
+ *
+ * @typeParam T - The type to which the JSON content will be parsed.
+ * @param path - The path to the JSON file.
+ * @returns A {@link Promise} that resolves with the parsed JSON object of type `T`.
+ */
+export declare function readJson<T>(path: string): Promise<T>;
+/**
+ * Reads a JSON file and parses its contents into a JavaScript object of type `T`.
+ *
+ * @typeParam T - The type to which the JSON content will be parsed.
+ * @param path - The path to the JSON file.
+ * @returns The parsed JSON object of type `T`.
+ */
+export declare function readJsonSync<T>(path: string): T;
+/**
+ * Writes a JavaScript object to a JSON file.
+ *
+ * @param path - The path to the JSON file.
+ * @param data - The data to write to the JSON file.
+ * @returns A {@link Promise} that resolves when the file has been written.
+ */
+export declare function writeJson(path: string, data: unknown): Promise<void>;
+/**
+ * Writes a JavaScript object to a JSON file.
+ *
+ * @param path - The path to the JSON file.
+ * @param data - The data to write to the JSON file.
+ */
+export declare function writeJsonSync(path: string, data: unknown): void;

package/dist/lib/esm/json.mjs

@@ -0,0 +1,106 @@
+/*
+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 { toJson } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+import {
+  readFile,
+  writeFile
+} from "node:fs/promises";
+async function editJson(params) {
+  const {
+    editFunction,
+    path,
+    shouldSkipIfMissing
+  } = params;
+  if (shouldSkipIfMissing && !existsSync(path)) {
+    return;
+  }
+  const data = await readJson(path);
+  await editFunction(data);
+  await writeJson(path, data);
+}
+function editJsonSync(params) {
+  const {
+    editFunction,
+    path,
+    shouldSkipIfMissing
+  } = params;
+  if (shouldSkipIfMissing && !existsSync(path)) {
+    return;
+  }
+  const data = readJsonSync(path);
+  editFunction(data);
+  writeJsonSync(path, data);
+}
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf-8"));
+}
+function readJsonSync(path) {
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+async function writeJson(path, data) {
+  await writeFile(path, `${toJson(data)}
+`);
+}
+function writeJsonSync(path, data) {
+  writeFileSync(path, `${toJson(data)}
+`);
+}
+export {
+  editJson,
+  editJsonSync,
+  readJson,
+  readJsonSync,
+  writeJson,
+  writeJsonSync
+};
+//# sourceMappingURL=data:application/json;base64,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