@mnaoumov/typescript-dev-toolkit 2.2.0 → 3.1.0

package/dist/lib/cjs/test-runners/jest-config.cjs

@@ -0,0 +1,86 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_config_exports = {};
+__export(jest_config_exports, {
+  DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS: () => DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS,
+  JEST_RELATIVE_JS_IMPORT_MAPPER: () => JEST_RELATIVE_JS_IMPORT_MAPPER,
+  JEST_TYPESCRIPT_TRANSFORM_PATTERN: () => JEST_TYPESCRIPT_TRANSFORM_PATTERN,
+  defineJestConfig: () => defineJestConfig,
+  isEsmPackage: () => isEsmPackage
+});
+module.exports = __toCommonJS(jest_config_exports);
+var import_node_fs = require('node:fs');
+var import_npm = require('../npm.cjs');
+var import_repo_paths = require('../repo-paths.cjs');
+var import_root = require('../root.cjs');
+var import_vitest_config = require('./vitest-config.cjs');
+const JEST_TYPESCRIPT_TRANSFORM_PATTERN = String.raw`^.+\.[cm]?tsx?$`;
+const JEST_RELATIVE_JS_IMPORT_MAPPER = {
+  "^(\\.{1,2}/.*)\\.js$": "$1"
+};
+const DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS = ["/node_modules/", "/dist/"];
+function defineJestConfig(options = {}) {
+  const { esm = isEsmPackage(), moduleNameMapper, tsJestOptions, ...overrides } = options;
+  return {
+    collectCoverageFrom: [
+      ...import_vitest_config.LIBRARY_VITEST_COVERAGE.include,
+      ...import_vitest_config.LIBRARY_VITEST_COVERAGE.exclude.map((pattern) => `!${pattern}`)
+    ],
+    coverageDirectory: import_vitest_config.LIBRARY_VITEST_COVERAGE.reportsDirectory,
+    coverageProvider: import_vitest_config.LIBRARY_VITEST_COVERAGE.provider,
+    coverageReporters: ["text", "lcov", "html"],
+    extensionsToTreatAsEsm: esm ? [".ts", ".tsx"] : [],
+    moduleNameMapper: {
+      ...JEST_RELATIVE_JS_IMPORT_MAPPER,
+      ...moduleNameMapper
+    },
+    roots: ["<rootDir>/src"],
+    testEnvironment: "node",
+    testMatch: ["**/*.test.ts"],
+    testPathIgnorePatterns: [...DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS],
+    transform: {
+      [JEST_TYPESCRIPT_TRANSFORM_PATTERN]: [
+        "ts-jest",
+        {
+          tsconfig: { isolatedModules: true },
+          useESM: esm,
+          ...tsJestOptions
+        }
+      ]
+    },
+    ...overrides
+  };
+}
+function isEsmPackage() {
+  return (0, import_node_fs.existsSync)((0, import_root.resolvePathFromRootSafe)({ path: import_repo_paths.RepoPaths.PackageJson })) && (0, import_npm.readPackageJsonSync)().type === "module";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS,
+  JEST_RELATIVE_JS_IMPORT_MAPPER,
+  JEST_TYPESCRIPT_TRANSFORM_PATTERN,
+  defineJestConfig,
+  isEsmPackage
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/test-runners/jest-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared jest configuration for TypeScript packages: {@link defineJestConfig}, which fills in the ts-jest transform,\n * the ESM settings, the test excludes and the coverage block a project otherwise writes by hand.\n *\n * The coverage block is the one the vitest library configuration uses, so a package reports the same files whichever\n * runner it picks.\n */\n\nimport type { Config } from 'jest';\nimport type { TsJestTransformerOptions } from 'ts-jest';\n\nimport { existsSync } from 'node:fs';\n\nimport { readPackageJsonSync } from '../npm.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport { resolvePathFromRootSafe } from '../root.ts';\nimport { LIBRARY_VITEST_COVERAGE } from './vitest-config.ts';\n\n/**\n * The files ts-jest compiles: `.ts`, `.tsx`, `.mts` and `.cts`.\n */\nexport const JEST_TYPESCRIPT_TRANSFORM_PATTERN = String.raw`^.+\\.[cm]?tsx?$`;\n\n/**\n * Maps a relative import written with a `.js` extension onto the path without an extension, which jest resolves.\n *\n * A project compiled with `module: nodenext` writes `./foo.js` for `./foo.ts`, and so does TypeScript itself when\n * `rewriteRelativeImportExtensions` turns a `./foo.ts` import into `./foo.js`. Jest looks for a file literally named\n * `foo.js` and fails with `Cannot find module './foo.js'`, so the extension is removed and jest's own\n * `moduleFileExtensions` search finds `foo.ts`.\n */\nexport const JEST_RELATIVE_JS_IMPORT_MAPPER: Readonly<Record<string, string>> = {\n  '^(\\\\.{1,2}/.*)\\\\.js$': '$1'\n};\n\n/**\n * Folders jest never collects tests from.\n */\nexport const DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS: readonly string[] = ['/node_modules/', '/dist/'];\n\n/**\n * Options for {@link defineJestConfig}: any jest option, which wins over the default the function would otherwise\n * set, plus the two below.\n */\nexport interface DefineJestConfigOptions extends Config {\n  /**\n   * Whether jest loads the project as ES modules.\n   *\n   * ESM needs `extensionsToTreatAsEsm`, ts-jest's `useESM`, and Node's `--experimental-vm-modules`, which the jest\n   * runner in this package adds by the same rule.\n   *\n   * @default `true` when `package.json` declares `\"type\": \"module\"`\n   */\n  readonly esm?: boolean;\n\n  /**\n   * Options for the ts-jest transform, spread over the defaults: `useESM` from {@link esm}, and a `tsconfig` of\n   * `{ isolatedModules: true }`, so each file is transpiled on its own, without a type check, as vitest does. A\n   * `tsconfig` given here replaces that default rather than merging with it.\n   *\n   * Ignored when {@link Config.transform} is given.\n   */\n  readonly tsJestOptions?: TsJestTransformerOptions;\n}\n\n/**\n * Defines a TypeScript project's jest configuration.\n *\n * The defaults: the tests are `src/**\\/*.test.ts`, run in the `node` environment, transformed by ts-jest, as ESM when\n * the package is (see {@link DefineJestConfigOptions.esm}); a `.js` relative import resolves onto its `.ts` source;\n * coverage is v8 over `src/`, without the barrels, the declarations, the tests and the test helpers, reported as\n * `text`, `lcov` and `html` into `coverage/`. Every jest option in `options` replaces its default, except\n * `moduleNameMapper`, whose entries are added to the `.js` mapper.\n *\n * @param options - The configuration options.\n * @returns The jest configuration.\n */\nexport function defineJestConfig(options: DefineJestConfigOptions = {}): Config {\n  const { esm = isEsmPackage(), moduleNameMapper, tsJestOptions, ...overrides } = options;\n\n  return {\n    collectCoverageFrom: [\n      ...LIBRARY_VITEST_COVERAGE.include,\n      ...LIBRARY_VITEST_COVERAGE.exclude.map((pattern) => `!${pattern}`)\n    ],\n    coverageDirectory: LIBRARY_VITEST_COVERAGE.reportsDirectory,\n    coverageProvider: LIBRARY_VITEST_COVERAGE.provider,\n    coverageReporters: ['text', 'lcov', 'html'],\n    extensionsToTreatAsEsm: esm ? ['.ts', '.tsx'] : [],\n    moduleNameMapper: {\n      ...JEST_RELATIVE_JS_IMPORT_MAPPER,\n      ...moduleNameMapper\n    },\n    roots: ['<rootDir>/src'],\n    testEnvironment: 'node',\n    testMatch: ['**/*.test.ts'],\n    testPathIgnorePatterns: [...DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS],\n    transform: {\n      [JEST_TYPESCRIPT_TRANSFORM_PATTERN]: [\n        'ts-jest',\n        {\n          tsconfig: { isolatedModules: true },\n          useESM: esm,\n          ...tsJestOptions\n        }\n      ]\n    },\n    ...overrides\n  };\n}\n\n/**\n * Says whether the project at the root is an ES module package.\n *\n * @returns Whether its `package.json` declares `\"type\": \"module\"`. A project without a `package.json` is not.\n */\nexport function isEsmPackage(): boolean {\n  return existsSync(resolvePathFromRootSafe({ path: RepoPaths.PackageJson })) && readPackageJsonSync().type === 'module';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,qBAA2B;AAE3B,iBAAoC;AACpC,wBAA0B;AAC1B,kBAAwC;AACxC,2BAAwC;AAKjC,MAAM,oCAAoC,OAAO;AAUjD,MAAM,iCAAmE;AAAA,EAC9E,wBAAwB;AAC1B;AAKO,MAAM,yCAA4D,CAAC,kBAAkB,QAAQ;AAuC7F,SAAS,iBAAiB,UAAmC,CAAC,GAAW;AAC9E,QAAM,EAAE,MAAM,aAAa,GAAG,kBAAkB,eAAe,GAAG,UAAU,IAAI;AAEhF,SAAO;AAAA,IACL,qBAAqB;AAAA,MACnB,GAAG,6CAAwB;AAAA,MAC3B,GAAG,6CAAwB,QAAQ,IAAI,CAAC,YAAY,IAAI,OAAO,EAAE;AAAA,IACnE;AAAA,IACA,mBAAmB,6CAAwB;AAAA,IAC3C,kBAAkB,6CAAwB;AAAA,IAC1C,mBAAmB,CAAC,QAAQ,QAAQ,MAAM;AAAA,IAC1C,wBAAwB,MAAM,CAAC,OAAO,MAAM,IAAI,CAAC;AAAA,IACjD,kBAAkB;AAAA,MAChB,GAAG;AAAA,MACH,GAAG;AAAA,IACL;AAAA,IACA,OAAO,CAAC,eAAe;AAAA,IACvB,iBAAiB;AAAA,IACjB,WAAW,CAAC,cAAc;AAAA,IAC1B,wBAAwB,CAAC,GAAG,sCAAsC;AAAA,IAClE,WAAW;AAAA,MACT,CAAC,iCAAiC,GAAG;AAAA,QACnC;AAAA,QACA;AAAA,UACE,UAAU,EAAE,iBAAiB,KAAK;AAAA,UAClC,QAAQ;AAAA,UACR,GAAG;AAAA,QACL;AAAA,MACF;AAAA,IACF;AAAA,IACA,GAAG;AAAA,EACL;AACF;AAOO,SAAS,eAAwB;AACtC,aAAO,+BAAW,qCAAwB,EAAE,MAAM,4BAAU,YAAY,CAAC,CAAC,SAAK,gCAAoB,EAAE,SAAS;AAChH;",
  "names": []
}


package/dist/lib/cjs/test-runners/jest-config.d.cts

@@ -0,0 +1,71 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Shared jest configuration for TypeScript packages: {@link defineJestConfig}, which fills in the ts-jest transform,
+ * the ESM settings, the test excludes and the coverage block a project otherwise writes by hand.
+ *
+ * The coverage block is the one the vitest library configuration uses, so a package reports the same files whichever
+ * runner it picks.
+ */
+import type { Config } from 'jest' with { 'resolution-mode': 'import' };
+import type { TsJestTransformerOptions } from 'ts-jest' with { 'resolution-mode': 'import' };
+/**
+ * The files ts-jest compiles: `.ts`, `.tsx`, `.mts` and `.cts`.
+ */
+export declare const JEST_TYPESCRIPT_TRANSFORM_PATTERN: string;
+/**
+ * Maps a relative import written with a `.js` extension onto the path without an extension, which jest resolves.
+ *
+ * A project compiled with `module: nodenext` writes `./foo.js` for `./foo.ts`, and so does TypeScript itself when
+ * `rewriteRelativeImportExtensions` turns a `./foo.ts` import into `./foo.js`. Jest looks for a file literally named
+ * `foo.js` and fails with `Cannot find module './foo.js'`, so the extension is removed and jest's own
+ * `moduleFileExtensions` search finds `foo.ts`.
+ */
+export declare const JEST_RELATIVE_JS_IMPORT_MAPPER: Readonly<Record<string, string>>;
+/**
+ * Folders jest never collects tests from.
+ */
+export declare const DEFAULT_JEST_TEST_PATH_IGNORE_PATTERNS: readonly string[];
+/**
+ * Options for {@link defineJestConfig}: any jest option, which wins over the default the function would otherwise
+ * set, plus the two below.
+ */
+export interface DefineJestConfigOptions extends Config {
+    /**
+     * Whether jest loads the project as ES modules.
+     *
+     * ESM needs `extensionsToTreatAsEsm`, ts-jest's `useESM`, and Node's `--experimental-vm-modules`, which the jest
+     * runner in this package adds by the same rule.
+     *
+     * @default `true` when `package.json` declares `"type": "module"`
+     */
+    readonly esm?: boolean;
+    /**
+     * Options for the ts-jest transform, spread over the defaults: `useESM` from {@link esm}, and a `tsconfig` of
+     * `{ isolatedModules: true }`, so each file is transpiled on its own, without a type check, as vitest does. A
+     * `tsconfig` given here replaces that default rather than merging with it.
+     *
+     * Ignored when {@link Config.transform} is given.
+     */
+    readonly tsJestOptions?: TsJestTransformerOptions;
+}
+/**
+ * Defines a TypeScript project's jest configuration.
+ *
+ * The defaults: the tests are `src/**\/*.test.ts`, run in the `node` environment, transformed by ts-jest, as ESM when
+ * the package is (see {@link DefineJestConfigOptions.esm}); a `.js` relative import resolves onto its `.ts` source;
+ * coverage is v8 over `src/`, without the barrels, the declarations, the tests and the test helpers, reported as
+ * `text`, `lcov` and `html` into `coverage/`. Every jest option in `options` replaces its default, except
+ * `moduleNameMapper`, whose entries are added to the `.js` mapper.
+ *
+ * @param options - The configuration options.
+ * @returns The jest configuration.
+ */
+export declare function defineJestConfig(options?: DefineJestConfigOptions): Config;
+/**
+ * Says whether the project at the root is an ES module package.
+ *
+ * @returns Whether its `package.json` declares `"type": "module"`. A project without a `package.json` is not.
+ */
+export declare function isEsmPackage(): boolean;

package/dist/lib/cjs/test-runners/jest.cjs

@@ -0,0 +1,111 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jest_exports = {};
+__export(jest_exports, {
+  EXPERIMENTAL_VM_MODULES_FLAG: () => EXPERIMENTAL_VM_MODULES_FLAG,
+  JEST_CONFIG_FILE_NAMES: () => JEST_CONFIG_FILE_NAMES,
+  hasJestConfig: () => hasJestConfig,
+  test: () => test,
+  testCoverage: () => testCoverage,
+  testWatch: () => testWatch
+});
+module.exports = __toCommonJS(jest_exports);
+var import_node_fs = require('node:fs');
+var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
+var import_npm = require('../npm.cjs');
+var import_package_manager = require('../package-manager.cjs');
+var import_repo_paths = require('../repo-paths.cjs');
+var import_root = require('../root.cjs');
+var import_jest_config = require('./jest-config.cjs');
+const JEST_CONFIG_FILE_NAMES = [
+  "jest.config.cjs",
+  "jest.config.cts",
+  "jest.config.js",
+  "jest.config.json",
+  "jest.config.mjs",
+  "jest.config.mts",
+  "jest.config.ts"
+];
+const EXPERIMENTAL_VM_MODULES_FLAG = "--experimental-vm-modules";
+async function hasJestConfig() {
+  if (JEST_CONFIG_FILE_NAMES.some((fileName) => (0, import_node_fs.existsSync)((0, import_root.resolvePathFromRootSafe)({ path: fileName })))) {
+    return true;
+  }
+  if (!(0, import_node_fs.existsSync)((0, import_root.resolvePathFromRootSafe)({ path: import_repo_paths.RepoPaths.PackageJson }))) {
+    return false;
+  }
+  const packageJson = await (0, import_npm.readPackageJson)();
+  return Object.hasOwn(packageJson, "jest");
+}
+async function test(options = {}) {
+  await runJest([], options);
+}
+async function testCoverage(options = {}) {
+  const threshold = options.minCoverageInPercents ?? 0;
+  const coverageThreshold = {
+    global: {
+      branches: threshold,
+      functions: threshold,
+      lines: threshold,
+      statements: threshold
+    }
+  };
+  await runJest(["--coverage", `--coverageThreshold=${JSON.stringify(coverageThreshold)}`], options);
+}
+async function testWatch(options = {}) {
+  await runJest(["--watch"], options, true);
+}
+function addExperimentalVmModulesFlag(nodeOptions) {
+  const flags = (nodeOptions ?? "").split(/\s+/).filter(Boolean);
+  if (!flags.includes(EXPERIMENTAL_VM_MODULES_FLAG)) {
+    flags.push(EXPERIMENTAL_VM_MODULES_FLAG);
+  }
+  return flags.join(" ");
+}
+async function runJest(runArguments, options, isInteractive = false) {
+  const { esm = (0, import_jest_config.isEsmPackage)(), projects = [] } = options;
+  const projectArguments = projects.length > 0 ? ["--selectProjects", ...projects] : [];
+  const env = esm ? { NODE_OPTIONS: addExperimentalVmModulesFlag(import_node_process.default.env["NODE_OPTIONS"]) } : {};
+  await (0, import_root.execFromRoot)([...(0, import_package_manager.resolveToolCommand)({ tool: "jest" }), ...runArguments, ...projectArguments], { env, isInteractive });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXPERIMENTAL_VM_MODULES_FLAG,
+  JEST_CONFIG_FILE_NAMES,
+  hasJestConfig,
+  test,
+  testCoverage,
+  testWatch
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/test-runners/jest.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides functions for running tests using the Jest framework.\n */\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport { readPackageJson } from '../npm.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport { isEsmPackage } from './jest-config.ts';\n\n/**\n * Every file jest reads its configuration from, besides the `jest` key of `package.json`.\n *\n * @see {@link https://jestjs.io/docs/configuration}\n */\nexport const JEST_CONFIG_FILE_NAMES: readonly string[] = [\n  'jest.config.cjs',\n  'jest.config.cts',\n  'jest.config.js',\n  'jest.config.json',\n  'jest.config.mjs',\n  'jest.config.mts',\n  'jest.config.ts'\n];\n\n/**\n * The Node flag jest's ESM loader needs: it is built on `vm.SyntheticModule`, which Node only exposes under it.\n * Without it every ESM suite fails to load with `Must use import to load ES Module`.\n */\nexport const EXPERIMENTAL_VM_MODULES_FLAG = '--experimental-vm-modules';\n\n/**\n * Options for running tests with coverage.\n */\nexport interface TestCoverageOptions extends TestOptions {\n  /**\n   * Minimum coverage percentage required, for lines, functions, branches and statements alike. If the actual coverage\n   * falls below it, jest exits with a non-zero code.\n   *\n   * @default `0`\n   */\n  readonly minCoverageInPercents?: number;\n}\n\n/**\n * Options for running tests.\n */\nexport interface TestOptions {\n  /**\n   * Whether jest runs the suite as ES modules, which adds {@link EXPERIMENTAL_VM_MODULES_FLAG} to `NODE_OPTIONS`.\n   *\n   * @default `true` when `package.json` declares `\"type\": \"module\"`, the rule `defineJestConfig` follows too\n   */\n  readonly esm?: boolean;\n\n  /**\n   * The projects to run, by their `displayName`, passed to jest's `--selectProjects`. Unlike vitest's runner, a name\n   * matches only itself: jest has no `name:*` form.\n   */\n  readonly projects?: string[];\n}\n\n/**\n * Options for running tests in watch mode.\n */\nexport type TestWatchOptions = TestOptions;\n\n/**\n * Says whether the project configures jest.\n *\n * @returns Whether a jest configuration file, or a `jest` key in `package.json`, exists at the project root.\n */\nexport async function hasJestConfig(): Promise<boolean> {\n  if (JEST_CONFIG_FILE_NAMES.some((fileName) => existsSync(resolvePathFromRootSafe({ path: fileName })))) {\n    return true;\n  }\n\n  if (!existsSync(resolvePathFromRootSafe({ path: RepoPaths.PackageJson }))) {\n    return false;\n  }\n\n  const packageJson = await readPackageJson();\n  return Object.hasOwn(packageJson, 'jest');\n}\n\n/**\n * Runs the test suite.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function test(options: TestOptions = {}): Promise<void> {\n  await runJest([], options);\n}\n\n/**\n * Runs the test suite with coverage.\n *\n * @param options - Optional coverage configuration.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function testCoverage(options: TestCoverageOptions = {}): Promise<void> {\n  const threshold = options.minCoverageInPercents ?? 0;\n  const coverageThreshold = {\n    global: {\n      branches: threshold,\n      functions: threshold,\n      lines: threshold,\n      statements: threshold\n    }\n  };\n  await runJest(['--coverage', `--coverageThreshold=${JSON.stringify(coverageThreshold)}`], options);\n}\n\n/**\n * Runs the test suite in watch mode, re-running the tests the changed files affect. Jest needs a git or Mercurial\n * repository for that.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the watcher exits.\n */\nexport async function testWatch(options: TestWatchOptions = {}): Promise<void> {\n  await runJest(['--watch'], options, true);\n}\n\n/**\n * Appends {@link EXPERIMENTAL_VM_MODULES_FLAG} to a `NODE_OPTIONS` value, keeping whatever it already holds.\n *\n * @param nodeOptions - The inherited `NODE_OPTIONS`.\n * @returns The `NODE_OPTIONS` jest runs with.\n */\nfunction addExperimentalVmModulesFlag(nodeOptions: string | undefined): string {\n  const flags = (nodeOptions ?? '').split(/\\s+/).filter(Boolean);\n  if (!flags.includes(EXPERIMENTAL_VM_MODULES_FLAG)) {\n    flags.push(EXPERIMENTAL_VM_MODULES_FLAG);\n  }\n\n  return flags.join(' ');\n}\n\n/**\n * Runs the jest CLI from the project root.\n *\n * @param runArguments - The arguments that select what jest does.\n * @param options - The {@link TestOptions}.\n * @param isInteractive - Whether jest gets the terminal, as its watch mode needs to read keys.\n * @returns A {@link Promise} that resolves when jest exits.\n */\nasync function runJest(runArguments: string[], options: TestOptions, isInteractive = false): Promise<void> {\n  const { esm = isEsmPackage(), projects = [] } = options;\n  const projectArguments = projects.length > 0 ? ['--selectProjects', ...projects] : [];\n  const env = esm ? { NODE_OPTIONS: addExperimentalVmModulesFlag(process.env['NODE_OPTIONS']) } : {};\n\n  await execFromRoot([...resolveToolCommand({ tool: 'jest' }), ...runArguments, ...projectArguments], { env, isInteractive });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA2B;AAC3B,0BAAoB;AAEpB,iBAAgC;AAChC,6BAAmC;AACnC,wBAA0B;AAC1B,kBAGO;AACP,yBAA6B;AAOtB,MAAM,yBAA4C;AAAA,EACvD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAMO,MAAM,+BAA+B;AA2C5C,eAAsB,gBAAkC;AACtD,MAAI,uBAAuB,KAAK,CAAC,iBAAa,+BAAW,qCAAwB,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG;AACtG,WAAO;AAAA,EACT;AAEA,MAAI,KAAC,+BAAW,qCAAwB,EAAE,MAAM,4BAAU,YAAY,CAAC,CAAC,GAAG;AACzE,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,UAAM,4BAAgB;AAC1C,SAAO,OAAO,OAAO,aAAa,MAAM;AAC1C;AAQA,eAAsB,KAAK,UAAuB,CAAC,GAAkB;AACnE,QAAM,QAAQ,CAAC,GAAG,OAAO;AAC3B;AAQA,eAAsB,aAAa,UAA+B,CAAC,GAAkB;AACnF,QAAM,YAAY,QAAQ,yBAAyB;AACnD,QAAM,oBAAoB;AAAA,IACxB,QAAQ;AAAA,MACN,UAAU;AAAA,MACV,WAAW;AAAA,MACX,OAAO;AAAA,MACP,YAAY;AAAA,IACd;AAAA,EACF;AACA,QAAM,QAAQ,CAAC,cAAc,uBAAuB,KAAK,UAAU,iBAAiB,CAAC,EAAE,GAAG,OAAO;AACnG;AASA,eAAsB,UAAU,UAA4B,CAAC,GAAkB;AAC7E,QAAM,QAAQ,CAAC,SAAS,GAAG,SAAS,IAAI;AAC1C;AAQA,SAAS,6BAA6B,aAAyC;AAC7E,QAAM,SAAS,eAAe,IAAI,MAAM,KAAK,EAAE,OAAO,OAAO;AAC7D,MAAI,CAAC,MAAM,SAAS,4BAA4B,GAAG;AACjD,UAAM,KAAK,4BAA4B;AAAA,EACzC;AAEA,SAAO,MAAM,KAAK,GAAG;AACvB;AAUA,eAAe,QAAQ,cAAwB,SAAsB,gBAAgB,OAAsB;AACzG,QAAM,EAAE,UAAM,iCAAa,GAAG,WAAW,CAAC,EAAE,IAAI;AAChD,QAAM,mBAAmB,SAAS,SAAS,IAAI,CAAC,oBAAoB,GAAG,QAAQ,IAAI,CAAC;AACpF,QAAM,MAAM,MAAM,EAAE,cAAc,6BAA6B,oBAAAA,QAAQ,IAAI,cAAc,CAAC,EAAE,IAAI,CAAC;AAEjG,YAAM,0BAAa,CAAC,OAAG,2CAAmB,EAAE,MAAM,OAAO,CAAC,GAAG,GAAG,cAAc,GAAG,gBAAgB,GAAG,EAAE,KAAK,cAAc,CAAC;AAC5H;",
  "names": ["process"]
}


package/dist/lib/cjs/test-runners/jest.d.cts

@@ -0,0 +1,77 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * This module provides functions for running tests using the Jest framework.
+ */
+/**
+ * Every file jest reads its configuration from, besides the `jest` key of `package.json`.
+ *
+ * @see {@link https://jestjs.io/docs/configuration}
+ */
+export declare const JEST_CONFIG_FILE_NAMES: readonly string[];
+/**
+ * The Node flag jest's ESM loader needs: it is built on `vm.SyntheticModule`, which Node only exposes under it.
+ * Without it every ESM suite fails to load with `Must use import to load ES Module`.
+ */
+export declare const EXPERIMENTAL_VM_MODULES_FLAG = "--experimental-vm-modules";
+/**
+ * Options for running tests with coverage.
+ */
+export interface TestCoverageOptions extends TestOptions {
+    /**
+     * Minimum coverage percentage required, for lines, functions, branches and statements alike. If the actual coverage
+     * falls below it, jest exits with a non-zero code.
+     *
+     * @default `0`
+     */
+    readonly minCoverageInPercents?: number;
+}
+/**
+ * Options for running tests.
+ */
+export interface TestOptions {
+    /**
+     * Whether jest runs the suite as ES modules, which adds {@link EXPERIMENTAL_VM_MODULES_FLAG} to `NODE_OPTIONS`.
+     *
+     * @default `true` when `package.json` declares `"type": "module"`, the rule `defineJestConfig` follows too
+     */
+    readonly esm?: boolean;
+    /**
+     * The projects to run, by their `displayName`, passed to jest's `--selectProjects`. Unlike vitest's runner, a name
+     * matches only itself: jest has no `name:*` form.
+     */
+    readonly projects?: string[];
+}
+/**
+ * Options for running tests in watch mode.
+ */
+export type TestWatchOptions = TestOptions;
+/**
+ * Says whether the project configures jest.
+ *
+ * @returns Whether a jest configuration file, or a `jest` key in `package.json`, exists at the project root.
+ */
+export declare function hasJestConfig(): Promise<boolean>;
+/**
+ * Runs the test suite.
+ *
+ * @param options - The options for the test.
+ * @returns A {@link Promise} that resolves when the tests have completed.
+ */
+export declare function test(options?: TestOptions): Promise<void>;
+/**
+ * Runs the test suite with coverage.
+ *
+ * @param options - Optional coverage configuration.
+ * @returns A {@link Promise} that resolves when the tests have completed.
+ */
+export declare function testCoverage(options?: TestCoverageOptions): Promise<void>;
+/**
+ * Runs the test suite in watch mode, re-running the tests the changed files affect. Jest needs a git or Mercurial
+ * repository for that.
+ *
+ * @param options - The options for the test.
+ * @returns A {@link Promise} that resolves when the watcher exits.
+ */
+export declare function testWatch(options?: TestWatchOptions): Promise<void>;

package/dist/lib/esm/docs-site/docs-links.mjs

@@ -15,6 +15,7 @@ import {
   extractIds,
   formatBrokenLinks,
   NETWORK_FAILURE_STATUS,
+  parseRetryAfterInMilliseconds,
   resolveWithinRoot
 } from "./link-check.mjs";
 import {
@@ -77,9 +78,12 @@ async function fetchUrlStatus(url) {
   try {
     const response = await fetch(url, { signal: controller.signal });
     await response.body?.cancel();
-    return response.status;
+    return {
+      retryAfterInMilliseconds: parseRetryAfterInMilliseconds(response.headers.get("retry-after"), Date.now()),
+      status: response.status
+    };
   } catch {
-    return NETWORK_FAILURE_STATUS;
+    return { status: NETWORK_FAILURE_STATUS };
   } finally {
     globalThis.clearTimeout(timeoutId);
   }
@@ -110,4 +114,4 @@ async function readPages(outputRootPath, allFiles) {
 export {
   assertDocsLinksResolve
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/docs-site/docs-links.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Validates the links emitted by a built documentation site.\n *\n * Internal links are resolved offline against the build output; external links are validated over the network,\n * deduplicated so each unique URL is fetched at most once. See {@link ./link-check.ts} for the decision logic.\n *\n * It also fails on a GitHub alert that reached a page as a plain blockquote (see {@link ./unrendered-alerts.ts}),\n * since nothing else notices when the conversion stops.\n */\n\nimport {\n  readdir,\n  readFile\n} from 'node:fs/promises';\nimport { resolve } from 'node:path';\n\nimport type {\n  DocumentationPage,\n  LinkCheckFileSystem\n} from './link-check.ts';\n\nimport {\n  collectBrokenExternalLinks,\n  collectBrokenLinks,\n  collectExternalTargets,\n  extractIds,\n  formatBrokenLinks,\n  NETWORK_FAILURE_STATUS,\n  resolveWithinRoot\n} from './link-check.ts';\nimport {\n  collectUnrenderedAlerts,\n  formatUnrenderedAlerts\n} from './unrendered-alerts.ts';\n\n/**\n * Options for {@link assertDocsLinksResolve}.\n */\nexport interface AssertDocsLinksResolveParams {\n  /**\n   * The build output folder, normally `<docs>/dist`.\n   */\n  readonly outputDirectory: string;\n\n  /**\n   * The absolute URL the site is served from, with a trailing slash, e.g. `https://mnaoumov.dev/typescript-lib/`.\n   */\n  readonly siteBaseUrl: string;\n}\n\nconst EXTERNAL_LINK_TIMEOUT_IN_MILLISECONDS = 10_000;\nconst EXTERNAL_LINK_CONCURRENCY = 20;\nconst HTML_FILE_EXTENSION = '.html';\n\n// The host serves this page as the fallback for any missing path (with a 404 status), so it is not a\n// real navigable route: Starlight gives it a self-`rel=\"canonical\"` of `/404/` that inherently cannot\n// resolve, and its body links (nav, logo) are identical to every real page we already validate.\nconst FALLBACK_PAGE_RELATIVE_PATH = '404.html';\n\ninterface CreateFileSystemParams {\n  readonly allFiles: Set<string>;\n  readonly outputDirectory: string;\n  readonly pages: DocumentationPage[];\n}\n\n/**\n * Checks every link of the built site, and that every GitHub alert rendered as an aside.\n *\n * @param options - The options.\n * @throws If an alert rendered as a plain blockquote, or a link does not resolve.\n */\nexport async function assertDocsLinksResolve(options: AssertDocsLinksResolveParams): Promise<void> {\n  const outputDirectory = resolve(options.outputDirectory).replaceAll('\\\\', '/');\n  const allFiles = await getAllFiles(outputDirectory);\n  const pages = await readPages(outputDirectory, allFiles);\n\n  // Offline and instant, so it runs before the network half and fails first.\n  const unrenderedAlerts = collectUnrenderedAlerts(pages);\n  if (unrenderedAlerts.length > 0) {\n    throw new Error(\n      `Detected ${String(unrenderedAlerts.length)} GitHub alert(s) rendered as a plain blockquote instead of an aside:\\n${formatUnrenderedAlerts(unrenderedAlerts)}`\n    );\n  }\n\n  const internalBrokenLinks = collectBrokenLinks(pages, createFileSystem({ allFiles, outputDirectory, pages }), options.siteBaseUrl);\n\n  const externalTargets = collectExternalTargets(pages, options.siteBaseUrl);\n  const externalBrokenLinks = await collectBrokenExternalLinks(externalTargets, fetchUrlStatus, EXTERNAL_LINK_CONCURRENCY);\n\n  const brokenLinks = [...internalBrokenLinks, ...externalBrokenLinks];\n  if (brokenLinks.length > 0) {\n    throw new Error(`Detected ${String(brokenLinks.length)} broken documentation link(s):\\n${formatBrokenLinks(brokenLinks)}`);\n  }\n}\n\nfunction createFileSystem(params: CreateFileSystemParams): LinkCheckFileSystem {\n  const { allFiles, outputDirectory, pages } = params;\n  const htmlByRelativePath = new Map(pages.map((page) => [page.relativePath, page.html]));\n  const idsCache = new Map<string, Set<string>>();\n\n  return {\n    readIds: (pageKey): Set<string> => {\n      let ids = idsCache.get(pageKey);\n      if (ids === undefined) {\n        const html = htmlByRelativePath.get(pageKey);\n        ids = html === undefined ? new Set<string>() : extractIds(html);\n        idsCache.set(pageKey, ids);\n      }\n\n      return ids;\n    },\n    resolveExistingPage: (outputRelativePath): null | string => {\n      if (resolveWithinRoot(outputDirectory, outputRelativePath) === null) {\n        return null;\n      }\n\n      const trimmed = outputRelativePath.replace(/\\/$/u, '');\n      const candidates = trimmed === '' ? ['index.html'] : [trimmed, `${trimmed}/index.html`];\n      return candidates.find((candidate) => allFiles.has(candidate)) ?? null;\n    }\n  };\n}\n\nasync function fetchUrlStatus(url: string): Promise<number> {\n  const controller = new AbortController();\n  const timeoutId = globalThis.setTimeout(() => {\n    controller.abort();\n  }, EXTERNAL_LINK_TIMEOUT_IN_MILLISECONDS);\n\n  try {\n    const response = await fetch(url, { signal: controller.signal });\n    // Cancel the unread body so undici releases the connection immediately.\n    // Without this the per-host connection pool stalls and same-host requests\n    // serialize, turning a ~3s run into minutes.\n    await response.body?.cancel();\n    return response.status;\n  } catch {\n    return NETWORK_FAILURE_STATUS;\n  } finally {\n    globalThis.clearTimeout(timeoutId);\n  }\n}\n\nasync function getAllFiles(outputRootPath: string): Promise<Set<string>> {\n  const entries = await readdir(outputRootPath, { recursive: true, withFileTypes: true });\n  const files = new Set<string>();\n  for (const entry of entries) {\n    if (!entry.isFile()) {\n      continue;\n    }\n\n    const absolutePath = resolve(entry.parentPath, entry.name).replaceAll('\\\\', '/');\n    files.add(absolutePath.slice(`${outputRootPath}/`.length));\n  }\n\n  return files;\n}\n\nasync function readPages(outputRootPath: string, allFiles: Set<string>): Promise<DocumentationPage[]> {\n  const pages: DocumentationPage[] = [];\n  for (const relativePath of allFiles) {\n    if (!relativePath.endsWith(HTML_FILE_EXTENSION) || relativePath === FALLBACK_PAGE_RELATIVE_PATH) {\n      continue;\n    }\n\n    const html = await readFile(resolve(outputRootPath, relativePath), 'utf-8');\n    pages.push({ html, relativePath });\n  }\n\n  return pages;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/docs-site/docs-links.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Validates the links emitted by a built documentation site.\n *\n * Internal links are resolved offline against the build output; external links are validated over the network,\n * deduplicated so each unique URL is fetched at most once. See {@link ./link-check.ts} for the decision logic.\n *\n * It also fails on a GitHub alert that reached a page as a plain blockquote (see {@link ./unrendered-alerts.ts}),\n * since nothing else notices when the conversion stops.\n */\n\nimport {\n  readdir,\n  readFile\n} from 'node:fs/promises';\nimport { resolve } from 'node:path';\n\nimport type {\n  DocumentationPage,\n  ExternalLinkProbeResult,\n  LinkCheckFileSystem\n} from './link-check.ts';\n\nimport {\n  collectBrokenExternalLinks,\n  collectBrokenLinks,\n  collectExternalTargets,\n  extractIds,\n  formatBrokenLinks,\n  NETWORK_FAILURE_STATUS,\n  parseRetryAfterInMilliseconds,\n  resolveWithinRoot\n} from './link-check.ts';\nimport {\n  collectUnrenderedAlerts,\n  formatUnrenderedAlerts\n} from './unrendered-alerts.ts';\n\n/**\n * Options for {@link assertDocsLinksResolve}.\n */\nexport interface AssertDocsLinksResolveParams {\n  /**\n   * The build output folder, normally `<docs>/dist`.\n   */\n  readonly outputDirectory: string;\n\n  /**\n   * The absolute URL the site is served from, with a trailing slash, e.g. `https://mnaoumov.dev/typescript-lib/`.\n   */\n  readonly siteBaseUrl: string;\n}\n\nconst EXTERNAL_LINK_TIMEOUT_IN_MILLISECONDS = 10_000;\nconst EXTERNAL_LINK_CONCURRENCY = 20;\nconst HTML_FILE_EXTENSION = '.html';\n\n// The host serves this page as the fallback for any missing path (with a 404 status), so it is not a\n// real navigable route: Starlight gives it a self-`rel=\"canonical\"` of `/404/` that inherently cannot\n// resolve, and its body links (nav, logo) are identical to every real page we already validate.\nconst FALLBACK_PAGE_RELATIVE_PATH = '404.html';\n\ninterface CreateFileSystemParams {\n  readonly allFiles: Set<string>;\n  readonly outputDirectory: string;\n  readonly pages: DocumentationPage[];\n}\n\n/**\n * Checks every link of the built site, and that every GitHub alert rendered as an aside.\n *\n * @param options - The options.\n * @throws If an alert rendered as a plain blockquote, or a link does not resolve.\n */\nexport async function assertDocsLinksResolve(options: AssertDocsLinksResolveParams): Promise<void> {\n  const outputDirectory = resolve(options.outputDirectory).replaceAll('\\\\', '/');\n  const allFiles = await getAllFiles(outputDirectory);\n  const pages = await readPages(outputDirectory, allFiles);\n\n  // Offline and instant, so it runs before the network half and fails first.\n  const unrenderedAlerts = collectUnrenderedAlerts(pages);\n  if (unrenderedAlerts.length > 0) {\n    throw new Error(\n      `Detected ${String(unrenderedAlerts.length)} GitHub alert(s) rendered as a plain blockquote instead of an aside:\\n${formatUnrenderedAlerts(unrenderedAlerts)}`\n    );\n  }\n\n  const internalBrokenLinks = collectBrokenLinks(pages, createFileSystem({ allFiles, outputDirectory, pages }), options.siteBaseUrl);\n\n  const externalTargets = collectExternalTargets(pages, options.siteBaseUrl);\n  const externalBrokenLinks = await collectBrokenExternalLinks(externalTargets, fetchUrlStatus, EXTERNAL_LINK_CONCURRENCY);\n\n  const brokenLinks = [...internalBrokenLinks, ...externalBrokenLinks];\n  if (brokenLinks.length > 0) {\n    throw new Error(`Detected ${String(brokenLinks.length)} broken documentation link(s):\\n${formatBrokenLinks(brokenLinks)}`);\n  }\n}\n\nfunction createFileSystem(params: CreateFileSystemParams): LinkCheckFileSystem {\n  const { allFiles, outputDirectory, pages } = params;\n  const htmlByRelativePath = new Map(pages.map((page) => [page.relativePath, page.html]));\n  const idsCache = new Map<string, Set<string>>();\n\n  return {\n    readIds: (pageKey): Set<string> => {\n      let ids = idsCache.get(pageKey);\n      if (ids === undefined) {\n        const html = htmlByRelativePath.get(pageKey);\n        ids = html === undefined ? new Set<string>() : extractIds(html);\n        idsCache.set(pageKey, ids);\n      }\n\n      return ids;\n    },\n    resolveExistingPage: (outputRelativePath): null | string => {\n      if (resolveWithinRoot(outputDirectory, outputRelativePath) === null) {\n        return null;\n      }\n\n      const trimmed = outputRelativePath.replace(/\\/$/u, '');\n      const candidates = trimmed === '' ? ['index.html'] : [trimmed, `${trimmed}/index.html`];\n      return candidates.find((candidate) => allFiles.has(candidate)) ?? null;\n    }\n  };\n}\n\nasync function fetchUrlStatus(url: string): Promise<ExternalLinkProbeResult> {\n  const controller = new AbortController();\n  const timeoutId = globalThis.setTimeout(() => {\n    controller.abort();\n  }, EXTERNAL_LINK_TIMEOUT_IN_MILLISECONDS);\n\n  try {\n    const response = await fetch(url, { signal: controller.signal });\n    // Cancel the unread body so undici releases the connection immediately.\n    // Without this the per-host connection pool stalls and same-host requests\n    // serialize, turning a ~3s run into minutes.\n    await response.body?.cancel();\n    return {\n      retryAfterInMilliseconds: parseRetryAfterInMilliseconds(response.headers.get('retry-after'), Date.now()),\n      status: response.status\n    };\n  } catch {\n    return { status: NETWORK_FAILURE_STATUS };\n  } finally {\n    globalThis.clearTimeout(timeoutId);\n  }\n}\n\nasync function getAllFiles(outputRootPath: string): Promise<Set<string>> {\n  const entries = await readdir(outputRootPath, { recursive: true, withFileTypes: true });\n  const files = new Set<string>();\n  for (const entry of entries) {\n    if (!entry.isFile()) {\n      continue;\n    }\n\n    const absolutePath = resolve(entry.parentPath, entry.name).replaceAll('\\\\', '/');\n    files.add(absolutePath.slice(`${outputRootPath}/`.length));\n  }\n\n  return files;\n}\n\nasync function readPages(outputRootPath: string, allFiles: Set<string>): Promise<DocumentationPage[]> {\n  const pages: DocumentationPage[] = [];\n  for (const relativePath of allFiles) {\n    if (!relativePath.endsWith(HTML_FILE_EXTENSION) || relativePath === FALLBACK_PAGE_RELATIVE_PATH) {\n      continue;\n    }\n\n    const html = await readFile(resolve(outputRootPath, relativePath), 'utf-8');\n    pages.push({ html, relativePath });\n  }\n\n  return pages;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/docs-site/docs-site-commands.d.mts

@@ -10,7 +10,8 @@
 import type { DocsSiteConfig } from './docs-site-config.mjs';
 /**
  * Builds the site: generates the API reference and the Open Graph cards, runs `astro build`, then checks every link
- * of the output.
+ * of the output. With {@link DocsSiteConfig.repoHomepage} on, it then checks the repository's GitHub homepage against
+ * the site's URL.
  *
  * @param config - The site's configuration.
  */
@@ -19,11 +20,15 @@ export declare function buildDocsSite(config: DocsSiteConfig): Promise<void>;
  * Generates the API reference, then serves the site with `astro dev` until it is stopped.
  *
  * @param config - The site's configuration.
+ * @param astroArguments - The arguments appended to `astro dev`, such as `--port 4399`. Defaults to the script's own
+ *   command-line arguments, so `npm run docs:dev -- --port 4399` reaches Astro.
  */
-export declare function devDocsSite(config: DocsSiteConfig): Promise<void>;
+export declare function devDocsSite(config: DocsSiteConfig, astroArguments?: readonly string[]): Promise<void>;
 /**
  * Serves the last build with `astro preview` until it is stopped.
  *
  * @param config - The site's configuration.
+ * @param astroArguments - The arguments appended to `astro preview`, such as `--port 4399`. Defaults to the script's
+ *   own command-line arguments, so `npm run docs:preview -- --port 4399` reaches Astro.
  */
-export declare function previewDocsSite(config: DocsSiteConfig): Promise<void>;
+export declare function previewDocsSite(config: DocsSiteConfig, astroArguments?: readonly string[]): Promise<void>;

package/dist/lib/esm/docs-site/docs-site-commands.mjs

@@ -4,12 +4,14 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 import { join } from "node:path";
+import process from "node:process";
 import { execFromRoot } from "../root.mjs";
 import { generateApiDocs } from "./api-docs.mjs";
 import { assertDocsLinksResolve } from "./docs-links.mjs";
 import { getDocsSiteAssetsDirectory } from "./docs-site-assets.mjs";
 import { resolveDocsSiteConfig } from "./docs-site-config.mjs";
 import { generateOgImages } from "./og-images.mjs";
+import { syncRepoHomepage } from "./repo-homepage.mjs";
 async function buildDocsSite(config) {
   const resolved = resolveDocsSiteConfig(config);
   await generateApiDocs({ rootDirectory: resolved.rootDirectory, settings: resolved.apiDocSettings, sourceDirectory: resolved.sourceDirectory });
@@ -22,11 +24,14 @@ async function buildDocsSite(config) {
   });
   await execFromRoot(["astro", "build"], { cwd: resolved.rootDirectory });
   await assertDocsLinksResolve({ outputDirectory: resolved.distDirectory, siteBaseUrl: resolved.siteBaseUrl });
+  if (resolved.repoHomepage !== "off") {
+    await syncRepoHomepage({ homepageUrl: resolved.siteBaseUrl, mode: resolved.repoHomepage, owner: resolved.owner, repo: resolved.repo });
+  }
 }
-async function devDocsSite(config) {
+async function devDocsSite(config, astroArguments = getScriptArguments()) {
   const resolved = resolveDocsSiteConfig(config);
   await generateApiDocs({ rootDirectory: resolved.rootDirectory, settings: resolved.apiDocSettings, sourceDirectory: resolved.sourceDirectory });
-  await execFromRoot(["astro", "dev"], {
+  await execFromRoot(["astro", "dev", ...astroArguments], {
     cwd: resolved.rootDirectory,
     env: {
       ASTRO_DEV_BACKGROUND: "1"
@@ -34,13 +39,17 @@ async function devDocsSite(config) {
     isInteractive: true
   });
 }
-async function previewDocsSite(config) {
+async function previewDocsSite(config, astroArguments = getScriptArguments()) {
   const resolved = resolveDocsSiteConfig(config);
-  await execFromRoot(["astro", "preview"], { cwd: resolved.rootDirectory, isInteractive: true });
+  await execFromRoot(["astro", "preview", ...astroArguments], { cwd: resolved.rootDirectory, isInteractive: true });
+}
+function getScriptArguments() {
+  const [, , ...scriptArguments] = process.argv;
+  return scriptArguments;
 }
 export {
   buildDocsSite,
   devDocsSite,
   previewDocsSite
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/docs-site/docs-site-config.d.mts

@@ -6,6 +6,7 @@
  * it documents, where its sources and pages live, and which other sites it links to.
  */
 import type { ApiDocSettings } from './api-doc-settings.mjs';
+import type { RepoHomepageMode } from './repo-homepage.mjs';
 /**
  * Describes a documentation site. Every path is relative to {@link DocsSiteConfig.rootDirectory}.
  */
@@ -44,6 +45,14 @@ export interface DocsSiteConfig {
      * The repository's name. The site is served under it: `<siteOrigin>/<repo>/`.
      */
     readonly repo: string;
+    /**
+     * What `buildDocsSite` does, after the build, about the repository's GitHub homepage: compare it with the site's
+     * URL and report a mismatch (`check`), or also set it (`set`). It reads and writes through the `gh` CLI, and
+     * only ever warns. A workflow's `GITHUB_TOKEN` can read the homepage but not set it, so in CI `set` reports too.
+     *
+     * @default 'off'
+     */
+    readonly repoHomepage?: RepoHomepageMode;
     /**
      * The repository root, holding `package.json`, `tsconfig.json` and `node_modules`.
      *
@@ -115,6 +124,10 @@ export interface ResolvedDocsSiteConfig {
      * The folder the Open Graph cards are written to, `<docs>/public/og`.
      */
     readonly ogOutputDirectory: string;
+    /**
+     * See {@link DocsSiteConfig.owner}.
+     */
+    readonly owner: string;
     /**
      * The documented package's name, read from the root `package.json`.
      */
@@ -131,6 +144,10 @@ export interface ResolvedDocsSiteConfig {
      * See {@link DocsSiteConfig.repo}.
      */
     readonly repo: string;
+    /**
+     * See {@link DocsSiteConfig.repoHomepage}.
+     */
+    readonly repoHomepage: RepoHomepageMode;
     /**
      * See {@link DocsSiteConfig.rootDirectory}.
      */