@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/cjs/library-build.d.cts

@@ -0,0 +1,101 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * The build pipeline of a TypeScript LIBRARY package: one `dist/lib/{cjs,esm}` tree of unbundled modules beside its
+ * `.d.cts` / `.d.mts` declarations, the generated `index.ts` barrels, and the generated `package.json` `exports` map.
+ *
+ * Each step works on the current working folder, which is the package being built. A repository's
+ * `scripts/build-*.ts` entry points are thin `wrapCliTask` wrappers around these functions, and its `build` script
+ * runs them in order through {@link runBuildSteps}.
+ */
+import type { Plugin } from 'esbuild' with { 'resolution-mode': 'import' };
+/**
+ * The banner every emitted library module opens with.
+ */
+export declare const LIBRARY_BANNER = "/*\nTHIS IS A GENERATED/BUNDLED FILE BY ESBUILD\nif you want to view the source, please visit the github repository of this plugin\n*/\n";
+/**
+ * The steps of a library build, in the order {@link runBuildSteps} runs them.
+ */
+export declare const LIBRARY_BUILD_STEPS: readonly string[];
+/**
+ * The export condition the `obsidian-dev-utils` workspace maps every subpath onto its TypeScript source with, so a
+ * package there can import a sibling package's source before anything is built. Pass it to
+ * {@link generateLibraryExports} through {@link GenerateLibraryExportsOptions.sourceCondition}.
+ */
+export declare const SOURCE_CONDITION = "@mnaoumov/source";
+/**
+ * Options for {@link buildLibrary}.
+ */
+export interface BuildLibraryOptions {
+    /**
+     * Creates the preprocess plugin for one output format. Defaults to the generic one, which carries no
+     * environment-specific `require` patch.
+     */
+    readonly preprocessPluginFactory?: (isEsm: boolean) => Plugin;
+}
+/**
+ * Options for {@link generateLibraryExports}.
+ */
+export interface GenerateLibraryExportsOptions {
+    /**
+     * An export condition to put first in every entry, mapping the subpath onto its TypeScript source. Only a
+     * repository holding several packages that import each other needs one; nothing outside it sets the condition, and
+     * the sources it points at do not ship, so the publish has to strip it again. Omitted, the map has none.
+     */
+    readonly sourceCondition?: string | undefined;
+}
+/**
+ * Removes everything an earlier build left: `dist/`, the generated `index.ts` barrels, the `.d.ts` files `tsc` wrote
+ * beside the sources (hand-authored ones under `@types` stay), and the per-subpath `package.json` stubs.
+ *
+ * @returns A {@link Promise} that resolves when everything has been removed.
+ */
+export declare function buildCleanLibrary(): Promise<void>;
+/**
+ * Builds every source module, unbundled, into `dist/lib/cjs` (`.cjs`) and `dist/lib/esm` (`.mjs`).
+ *
+ * The output folders must already exist; {@link buildLibraryTypes} creates them.
+ *
+ * @param options - The build options.
+ * @returns A {@link Promise} that resolves when both formats have been built.
+ */
+export declare function buildLibrary(options?: BuildLibraryOptions): Promise<void>;
+/**
+ * Emits the declarations with `tsc --project ./tsconfig.types.json`, then copies each one into `dist/lib` twice: as a
+ * `.d.cts` whose relative imports name `.cjs` files and whose bare type imports carry `resolution-mode: import`, and
+ * as a `.d.mts` whose relative imports name `.mjs` files.
+ *
+ * The library's root declaration (`library.ts` where the package has one, otherwise the generated `index.ts`) carries
+ * every `lib` and `types` reference the package needs, and so does a `library-references` declaration beside it that
+ * carries nothing else. Every other declaration references that one by path, never the root: the root barrel
+ * re-exports every module, so referencing it made each subpath load the whole package, and a consumer type-checking
+ * with `skipLibCheck: false` then needed every optional peer installed.
+ *
+ * @returns A {@link Promise} that resolves when the declarations have been written.
+ * @throws If a source module is named `library-references`, which would collide with the generated declaration.
+ */
+export declare function buildLibraryTypes(): Promise<void>;
+/**
+ * Regenerates the `exports` map of the package's `package.json` from its source folders, and writes a `package.json`
+ * stub per subpath for resolvers that do not read `exports`.
+ *
+ * @param options - The {@link GenerateLibraryExportsOptions}.
+ * @returns A {@link Promise} that resolves when the map is current.
+ * @throws If the map changed, so the change gets reviewed and committed rather than shipped unseen.
+ */
+export declare function generateLibraryExports(options?: GenerateLibraryExportsOptions): Promise<void>;
+/**
+ * Generates an `index.ts` barrel in every source folder that has something to export, re-exporting each module and
+ * each sub-barrel under its own name.
+ *
+ * @returns A {@link Promise} that resolves when the barrels have been written.
+ */
+export declare function generateLibraryIndex(): Promise<void>;
+/**
+ * Runs each named npm script the package defines, in order, skipping the ones it does not define.
+ *
+ * @param steps - The npm script names.
+ * @returns A {@link Promise} that resolves when every step has run.
+ */
+export declare function runBuildSteps(steps?: readonly string[]): Promise<void>;

package/dist/lib/cjs/library-references.d.cts

@@ -0,0 +1,5 @@
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+/// <reference lib="es2022" />
+/// <reference lib="esnext.disposable" />
+/// <reference types="node" />

package/dist/lib/cjs/linters/cspell-content.cjs

@@ -0,0 +1,124 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 cspell_content_exports = {};
+__export(cspell_content_exports, {
+  spellcheckContent: () => spellcheckContent
+});
+module.exports = __toCommonJS(cspell_content_exports);
+var import_debug = require('@mnaoumov/typescript-lib/debug');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_package_manager = require('../package-manager.cjs');
+var import_root = require('../root.cjs');
+const SUCCESS_EXIT_CODE = 0;
+async function spellcheckContent(params) {
+  const { content, filePath } = params;
+  const contentDebugger = (0, import_debug.getLibDebugger)("cspell:spellcheckContent");
+  const result = await (0, import_root.execFromRoot)([
+    ...(0, import_package_manager.resolveToolCommand)({ tool: "cspell" }),
+    "lint",
+    "--no-progress",
+    "--no-must-find-files",
+    // The `CSpell: Files checked: …` summary and the color codes are both noise in a finding that ends up
+    // quoted in an error message, and both are printed by default when they are not asked away.
+    "--no-summary",
+    "--no-color",
+    // A POSIX path, because this is parsed as a URL: a Windows path's backslashes do not survive that.
+    `stdin://${(0, import_path.toPosixPath)(filePath)}`
+  ], {
+    isQuiet: true,
+    shouldIgnoreExitCode: true,
+    shouldIncludeDetails: true,
+    stdin: content
+  });
+  contentDebugger(result.stderr);
+  if (result.exitCode === SUCCESS_EXIT_CODE) {
+    return [];
+  }
+  const findings = result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+  if (findings.length === 0) {
+    throw new Error(`\`cspell\` exited with ${String(result.exitCode)} without reporting anything:
+${result.stderr}`);
+  }
+  return findings;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  spellcheckContent
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/linters/cspell-content.d.cts

@@ -0,0 +1,46 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Spellchecks markdown that is still in memory, with the repository's own `spellcheck` configuration.
+ *
+ * The sibling of `markdownlint-content.ts`, for the other half of the same gap: `spellcheck` can only answer
+ * for what is already on disk, so a document composed during a run — the release's changelog being the one
+ * that costs a red `main` — is checked by nothing until the next gate. A coined word in a release note lands
+ * on the default branch inside the release commit, and the NEXT release aborts in its second preflight step,
+ * in a repository nobody was working on.
+ *
+ * It SHELLS OUT where the markdownlint half calls a library, and the difference has a reason rather than
+ * being an oversight. `cspell` does export a CLI-layer `lint(fileGlobs, options, reporter)` that would be the
+ * exact analogue of `markdownlint-cli2`'s `main`, but the only way to hand it content that is not on disk is
+ * a `stdin://` glob, and its reader is `streamConsumers.text(process.stdin)` — the HOST process's own stdin,
+ * which the release's interactive review also uses. Reaching for it in-process would mean monkey-patching
+ * `process.stdin` for the whole process, so the content goes to a child's stdin instead.
+ *
+ * The `stdin://<path>` form is what makes the check the repository's own rather than a generic one: the
+ * virtual document is attributed to a REAL path, so `cspell.json` beside it — its `words`, its dictionaries,
+ * its `ignorePaths` — resolves exactly as it would for the written file. A temp file outside the repository
+ * would lose all of that, which is why it is not used.
+ */
+/**
+ * Parameters for {@link spellcheckContent}.
+ */
+export interface SpellcheckContentParams {
+    /**
+     * The content to spellcheck.
+     */
+    readonly content: string;
+    /**
+     * The path the content is checked AS — normally the path it is about to be written to. It decides which
+     * `cspell` configuration applies, and it is what every reported finding is named after.
+     */
+    readonly filePath: string;
+}
+/**
+ * Spellchecks content that is not on disk, with the configuration `spellcheck` would have used for it.
+ *
+ * @param params - The {@link SpellcheckContentParams}.
+ * @returns A {@link Promise} that resolves to the findings, each one the line the `spellcheck` output would
+ * have carried — `<path>:<line>:<column> - Unknown word (<word>)` — or an empty array when there are none.
+ */
+export declare function spellcheckContent(params: SpellcheckContentParams): Promise<string[]>;

package/dist/lib/cjs/linters/cspell.cjs

@@ -0,0 +1,103 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 cspell_exports = {};
+__export(cspell_exports, {
+  spellcheck: () => spellcheck
+});
+module.exports = __toCommonJS(cspell_exports);
+var import_package_manager = require('../package-manager.cjs');
+var import_root = require('../root.cjs');
+async function spellcheck(options) {
+  const { paths } = options ?? {};
+  const targets = paths?.length ? paths : ["."];
+  const rootFolder = (0, import_root.getRootFolder)();
+  await (0, import_root.execFromRoot)([
+    ...(0, import_package_manager.resolveToolCommand)({ tool: "cspell" }),
+    "--no-progress",
+    "--no-must-find-files",
+    "--gitignore",
+    ...rootFolder === null ? [] : ["--gitignore-root", rootFolder],
+    { batchedArguments: targets }
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  spellcheck
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/linters/cspell.d.cts

@@ -0,0 +1,36 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * This module provides a function for running a spellcheck on the codebase using the `cspell` library.
+ * It reports any spelling issues found in the code and returns a {@link CliTaskResult} indicating whether the spellcheck was successful.
+ */
+/**
+ * Parameters for the {@link spellcheck} function.
+ */
+export interface SpellcheckOptions {
+    /**
+     * Optional file paths to check. If omitted, checks the entire project.
+     */
+    readonly paths?: string[] | undefined;
+}
+/**
+ * Runs a spellcheck on the entire codebase using `cspell`.
+ *
+ * Checks all files in the current folder and its subfolders for spelling issues.
+ * If issues are found, they are logged to the console with their file path, line, and column number.
+ *
+ * Uses `--no-must-find-files` so that cspell does not fail when all provided paths
+ * are excluded by built-in ignore rules (e.g., `package-lock.json`).
+ *
+ * Uses `--gitignore` so a path git ignores is a path cspell skips — generated output, build folders and
+ * every `node_modules` are covered without a hand-maintained `ignorePaths` list that drifts from
+ * `.gitignore`. It is passed on the command line rather than set in `cspell.json` so that every project
+ * consuming this function inherits it, rather than each having to edit its own config. `--gitignore-root`
+ * stops the search at the project root, so a `.gitignore` in some parent folder outside the project cannot
+ * silently remove files from the check.
+ *
+ * @param options - The {@link SpellcheckOptions}.
+ * @returns A {@link Promise} that resolves to a {@link CliTaskResult}, indicating the success or failure of the spellcheck.
+ */
+export declare function spellcheck(options?: SpellcheckOptions): Promise<void>;

package/dist/lib/cjs/linters/eslint-agnostic-core-boundary.cjs

@@ -0,0 +1,94 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 eslint_agnostic_core_boundary_exports = {};
+__export(eslint_agnostic_core_boundary_exports, {
+  getPackageBoundaryNoRestrictedImportPatterns: () => getPackageBoundaryNoRestrictedImportPatterns
+});
+module.exports = __toCommonJS(eslint_agnostic_core_boundary_exports);
+function getPackageBoundaryNoRestrictedImportPatterns(params) {
+  return params.forbiddenPackageNames.map((forbiddenPackageName) => ({
+    group: [forbiddenPackageName, `${forbiddenPackageName}/*`, `${forbiddenPackageName}/**`],
+    message: `\`${params.packageName}\` must not import \`${forbiddenPackageName}\`: the dependency arrows between the workspace packages point the other way.`
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPackageBoundaryNoRestrictedImportPatterns
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/linters/eslint-agnostic-core-boundary.d.cts

@@ -0,0 +1,49 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * `no-restricted-imports` pattern entries that enforce the dependency arrows between the packages of a workspace:
+ * which packages a package's code may import, by naming the ones it may not.
+ *
+ * Exported as standalone builders so the patterns can be unit-tested independently of the larger declarative
+ * config, and so the owning project can apply them scoped to each package's source files.
+ *
+ * Workspace `package.json` dependencies enforce the same boundary in the end, because an import of an undeclared
+ * package fails to resolve once the package is installed on its own. Inside the workspace every package is
+ * resolvable from every other, so without this rule a wrong arrow would surface only after publishing.
+ */
+/**
+ * Parameters for {@link getPackageBoundaryNoRestrictedImportPatterns}.
+ */
+export interface GetPackageBoundaryNoRestrictedImportPatternsParams {
+    /**
+     * The packages the package's code must not import, by package name.
+     */
+    readonly forbiddenPackageNames: readonly string[];
+    /**
+     * The name of the package the patterns apply to, named in the message.
+     */
+    readonly packageName: string;
+}
+/**
+ * A single `no-restricted-imports` pattern entry pairing a group of banned import specifiers with a
+ * human-readable message explaining why they are banned.
+ */
+export interface NoRestrictedImportPatternEntry {
+    /**
+     * The glob group of import specifiers to ban.
+     */
+    group: string[];
+    /**
+     * Human-readable message shown when an import matches the group.
+     */
+    message: string;
+}
+/**
+ * Builds the `no-restricted-imports` pattern entries banning a package's code from importing the given packages,
+ * through their root or any subpath.
+ *
+ * @param params - The {@link GetPackageBoundaryNoRestrictedImportPatternsParams}.
+ * @returns One pattern entry per forbidden package; none when nothing is forbidden.
+ */
+export declare function getPackageBoundaryNoRestrictedImportPatterns(params: GetPackageBoundaryNoRestrictedImportPatternsParams): NoRestrictedImportPatternEntry[];