@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/esm/commitlint-forbidden-patterns.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 {
+  findForbiddenPatternMatches,
+  FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE,
+  readForbiddenPatterns
+} from "./forbidden-patterns.mjs";
+const NO_FORBIDDEN_PATTERNS_RULE_NAME = "obsidian-dev-utils/no-forbidden-patterns";
+async function noForbiddenPatternsRule(commit) {
+  const patterns = await readForbiddenPatterns();
+  const text = [commit.header, commit.body, commit.footer].filter((part) => part !== null).join("\n");
+  const matches = findForbiddenPatternMatches(text, patterns);
+  if (matches.length === 0) {
+    return [true];
+  }
+  const offendingLines = matches.map(({ line, match }) => `${line}    <- ${match}`).join("\n");
+  return [false, `the commit message matches a pattern from the file ${FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names:
+${offendingLines}`];
+}
+const forbiddenPatternsPlugin = {
+  rules: {
+    [NO_FORBIDDEN_PATTERNS_RULE_NAME]: noForbiddenPatternsRule
+  }
+};
+export {
+  NO_FORBIDDEN_PATTERNS_RULE_NAME,
+  forbiddenPatternsPlugin,
+  noForbiddenPatternsRule
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/commitlint-spellcheck-header.d.mts

@@ -0,0 +1,40 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * A commitlint rule that spellchecks a commit HEADER with the project's own `spellcheck` configuration.
+ *
+ * The header is the one part of a commit message that ships verbatim: a release turns every commit subject
+ * since the last tag into a `- <subject>` bullet of the new `CHANGELOG.md` section, and spellchecks that
+ * section before writing it. That check works, but it runs at release time, after the whole preflight gate,
+ * and weeks after the subject was pushed to the default branch. At that point the only fixes are rewriting
+ * published history or supplying the release notes by hand. The commit-msg hook is the last point at which
+ * the word can still be changed for free.
+ *
+ * The header is checked AS the bullet it will become, attributed to `CHANGELOG.md`, so the verdict is the one
+ * the release would give: the same `cspell` configuration, the same `words`, the same `ignorePaths`. And it
+ * runs only where the project defines a `spellcheck` script, which is the condition the release applies too.
+ * A project with no spelling configuration would otherwise have its commits judged against the stock
+ * dictionaries alone, and refused over its own name.
+ */
+import type { AsyncRule, Plugin, RuleOutcome } from '@commitlint/types';
+/**
+ * The name the rule is registered under.
+ */
+export declare const SPELLCHECK_HEADER_RULE_NAME = "obsidian-dev-utils/spellcheck-header";
+type Commit = Parameters<AsyncRule>[0];
+/**
+ * Spellchecks the commit header as the changelog bullet it will become.
+ *
+ * Only the `always` condition is meaningful: `never` would require the header to be misspelled, so it is
+ * treated the same way rather than inverted.
+ *
+ * @param commit - The parsed commit.
+ * @returns A {@link Promise} that resolves to the rule outcome, naming each unknown word.
+ */
+export declare function spellcheckHeaderRule(commit: Commit): Promise<RuleOutcome>;
+/**
+ * The commitlint plugin carrying {@link spellcheckHeaderRule}.
+ */
+export declare const spellcheckHeaderPlugin: Plugin;
+export {};

package/dist/lib/esm/commitlint-spellcheck-header.mjs

@@ -0,0 +1,87 @@
+/*
+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 { spellcheckContent } from "./linters/cspell-content.mjs";
+import { readPackageJson } from "./npm.mjs";
+import { RepoPaths } from "./repo-paths.mjs";
+import { resolvePathFromRootSafe } from "./root.mjs";
+const SPELLCHECK_HEADER_RULE_NAME = "obsidian-dev-utils/spellcheck-header";
+const SPELLCHECK_SCRIPT_NAME = "spellcheck";
+async function spellcheckHeaderRule(commit) {
+  if (!commit.header) {
+    return [true];
+  }
+  const packageJson = await readPackageJson();
+  if (!Object.keys(packageJson.scripts ?? {}).includes(SPELLCHECK_SCRIPT_NAME)) {
+    return [true];
+  }
+  const findings = await spellcheckContent({
+    content: `- ${commit.header}
+`,
+    filePath: resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd })
+  });
+  if (findings.length === 0) {
+    return [true];
+  }
+  return [
+    false,
+    `the header does not pass \`${SPELLCHECK_SCRIPT_NAME}\`, and it ships verbatim into the next release's changelog:
+${findings.join("\n")}
+Reword it, or, for a word this project really does use, add it to the project's \`cspell\` configuration.`
+  ];
+}
+const spellcheckHeaderPlugin = {
+  rules: {
+    [SPELLCHECK_HEADER_RULE_NAME]: spellcheckHeaderRule
+  }
+};
+export {
+  SPELLCHECK_HEADER_RULE_NAME,
+  spellcheckHeaderPlugin,
+  spellcheckHeaderRule
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbW1pdGxpbnQtc3BlbGxjaGVjay1oZWFkZXIudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBBIGNvbW1pdGxpbnQgcnVsZSB0aGF0IHNwZWxsY2hlY2tzIGEgY29tbWl0IEhFQURFUiB3aXRoIHRoZSBwcm9qZWN0J3Mgb3duIGBzcGVsbGNoZWNrYCBjb25maWd1cmF0aW9uLlxuICpcbiAqIFRoZSBoZWFkZXIgaXMgdGhlIG9uZSBwYXJ0IG9mIGEgY29tbWl0IG1lc3NhZ2UgdGhhdCBzaGlwcyB2ZXJiYXRpbTogYSByZWxlYXNlIHR1cm5zIGV2ZXJ5IGNvbW1pdCBzdWJqZWN0XG4gKiBzaW5jZSB0aGUgbGFzdCB0YWcgaW50byBhIGAtIDxzdWJqZWN0PmAgYnVsbGV0IG9mIHRoZSBuZXcgYENIQU5HRUxPRy5tZGAgc2VjdGlvbiwgYW5kIHNwZWxsY2hlY2tzIHRoYXRcbiAqIHNlY3Rpb24gYmVmb3JlIHdyaXRpbmcgaXQuIFRoYXQgY2hlY2sgd29ya3MsIGJ1dCBpdCBydW5zIGF0IHJlbGVhc2UgdGltZSwgYWZ0ZXIgdGhlIHdob2xlIHByZWZsaWdodCBnYXRlLFxuICogYW5kIHdlZWtzIGFmdGVyIHRoZSBzdWJqZWN0IHdhcyBwdXNoZWQgdG8gdGhlIGRlZmF1bHQgYnJhbmNoLiBBdCB0aGF0IHBvaW50IHRoZSBvbmx5IGZpeGVzIGFyZSByZXdyaXRpbmdcbiAqIHB1Ymxpc2hlZCBoaXN0b3J5IG9yIHN1cHBseWluZyB0aGUgcmVsZWFzZSBub3RlcyBieSBoYW5kLiBUaGUgY29tbWl0LW1zZyBob29rIGlzIHRoZSBsYXN0IHBvaW50IGF0IHdoaWNoXG4gKiB0aGUgd29yZCBjYW4gc3RpbGwgYmUgY2hhbmdlZCBmb3IgZnJlZS5cbiAqXG4gKiBUaGUgaGVhZGVyIGlzIGNoZWNrZWQgQVMgdGhlIGJ1bGxldCBpdCB3aWxsIGJlY29tZSwgYXR0cmlidXRlZCB0byBgQ0hBTkdFTE9HLm1kYCwgc28gdGhlIHZlcmRpY3QgaXMgdGhlIG9uZVxuICogdGhlIHJlbGVhc2Ugd291bGQgZ2l2ZTogdGhlIHNhbWUgYGNzcGVsbGAgY29uZmlndXJhdGlvbiwgdGhlIHNhbWUgYHdvcmRzYCwgdGhlIHNhbWUgYGlnbm9yZVBhdGhzYC4gQW5kIGl0XG4gKiBydW5zIG9ubHkgd2hlcmUgdGhlIHByb2plY3QgZGVmaW5lcyBhIGBzcGVsbGNoZWNrYCBzY3JpcHQsIHdoaWNoIGlzIHRoZSBjb25kaXRpb24gdGhlIHJlbGVhc2UgYXBwbGllcyB0b28uXG4gKiBBIHByb2plY3Qgd2l0aCBubyBzcGVsbGluZyBjb25maWd1cmF0aW9uIHdvdWxkIG90aGVyd2lzZSBoYXZlIGl0cyBjb21taXRzIGp1ZGdlZCBhZ2FpbnN0IHRoZSBzdG9ja1xuICogZGljdGlvbmFyaWVzIGFsb25lLCBhbmQgcmVmdXNlZCBvdmVyIGl0cyBvd24gbmFtZS5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIEFzeW5jUnVsZSxcbiAgUGx1Z2luLFxuICBSdWxlT3V0Y29tZVxufSBmcm9tICdAY29tbWl0bGludC90eXBlcyc7XG5cbmltcG9ydCB7IHNwZWxsY2hlY2tDb250ZW50IH0gZnJvbSAnLi9saW50ZXJzL2NzcGVsbC1jb250ZW50LnRzJztcbmltcG9ydCB7IHJlYWRQYWNrYWdlSnNvbiB9IGZyb20gJy4vbnBtLnRzJztcbmltcG9ydCB7IFJlcG9QYXRocyB9IGZyb20gJy4vcmVwby1wYXRocy50cyc7XG5pbXBvcnQgeyByZXNvbHZlUGF0aEZyb21Sb290U2FmZSB9IGZyb20gJy4vcm9vdC50cyc7XG5cbi8qKlxuICogVGhlIG5hbWUgdGhlIHJ1bGUgaXMgcmVnaXN0ZXJlZCB1bmRlci5cbiAqL1xuZXhwb3J0IGNvbnN0IFNQRUxMQ0hFQ0tfSEVBREVSX1JVTEVfTkFNRSA9ICdvYnNpZGlhbi1kZXYtdXRpbHMvc3BlbGxjaGVjay1oZWFkZXInO1xuXG4vKipcbiAqIFRoZSBucG0gc2NyaXB0IHdob3NlIHByZXNlbmNlIG9wdHMgYSBwcm9qZWN0IGludG8gdGhlIGNoZWNrLlxuICovXG5jb25zdCBTUEVMTENIRUNLX1NDUklQVF9OQU1FID0gJ3NwZWxsY2hlY2snO1xuXG50eXBlIENvbW1pdCA9IFBhcmFtZXRlcnM8QXN5bmNSdWxlPlswXTtcblxuLyoqXG4gKiBTcGVsbGNoZWNrcyB0aGUgY29tbWl0IGhlYWRlciBhcyB0aGUgY2hhbmdlbG9nIGJ1bGxldCBpdCB3aWxsIGJlY29tZS5cbiAqXG4gKiBPbmx5IHRoZSBgYWx3YXlzYCBjb25kaXRpb24gaXMgbWVhbmluZ2Z1bDogYG5ldmVyYCB3b3VsZCByZXF1aXJlIHRoZSBoZWFkZXIgdG8gYmUgbWlzc3BlbGxlZCwgc28gaXQgaXNcbiAqIHRyZWF0ZWQgdGhlIHNhbWUgd2F5IHJhdGhlciB0aGFuIGludmVydGVkLlxuICpcbiAqIEBwYXJhbSBjb21taXQgLSBUaGUgcGFyc2VkIGNvbW1pdC5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gdGhlIHJ1bGUgb3V0Y29tZSwgbmFtaW5nIGVhY2ggdW5rbm93biB3b3JkLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc3BlbGxjaGVja0hlYWRlclJ1bGUoY29tbWl0OiBDb21taXQpOiBQcm9taXNlPFJ1bGVPdXRjb21lPiB7XG4gIGlmICghY29tbWl0LmhlYWRlcikge1xuICAgIHJldHVybiBbdHJ1ZV07XG4gIH1cblxuICBjb25zdCBwYWNrYWdlSnNvbiA9IGF3YWl0IHJlYWRQYWNrYWdlSnNvbigpO1xuICBpZiAoIU9iamVjdC5rZXlzKHBhY2thZ2VKc29uLnNjcmlwdHMgPz8ge30pLmluY2x1ZGVzKFNQRUxMQ0hFQ0tfU0NSSVBUX05BTUUpKSB7XG4gICAgcmV0dXJuIFt0cnVlXTtcbiAgfVxuXG4gIGNvbnN0IGZpbmRpbmdzID0gYXdhaXQgc3BlbGxjaGVja0NvbnRlbnQoe1xuICAgIGNvbnRlbnQ6IGAtICR7Y29tbWl0LmhlYWRlcn1cXG5gLFxuICAgIGZpbGVQYXRoOiByZXNvbHZlUGF0aEZyb21Sb290U2FmZSh7IHBhdGg6IFJlcG9QYXRocy5DaGFuZ2Vsb2dNZCB9KVxuICB9KTtcblxuICBpZiAoZmluZGluZ3MubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIFt0cnVlXTtcbiAgfVxuXG4gIHJldHVybiBbXG4gICAgZmFsc2UsXG4gICAgYHRoZSBoZWFkZXIgZG9lcyBub3QgcGFzcyBcXGAke1NQRUxMQ0hFQ0tfU0NSSVBUX05BTUV9XFxgLCBhbmQgaXQgc2hpcHMgdmVyYmF0aW0gaW50byB0aGUgbmV4dCByZWxlYXNlJ3MgY2hhbmdlbG9nOlxcbmBcbiAgICArIGAke2ZpbmRpbmdzLmpvaW4oJ1xcbicpfVxcbmBcbiAgICArICdSZXdvcmQgaXQsIG9yLCBmb3IgYSB3b3JkIHRoaXMgcHJvamVjdCByZWFsbHkgZG9lcyB1c2UsIGFkZCBpdCB0byB0aGUgcHJvamVjdFxcJ3MgYGNzcGVsbGAgY29uZmlndXJhdGlvbi4nXG4gIF07XG59XG5cbi8qKlxuICogVGhlIGNvbW1pdGxpbnQgcGx1Z2luIGNhcnJ5aW5nIHtAbGluayBzcGVsbGNoZWNrSGVhZGVyUnVsZX0uXG4gKi9cbmV4cG9ydCBjb25zdCBzcGVsbGNoZWNrSGVhZGVyUGx1Z2luOiBQbHVnaW4gPSB7XG4gIHJ1bGVzOiB7XG4gICAgW1NQRUxMQ0hFQ0tfSEVBREVSX1JVTEVfTkFNRV06IHNwZWxsY2hlY2tIZWFkZXJSdWxlXG4gIH1cbn07XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQXlCQSxTQUFTLHlCQUF5QjtBQUNsQyxTQUFTLHVCQUF1QjtBQUNoQyxTQUFTLGlCQUFpQjtBQUMxQixTQUFTLCtCQUErQjtBQUtqQyxNQUFNLDhCQUE4QjtBQUszQyxNQUFNLHlCQUF5QjtBQWEvQixlQUFzQixxQkFBcUIsUUFBc0M7QUFDL0UsTUFBSSxDQUFDLE9BQU8sUUFBUTtBQUNsQixXQUFPLENBQUMsSUFBSTtBQUFBLEVBQ2Q7QUFFQSxRQUFNLGNBQWMsTUFBTSxnQkFBZ0I7QUFDMUMsTUFBSSxDQUFDLE9BQU8sS0FBSyxZQUFZLFdBQVcsQ0FBQyxDQUFDLEVBQUUsU0FBUyxzQkFBc0IsR0FBRztBQUM1RSxXQUFPLENBQUMsSUFBSTtBQUFBLEVBQ2Q7QUFFQSxRQUFNLFdBQVcsTUFBTSxrQkFBa0I7QUFBQSxJQUN2QyxTQUFTLEtBQUssT0FBTyxNQUFNO0FBQUE7QUFBQSxJQUMzQixVQUFVLHdCQUF3QixFQUFFLE1BQU0sVUFBVSxZQUFZLENBQUM7QUFBQSxFQUNuRSxDQUFDO0FBRUQsTUFBSSxTQUFTLFdBQVcsR0FBRztBQUN6QixXQUFPLENBQUMsSUFBSTtBQUFBLEVBQ2Q7QUFFQSxTQUFPO0FBQUEsSUFDTDtBQUFBLElBQ0EsOEJBQThCLHNCQUFzQjtBQUFBLEVBQy9DLFNBQVMsS0FBSyxJQUFJLENBQUM7QUFBQTtBQUFBLEVBRTFCO0FBQ0Y7QUFLTyxNQUFNLHlCQUFpQztBQUFBLEVBQzVDLE9BQU87QUFBQSxJQUNMLENBQUMsMkJBQTJCLEdBQUc7QUFBQSxFQUNqQztBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/env-toggle.d.mts

@@ -0,0 +1,42 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Shared environment-variable off switches for the CLI scripts.
+ *
+ * Every npm script can be skipped by setting an environment variable named after it — the script name
+ * uppercased, with every non-alphanumeric character replaced by `_`:
+ *
+ * | Script              | Switch              |
+ * |---------------------|---------------------|
+ * | `lint`              | `LINT=0`            |
+ * | `lint:md:fix`       | `LINT_MD_FIX=0`     |
+ * | `format:check`      | `FORMAT_CHECK=0`    |
+ * | `find-overexposed`  | `FIND_OVEREXPOSED=0`|
+ *
+ * This mirrors the pre-existing `NANO_STAGED=0` / `HUSKY=0` escape hatches, and reuses their notion of an
+ * "off" value, so there is a single answer to what counts as off across the whole tool set.
+ */
+/**
+ * Resolves the off switch for the npm script that is currently running, loading {@link ENV_FILE_PATH} first.
+ *
+ * The script name comes from npm itself, so no script has to declare its own switch. When the script was
+ * started directly rather than through npm, there is no name to derive from and nothing is ever skipped.
+ *
+ * @returns The name of the environment variable that switched the current script off, or `null` when the
+ * script should run.
+ */
+export declare function getDisabledScriptEnvVariableName(): null | string;
+/**
+ * Determines whether the environment variable is set to an off value (`0`, `false`, `no`, or `off`,
+ * case-insensitively and ignoring surrounding whitespace).
+ *
+ * @param envVariableName - The name of the environment variable to inspect.
+ * @returns `true` when the variable is set to an off value, otherwise `false`.
+ */
+export declare function isEnvVariableOff(envVariableName: string): boolean;
+/**
+ * Loads the optional {@link ENV_FILE_PATH} file into `process.env` when it exists, so a developer can park a
+ * switch such as `LINT_MD=0` there instead of prefixing every command.
+ */
+export declare function loadEnvFileIfExists(): void;

package/dist/lib/esm/env-toggle.mjs

@@ -0,0 +1,84 @@
+/*
+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 { replaceAll } from "@mnaoumov/typescript-lib/string";
+import { existsSync } from "node:fs";
+import process from "node:process";
+const OFF_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+const ENV_FILE_PATH = ".env";
+const NON_ALPHANUMERIC_REG_EXP = /[^a-z0-9]+/gi;
+const NPM_SCRIPT_NAME_ENV_VARIABLE = "npm_lifecycle_event";
+function getDisabledScriptEnvVariableName() {
+  loadEnvFileIfExists();
+  const scriptName = process.env[NPM_SCRIPT_NAME_ENV_VARIABLE];
+  if (!scriptName) {
+    return null;
+  }
+  const envVariableName = toEnvVariableName(scriptName);
+  return isEnvVariableOff(envVariableName) ? envVariableName : null;
+}
+function isEnvVariableOff(envVariableName) {
+  return OFF_VALUES.has((process.env[envVariableName] ?? "").trim().toLowerCase());
+}
+function loadEnvFileIfExists() {
+  if (existsSync(ENV_FILE_PATH)) {
+    process.loadEnvFile(ENV_FILE_PATH);
+  }
+}
+function toEnvVariableName(scriptName) {
+  return replaceAll({
+    $string: scriptName,
+    replacer: "_",
+    searchValue: NON_ALPHANUMERIC_REG_EXP
+  }).toUpperCase();
+}
+export {
+  getDisabledScriptEnvVariableName,
+  isEnvVariableOff,
+  loadEnvFileIfExists
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,162 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for executing commands.
+ */
+/**
+ * A command part: either a plain string or an {@link ExecArgument} with batched arguments.
+ */
+export type CommandPart = ExecArgument | string;
+/**
+ * A command argument that contains a list of args to be batched.
+ * If the expanded command exceeds the platform's max command length,
+ * the batched args are split into sequential executions.
+ */
+export interface ExecArgument {
+    /**
+     * The arguments to batch.
+     */
+    readonly batchedArguments: readonly string[];
+}
+/**
+ * Options for {@link exec} that return detailed results.
+ */
+export interface ExecDetailedOptions extends ExecOptions {
+    /**
+     * Must be `true` to receive detailed results.
+     */
+    readonly shouldIncludeDetails: true;
+}
+/**
+ * Options for executing a command.
+ */
+export interface ExecOptions {
+    /**
+     * A current working folder for the command execution.
+     */
+    readonly cwd?: string;
+    /**
+     * Additional environment variables for the child process, merged over the inherited environment.
+     *
+     * @default `{}`
+     */
+    readonly env?: NodeJS.ProcessEnv;
+    /**
+     * If `true`, attaches the child process's stdio directly to the terminal (`stdio: 'inherit'`) instead
+     * of capturing it. Use for long-running or interactive commands such as dev servers and watch mode.
+     * Because the output is not captured, the resolved stdout is an empty string.
+     *
+     * @default `false`
+     */
+    readonly isInteractive?: boolean;
+    /**
+     * If `true`, suppresses the output of the command.
+     *
+     * @default `false`
+     */
+    readonly isQuiet?: boolean;
+    /**
+     * If `true`, throws an error if the command fails.
+     *
+     * @default `true`
+     */
+    readonly shouldFailIfCalledFromOutsideRoot?: boolean;
+    /**
+     * If `true`, ignores the exit code of the command.
+     *
+     * @default `false`
+     */
+    readonly shouldIgnoreExitCode?: boolean;
+    /**
+     * If `false`, only returns the output of the command.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeDetails?: boolean;
+    /**
+     * An input to be passed to the command.
+     *
+     * @default `''`
+     */
+    readonly stdin?: string;
+}
+/**
+ * A result of {@link exec}.
+ */
+export interface ExecResult {
+    /**
+     * An exit code of the command. A value of `null` indicates that the process did not exit normally.
+     */
+    readonly exitCode: null | number;
+    /**
+     * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.
+     */
+    readonly exitSignal: NodeJS.Signals | null;
+    /**
+     * A standard error output from the command.
+     */
+    readonly stderr: string;
+    /**
+     * A standard output from the command.
+     */
+    readonly stdout: string;
+}
+/**
+ * Options for {@link exec} that return only stdout.
+ */
+export interface ExecSimpleOptions extends ExecOptions {
+    /**
+     * Must be `false` or omitted to receive only stdout.
+     *
+     * @default `false`
+     */
+    readonly shouldIncludeDetails?: false;
+}
+/**
+ * Appends a single `node` CLI option to a `NODE_OPTIONS` string, preserving any options already present.
+ *
+ * @param existingNodeOptions - The current `NODE_OPTIONS` value (e.g. `process.env.NODE_OPTIONS`), if any.
+ * @param option - The `node` CLI option to append (e.g. `--localstorage-file=:memory:`).
+ * @returns The combined `NODE_OPTIONS` string. If `option` is already present, the value is returned unchanged.
+ */
+export declare function appendNodeOption(existingNodeOptions: string | undefined, option: string): string;
+/**
+ * Builds the environment for child processes: the parent environment plus `DEBUG_COLORS`, and — when
+ * the running `node` supports it — {@link LOCAL_STORAGE_NODE_OPTION} appended to `NODE_OPTIONS`.
+ *
+ * The support check guards against older `node` (< 22): passing an option `node` does not recognize via
+ * `NODE_OPTIONS` makes it exit before running, which would break every spawned tool.
+ *
+ * @param baseEnv - The parent environment to extend (typically `process.env`).
+ * @param allowedNodeEnvironmentFlags - The `node` options accepted via `NODE_OPTIONS` (typically `process.allowedNodeEnvironmentFlags`).
+ * @returns The environment to pass to spawned child processes.
+ */
+export declare function buildChildEnv(baseEnv: NodeJS.ProcessEnv, allowedNodeEnvironmentFlags: ReadonlySet<string>): NodeJS.ProcessEnv;
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A {@link Promise} that resolves with the output of the command.
+ * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.
+ *         The error message includes the exit code, the command, stderr, and stdout (or a note that it was
+ *         printed), and says when the child crashed or was killed rather than exiting on its own.
+ *         If an error occurs during the execution and ignoreExitCode is `true`,
+ *         the error is resolved with the stdout and stderr.
+ */
+export declare function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A {@link Promise} that resolves with ExecResult object.
+ *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.
+ * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.
+ *         The error message includes the exit code, the command, stderr, and stdout (or a note that it was
+ *         printed), and says when the child crashed or was killed rather than exiting on its own.
+ *         If an error occurs during the execution and ignoreExitCode is `true`,
+ *         the error is resolved with the stdout and stderr.
+ */
+export declare function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;