@mnaoumov/typescript-dev-toolkit 3.0.0 → 3.2.0

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

@@ -0,0 +1,107 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { getLibDebugger } from "@mnaoumov/typescript-lib/debug";
+import {
+  basename,
+  relative,
+  toPosixPath
+} from "@mnaoumov/typescript-lib/path";
+import { assertNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { existsSync } from "node:fs";
+import {
+  cp,
+  writeFile
+} from "node:fs/promises";
+import { resolveToolCommand } from "../package-manager.mjs";
+import { RepoPaths } from "../repo-paths.mjs";
+import {
+  execFromRoot,
+  getRootFolder,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+import {
+  getSharedConfigFilePath,
+  SharedConfigFile
+} from "../shared-config-files.mjs";
+const BIOME_CONFIG_FILE_NAMES = [RepoPaths.BiomeJson, RepoPaths.BiomeJsonc];
+const BIOME_EXPLICIT_PATHS_ARGUMENTS = ["--files-ignore-unknown=true", "--no-errors-on-unmatched"];
+async function ensureBiomeConfig(options) {
+  if (hasBiomeConfig()) {
+    return;
+  }
+  const debug = getLibDebugger("Biome:ensureBiomeConfig");
+  const defaultConfigFilePath = options?.defaultConfigFilePath;
+  if (defaultConfigFilePath) {
+    debug("Biome configuration file not found. Copying the default config...");
+    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));
+    return;
+  }
+  debug("Biome configuration file not found. Writing one that extends the shared config...");
+  const rootFolder = getRootFolder();
+  assertNonNullable(rootFolder, "Root folder not found");
+  const sharedConfigPath = toPosixPath(relative(rootFolder, getSharedConfigFilePath(SharedConfigFile.Biome)));
+  const extendsPath = JSON.stringify(sharedConfigPath.startsWith(".") ? sharedConfigPath : `./${sharedConfigPath}`);
+  await writeFile(resolvePathFromRootSafe({ path: RepoPaths.BiomeJson }), `{
+  "extends": [${extendsPath}]
+}
+`);
+}
+async function format(options) {
+  const { defaultConfigFilePath, paths, rewrite = true } = options ?? {};
+  await ensureBiomeConfig({ defaultConfigFilePath });
+  const hasPaths = paths !== void 0 && paths.length > 0;
+  await execFromRoot([
+    ...resolveToolCommand({ tool: "biome" }),
+    "format",
+    ...rewrite ? ["--write"] : [],
+    ...hasPaths ? BIOME_EXPLICIT_PATHS_ARGUMENTS : [],
+    { batchedArguments: hasPaths ? paths : [RepoPaths.CurrentFolder] }
+  ]);
+}
+function hasBiomeConfig() {
+  return BIOME_CONFIG_FILE_NAMES.some((fileName) => existsSync(resolvePathFromRootSafe({ path: fileName })));
+}
+export {
+  BIOME_CONFIG_FILE_NAMES,
+  BIOME_EXPLICIT_PATHS_ARGUMENTS,
+  ensureBiomeConfig,
+  format,
+  hasBiomeConfig
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/formatters/biome.ts"],"sourcesContent":["/**\n * @file\n *\n * Format the source code with Biome.\n */\n\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport {\n  basename,\n  relative,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  writeFile\n} from 'node:fs/promises';\n\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport {\n  getSharedConfigFilePath,\n  SharedConfigFile\n} from '../shared-config-files.ts';\n\n/**\n * The files Biome reads its configuration from.\n */\nexport const BIOME_CONFIG_FILE_NAMES: readonly string[] = [RepoPaths.BiomeJson, RepoPaths.BiomeJsonc];\n\n/**\n * The flags that make Biome skip, rather than fail on, a path it is handed but does not handle: a pre-commit hook\n * hands every tool explicit file lists, which can name a file Biome does not know or a file the project ignores.\n */\nexport const BIOME_EXPLICIT_PATHS_ARGUMENTS: readonly string[] = ['--files-ignore-unknown=true', '--no-errors-on-unmatched'];\n\n/**\n * Parameters for the {@link ensureBiomeConfig} function.\n */\nexport interface EnsureBiomeConfigOptions {\n  /**\n   * The configuration file copied to the project root when the project has none.\n   */\n  readonly defaultConfigFilePath?: string | undefined;\n}\n\n/**\n * Parameters for the {@link format} function.\n */\nexport interface FormatOptions {\n  /**\n   * The configuration file copied to the project root when the project has none. Omitted, a `biome.json` extending\n   * the shared one this package ships (`assets/biome.json`) is written instead.\n   */\n  readonly defaultConfigFilePath?: string | undefined;\n\n  /**\n   * Optional file paths to format. If omitted, formats the entire project.\n   */\n  readonly paths?: string[] | undefined;\n\n  /**\n   * Whether to rewrite the source code.\n   *\n   * @default `true`\n   */\n  readonly rewrite?: boolean | undefined;\n}\n\n/**\n * Makes sure the project has a Biome configuration of its own.\n *\n * Biome resolves a configuration's VCS root and globs against the configuration file's own folder, so a shared\n * configuration cannot be passed with `--config-path` from inside `node_modules`: it looks for `.gitignore` there.\n * The project's own `biome.json` extends it instead. When there is none, the default one is copied in, or a\n * `biome.json` extending the shared configuration is written.\n *\n * @param options - The {@link EnsureBiomeConfigOptions}.\n * @returns A {@link Promise} that resolves when the project has a Biome configuration.\n */\nexport async function ensureBiomeConfig(options?: EnsureBiomeConfigOptions): Promise<void> {\n  if (hasBiomeConfig()) {\n    return;\n  }\n\n  const debug = getLibDebugger('Biome:ensureBiomeConfig');\n  const defaultConfigFilePath = options?.defaultConfigFilePath;\n  if (defaultConfigFilePath) {\n    debug('Biome configuration file not found. Copying the default config...');\n    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));\n    return;\n  }\n\n  debug('Biome configuration file not found. Writing one that extends the shared config...');\n  const rootFolder = getRootFolder();\n  assertNonNullable(rootFolder, 'Root folder not found');\n  const sharedConfigPath = toPosixPath(relative(rootFolder, getSharedConfigFilePath(SharedConfigFile.Biome)));\n  const extendsPath = JSON.stringify(sharedConfigPath.startsWith('.') ? sharedConfigPath : `./${sharedConfigPath}`);\n  // Written the way `biome format` prints it, so the first format leaves the file alone.\n  await writeFile(resolvePathFromRootSafe({ path: RepoPaths.BiomeJson }), `{\\n  \"extends\": [${extendsPath}]\\n}\\n`);\n}\n\n/**\n * Format the source code with Biome.\n *\n * @param options - The {@link FormatOptions}.\n * @returns A {@link Promise} that resolves when the source code has been formatted.\n */\nexport async function format(options?: FormatOptions): Promise<void> {\n  const { defaultConfigFilePath, paths, rewrite = true } = options ?? {};\n  await ensureBiomeConfig({ defaultConfigFilePath });\n  const hasPaths = paths !== undefined && paths.length > 0;\n\n  await execFromRoot([\n    ...resolveToolCommand({ tool: 'biome' }),\n    'format',\n    ...rewrite ? ['--write'] : [],\n    ...hasPaths ? BIOME_EXPLICIT_PATHS_ARGUMENTS : [],\n    { batchedArguments: hasPaths ? paths : [RepoPaths.CurrentFolder] }\n  ]);\n}\n\n/**\n * Says whether the project configures Biome itself.\n *\n * @returns Whether a `biome.json` or `biome.jsonc` exists at the project root.\n */\nexport function hasBiomeConfig(): boolean {\n  return BIOME_CONFIG_FILE_NAMES.some((fileName) => existsSync(resolvePathFromRootSafe({ path: fileName })));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,sBAAsB;AAC/B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,0BAA0B;AACnC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKA,MAAM,0BAA6C,CAAC,UAAU,WAAW,UAAU,UAAU;AAM7F,MAAM,iCAAoD,CAAC,+BAA+B,0BAA0B;AA8C3H,eAAsB,kBAAkB,SAAmD;AACzF,MAAI,eAAe,GAAG;AACpB;AAAA,EACF;AAEA,QAAM,QAAQ,eAAe,yBAAyB;AACtD,QAAM,wBAAwB,SAAS;AACvC,MAAI,uBAAuB;AACzB,UAAM,mEAAmE;AACzE,UAAM,GAAG,uBAAuB,wBAAwB,EAAE,MAAM,SAAS,qBAAqB,EAAE,CAAC,CAAC;AAClG;AAAA,EACF;AAEA,QAAM,mFAAmF;AACzF,QAAM,aAAa,cAAc;AACjC,oBAAkB,YAAY,uBAAuB;AACrD,QAAM,mBAAmB,YAAY,SAAS,YAAY,wBAAwB,iBAAiB,KAAK,CAAC,CAAC;AAC1G,QAAM,cAAc,KAAK,UAAU,iBAAiB,WAAW,GAAG,IAAI,mBAAmB,KAAK,gBAAgB,EAAE;AAEhH,QAAM,UAAU,wBAAwB,EAAE,MAAM,UAAU,UAAU,CAAC,GAAG;AAAA,gBAAoB,WAAW;AAAA;AAAA,CAAQ;AACjH;AAQA,eAAsB,OAAO,SAAwC;AACnE,QAAM,EAAE,uBAAuB,OAAO,UAAU,KAAK,IAAI,WAAW,CAAC;AACrE,QAAM,kBAAkB,EAAE,sBAAsB,CAAC;AACjD,QAAM,WAAW,UAAU,UAAa,MAAM,SAAS;AAEvD,QAAM,aAAa;AAAA,IACjB,GAAG,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAAA,IACvC;AAAA,IACA,GAAG,UAAU,CAAC,SAAS,IAAI,CAAC;AAAA,IAC5B,GAAG,WAAW,iCAAiC,CAAC;AAAA,IAChD,EAAE,kBAAkB,WAAW,QAAQ,CAAC,UAAU,aAAa,EAAE;AAAA,EACnE,CAAC;AACH;AAOO,SAAS,iBAA0B;AACxC,SAAO,wBAAwB,KAAK,CAAC,aAAa,WAAW,wBAAwB,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC;AAC3G;","names":[]}

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

@@ -1,2 +1,5 @@
 /// <reference path="../library-references.d.mts" />
+export * as 'auto' from './auto.mjs';
+export * as 'biome' from './biome.mjs';
 export * as 'dprint' from './dprint.mjs';
+export * as 'prettier' from './prettier.mjs';

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

@@ -3,8 +3,14 @@ THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
 
+import * as auto from "./auto.mjs";
+import * as biome from "./biome.mjs";
 import * as dprint from "./dprint.mjs";
+import * as prettier from "./prettier.mjs";
 export {
-  dprint
+  auto,
+  biome,
+  dprint,
+  prettier
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2Zvcm1hdHRlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnZHByaW50JyBmcm9tICcuL2RwcmludC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVksWUFBYzsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2Zvcm1hdHRlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnYXV0bycgZnJvbSAnLi9hdXRvLnRzJztcbmV4cG9ydCAqIGFzICdiaW9tZScgZnJvbSAnLi9iaW9tZS50cyc7XG5leHBvcnQgKiBhcyAnZHByaW50JyBmcm9tICcuL2RwcmludC50cyc7XG5leHBvcnQgKiBhcyAncHJldHRpZXInIGZyb20gJy4vcHJldHRpZXIudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFFQSxZQUFZLFVBQVk7QUFDeEIsWUFBWSxXQUFhO0FBQ3pCLFlBQVksWUFBYztBQUMxQixZQUFZLGNBQWdCOyIsCiAgIm5hbWVzIjogW10KfQo=

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

@@ -0,0 +1,56 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Format the source code with Prettier.
+ */
+/**
+ * Every file Prettier reads its configuration from, besides the `prettier` key of `package.json`.
+ *
+ * @see {@link https://prettier.io/docs/configuration}
+ */
+export declare const PRETTIER_CONFIG_FILE_NAMES: readonly string[];
+/**
+ * Parameters for the {@link format} function.
+ */
+export interface FormatOptions {
+    /**
+     * The Prettier configuration used when the project has none of its own. Omitted, the shared one this package ships
+     * (`assets/prettier.json`) is used.
+     */
+    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 with Prettier.
+ *
+ * Prettier finds the project's own configuration itself. Only a project with none gets `--config`, pointing at
+ * {@link FormatOptions.defaultConfigFilePath} or at the shared configuration. `.gitignore` and `.prettierignore` are
+ * honored, as Prettier always does.
+ *
+ * @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>;
+/**
+ * Reads the shared Prettier configuration this package ships, for a project's own `prettier.config.mjs` to export or
+ * build on.
+ *
+ * @returns The shared configuration.
+ */
+export declare function getPrettierConfig(): Readonly<Record<string, unknown>>;
+/**
+ * Says whether the project configures Prettier itself.
+ *
+ * @returns Whether a Prettier configuration file, or a `prettier` key in `package.json`, exists at the project root.
+ */
+export declare function hasPrettierConfig(): Promise<boolean>;

package/dist/lib/esm/formatters/prettier.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
+*/
+
+import {
+  existsSync,
+  readFileSync
+} from "node:fs";
+import { readPackageJson } from "../npm.mjs";
+import { resolveToolCommand } from "../package-manager.mjs";
+import { RepoPaths } from "../repo-paths.mjs";
+import {
+  execFromRoot,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+import {
+  getSharedConfigFilePath,
+  SharedConfigFile
+} from "../shared-config-files.mjs";
+const PRETTIER_CONFIG_FILE_NAMES = [
+  ".prettierrc",
+  ".prettierrc.cjs",
+  ".prettierrc.cts",
+  ".prettierrc.js",
+  ".prettierrc.json",
+  ".prettierrc.json5",
+  ".prettierrc.mjs",
+  ".prettierrc.mts",
+  ".prettierrc.toml",
+  ".prettierrc.ts",
+  ".prettierrc.yaml",
+  ".prettierrc.yml",
+  "prettier.config.cjs",
+  "prettier.config.cts",
+  "prettier.config.js",
+  "prettier.config.mjs",
+  "prettier.config.mts",
+  "prettier.config.ts"
+];
+const EXCLUDED_PATTERNS = ["!**/*.md", "!**/*-lock.json"];
+async function format(options) {
+  const { defaultConfigFilePath, paths, rewrite = true } = options ?? {};
+  const configArguments = await hasPrettierConfig() ? [] : ["--config", defaultConfigFilePath ?? getSharedConfigFilePath(SharedConfigFile.Prettier)];
+  const hasPaths = paths !== void 0 && paths.length > 0;
+  await execFromRoot([
+    ...resolveToolCommand({ tool: "prettier" }),
+    rewrite ? "--write" : "--check",
+    "--ignore-unknown",
+    ...hasPaths ? ["--no-error-on-unmatched-pattern"] : [],
+    ...configArguments,
+    ...EXCLUDED_PATTERNS,
+    { batchedArguments: hasPaths ? paths : [RepoPaths.CurrentFolder] }
+  ]);
+}
+function getPrettierConfig() {
+  return JSON.parse(readFileSync(getSharedConfigFilePath(SharedConfigFile.Prettier), "utf-8"));
+}
+async function hasPrettierConfig() {
+  if (PRETTIER_CONFIG_FILE_NAMES.some((fileName) => existsSync(resolvePathFromRootSafe({ path: fileName })))) {
+    return true;
+  }
+  if (!existsSync(resolvePathFromRootSafe({ path: RepoPaths.PackageJson }))) {
+    return false;
+  }
+  const packageJson = await readPackageJson();
+  return Object.hasOwn(packageJson, "prettier");
+}
+export {
+  PRETTIER_CONFIG_FILE_NAMES,
+  format,
+  getPrettierConfig,
+  hasPrettierConfig
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -31,6 +31,7 @@ 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 'shared-config-files' from './shared-config-files.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

@@ -31,6 +31,7 @@ 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 shared_config_files from "./shared-config-files.mjs";
 import * as test_runners from "./test-runners/index.mjs";
 import * as validate_declarations from "./validate-declarations.mjs";
 import * as version from "./version.mjs";
@@ -63,8 +64,9 @@ export {
   released_issues as "released-issues",
   repo_paths as "repo-paths",
   root,
+  shared_config_files as "shared-config-files",
   test_runners as "test-runners",
   validate_declarations as "validate-declarations",
   version
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/auto.d.mts

@@ -0,0 +1,49 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Lints the project with whichever linter the project configures: ESLint or Biome.
+ */
+/**
+ * A linter the toolkit runs.
+ */
+export type Linter = 'biome' | 'eslint';
+/**
+ * Parameters for the {@link lint} function.
+ */
+export interface LintOptions {
+    /**
+     * The configuration file used when the project has none of its own, as the chosen linter's own `lint` takes it.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+    /**
+     * The linter to run. Omitted, {@link detectLinter} chooses it.
+     */
+    readonly linter?: Linter | undefined;
+    /**
+     * Optional file paths to lint. If omitted, lints the entire project.
+     */
+    readonly paths?: string[] | undefined;
+    /**
+     * Whether to fix linting issues automatically.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+}
+/**
+ * Chooses the linter from the configuration files at the project root.
+ *
+ * An `eslint.config.*` file wins, so a project that formats with Biome and lints with ESLint gets ESLint. Otherwise a
+ * `biome.json` / `biome.jsonc` picks Biome, and a project with neither gets ESLint, as before Biome was supported.
+ *
+ * @returns The linter to run.
+ */
+export declare function detectLinter(): Linter;
+/**
+ * Lints the project with its linter.
+ *
+ * @param options - The {@link LintOptions}.
+ * @returns A {@link Promise} that resolves when the project lints clean.
+ */
+export declare function lint(options?: LintOptions): Promise<void>;

package/dist/lib/esm/linters/auto.mjs

@@ -0,0 +1,30 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { hasBiomeConfig } from "../formatters/biome.mjs";
+import { lint as lintWithBiome } from "./biome.mjs";
+import {
+  hasEslintConfig,
+  lint as lintWithEslint
+} from "./eslint.mjs";
+const LINTERS = {
+  biome: lintWithBiome,
+  eslint: lintWithEslint
+};
+function detectLinter() {
+  if (hasEslintConfig()) {
+    return "eslint";
+  }
+  return hasBiomeConfig() ? "biome" : "eslint";
+}
+async function lint(options) {
+  const { linter = detectLinter(), ...lintOptions } = options ?? {};
+  await LINTERS[linter](lintOptions);
+}
+export {
+  detectLinter,
+  lint
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/biome.d.mts

@@ -0,0 +1,36 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Lints the project with Biome.
+ */
+/**
+ * Parameters for the {@link lint} function.
+ */
+export interface LintOptions {
+    /**
+     * The configuration file copied to the project root when the project has none. Omitted, a `biome.json` extending
+     * the shared one this package ships (`assets/biome.json`) is written instead.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+    /**
+     * Optional file paths to lint. If omitted, lints the entire project.
+     */
+    readonly paths?: string[] | undefined;
+    /**
+     * Whether to apply the safe fixes.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+}
+/**
+ * Lint the project with Biome.
+ *
+ * A warning fails the run, as it does for ESLint: Biome exits `0` on warnings unless it is given
+ * `--error-on-warnings`.
+ *
+ * @param options - The {@link LintOptions}.
+ * @returns A {@link Promise} that resolves when the project lints clean.
+ */
+export declare function lint(options?: LintOptions): Promise<void>;

package/dist/lib/esm/linters/biome.mjs

@@ -0,0 +1,29 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import {
+  BIOME_EXPLICIT_PATHS_ARGUMENTS,
+  ensureBiomeConfig
+} from "../formatters/biome.mjs";
+import { resolveToolCommand } from "../package-manager.mjs";
+import { RepoPaths } from "../repo-paths.mjs";
+import { execFromRoot } from "../root.mjs";
+async function lint(options) {
+  const { defaultConfigFilePath, paths, shouldFix } = options ?? {};
+  await ensureBiomeConfig({ defaultConfigFilePath });
+  const hasPaths = paths !== void 0 && paths.length > 0;
+  await execFromRoot([
+    ...resolveToolCommand({ tool: "biome" }),
+    "lint",
+    "--error-on-warnings",
+    ...shouldFix ? ["--write"] : [],
+    ...hasPaths ? BIOME_EXPLICIT_PATHS_ARGUMENTS : [],
+    { batchedArguments: hasPaths ? paths : [RepoPaths.CurrentFolder] }
+  ]);
+}
+export {
+  lint
+};
+//# sourceMappingURL=data:application/json;base64,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