@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/cjs/version.d.cts

@@ -0,0 +1,418 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * This module provides functions for managing version updates in a project.
+ * It includes tasks such as validating version update types, checking the state
+ * of Git and GitHub CLI, updating version numbers in files, and performing
+ * Git operations such as tagging and pushing.
+ */
+import { parseArgs } from 'node:util';
+/**
+ * Options for {@link addUpdatedFilesToGit}.
+ */
+export interface AddUpdatedFilesToGitOptions {
+    /**
+     * Whether to run the pre-commit hook when creating the release commit. When `false`, `--no-verify`
+     * is passed to the release commit to skip the hook.
+     *
+     * @default `true`
+     */
+    readonly shouldVerifyCommit?: boolean;
+}
+/**
+ * The result of parsing the command-line arguments for a version update.
+ */
+export interface ParsedVersionArguments {
+    /**
+     * The {@link UpdateVersionOptions} parsed from the flags.
+     */
+    readonly options: UpdateVersionOptions;
+    /**
+     * The positional version update type argument, or `undefined` if none was provided.
+     */
+    readonly versionUpdateType: string | undefined;
+}
+/**
+ * Options for {@link publishGitHubRelease}.
+ */
+export interface PublishGitHubReleaseOptions {
+    /**
+     * Returns the files to attach to the GitHub release, as paths relative to the project root. A path that does
+     * not exist is skipped.
+     *
+     * @default the `npm pack` tarball of the project, written into `dist/`, and `dist/styles.css`
+     */
+    readonly getReleaseAssetPaths?: (() => Promise<string[]>) | undefined;
+    /**
+     * Whether to close the issues the release carries once it is published: every issue a commit since the previous
+     * tag names with a closing keyword (`fixes #12`) is closed with a `Fixed in` / `Implemented in` comment linking
+     * the release. See {@link closeReleasedIssues}.
+     *
+     * @default `true`
+     */
+    readonly shouldCloseReleasedIssues?: boolean;
+}
+/**
+ * Options for {@link updateChangelog}.
+ */
+export interface UpdateChangelogOptions {
+    /**
+     * A path to a file whose contents become the body of the new version's changelog section, instead of
+     * the bullets derived from the commit messages. Use it to supply prepared release notes from a
+     * non-interactive caller (a background process, CI, an agent).
+     *
+     * Setting it implies no interactive review: the commit log is not read, and the changelog is never
+     * opened in the editor nor waited on at the console, regardless of {@link shouldEditChangelog}.
+     *
+     * @default the first-parent commit subjects since the previous version
+     */
+    readonly changelogFilePath?: string | undefined;
+    /**
+     * Whether to open the generated changelog in the editor for an interactive review. When `false`,
+     * the changelog is still generated from commit messages, but it is not opened in the editor for
+     * manual review.
+     *
+     * Ignored when {@link changelogFilePath} is set.
+     *
+     * @default `true`
+     */
+    readonly shouldEditChangelog?: boolean;
+}
+/**
+ * Options for {@link updateVersion}.
+ */
+export interface UpdateVersionOptions {
+    /**
+     * A path to a file whose contents become the body of the new version's changelog section, instead of
+     * the bullets derived from the commit messages. Use it to supply prepared release notes from a
+     * non-interactive caller (a background process, CI, an agent).
+     *
+     * Setting it implies no interactive review: the commit log is not read, and the changelog is never
+     * opened in the editor nor waited on at the console, regardless of {@link shouldEditChangelog}.
+     *
+     * @default the first-parent commit subjects since the previous version
+     */
+    readonly changelogFilePath?: string | undefined;
+    /**
+     * Returns the files to attach to the GitHub release. See {@link PublishGitHubReleaseOptions.getReleaseAssetPaths}.
+     */
+    readonly getReleaseAssetPaths?: (() => Promise<string[]>) | undefined;
+    /**
+     * A callback function to prepare the GitHub release.
+     *
+     * @param newVersion - The new version number for the release.
+     * @returns A {@link Promise} that resolves when the GitHub release has been prepared.
+     */
+    readonly prepareGitHubRelease?: (newVersion: string) => Promise<void>;
+    /**
+     * Whether to run the build step. The build is a publishing prerequisite, not a verification check,
+     * so it is governed by this flag independently of {@link shouldRunChecks} — it runs even when the
+     * checks are skipped, so a fast release still ships fresh artifacts. Set to `false` only when the
+     * build output is known to already match the current code; otherwise the release would publish
+     * stale artifacts.
+     *
+     * @default `true`
+     */
+    readonly shouldBuild?: boolean;
+    /**
+     * Whether to close the issues the release carries once it is published. See
+     * {@link PublishGitHubReleaseOptions.shouldCloseReleasedIssues}.
+     *
+     * @default `true`
+     */
+    readonly shouldCloseReleasedIssues?: boolean;
+    /**
+     * Whether to open the generated changelog in the editor for an interactive review.
+     *
+     * Ignored when {@link changelogFilePath} is set. When it is neither set nor disabled, the release
+     * requires an interactive terminal, and {@link updateVersion} refuses up front without one rather
+     * than blocking on an editor nobody will close.
+     *
+     * @default `true`
+     */
+    readonly shouldEditChangelog?: boolean;
+    /**
+     * Whether to publish the release. When `false`, all local steps are executed (version bump,
+     * changelog, commit, tag), but the changes are not pushed and no GitHub release is published.
+     *
+     * @default `true`
+     */
+    readonly shouldRelease?: boolean;
+    /**
+     * Whether to run the preflight verification checks (clean-repo check, format, spellcheck, lint,
+     * over-exposure analysis, and tests). The build step is not one of these checks — it is governed
+     * separately by {@link shouldBuild}.
+     *
+     * @default `true`
+     */
+    readonly shouldRunChecks?: boolean;
+    /**
+     * Whether to run the pre-commit hook when creating the release commit. When `false`, `--no-verify`
+     * is passed to the release commit to skip the hook.
+     *
+     * @default `true`
+     */
+    readonly shouldVerifyCommit?: boolean;
+    /**
+     * Updates the version in any file beyond `package.json` and the lockfiles, once the new version is known and
+     * before the release commit is made. An Obsidian plugin's `manifest.json` and `versions.json` are the case this
+     * exists for.
+     *
+     * @param newVersion - The version being released.
+     * @returns A {@link Promise} that resolves when the files are updated.
+     */
+    readonly updateVersionInExtraFiles?: ((newVersion: string) => Promise<void>) | undefined;
+}
+/**
+ * Enum representing different types of version updates.
+ *
+ * Aligns with npm's `npm version` increment types plus `Manual` for explicit versions.
+ */
+export declare enum VersionUpdateType {
+    Invalid = "invalid",
+    Major = "major",
+    Manual = "manual",
+    Minor = "minor",
+    Patch = "patch",
+    PreMajor = "premajor",
+    PreMinor = "preminor",
+    PrePatch = "prepatch",
+    PreRelease = "prerelease"
+}
+/**
+ * Creates a Git tag for the new version.
+ *
+ * @param newVersion - The new version number to use for the tag.
+ * @returns A {@link Promise} that resolves when the tag has been created.
+ */
+export declare function addGitTag(newVersion: string): Promise<void>;
+/**
+ * Adds updated files to the Git staging area and commits them with the new version message.
+ *
+ * If the commit fails (for example, the pre-commit hook rejects a new word in the changelog) and the
+ * process is attached to an interactive terminal, the user is prompted to fix the issue (for example,
+ * add the missing word to `cspell.json`) and press Enter to retry. The retry re-stages all files, so the
+ * fix is picked up without restarting the whole release lifecycle. In a non-interactive environment (no
+ * TTY, such as CI), the error is re-thrown instead of prompting, so the script fails fast rather than
+ * hanging. Pass `shouldVerifyCommit: false` to skip the pre-commit hook entirely in such cases.
+ *
+ * @param newVersion - The new version number used as the commit message.
+ * @param options - The {@link AddUpdatedFilesToGitOptions} controlling the commit behavior.
+ * @returns A {@link Promise} that resolves when the files have been added and committed.
+ */
+export declare function addUpdatedFilesToGit(newVersion: string, options?: AddUpdatedFilesToGitOptions): Promise<void>;
+/**
+ * Checks if the GitHub CLI is installed on the system.
+ *
+ * Throws an error if the GitHub CLI is not installed.
+ *
+ * @throws Error if the GitHub CLI is not installed.
+ */
+export declare function assertGitHubCliInstalled(): Promise<void>;
+/**
+ * Checks if Git is installed on the system.
+ *
+ * Throws an error if Git is not installed.
+ *
+ * @throws Error if Git is not installed.
+ */
+export declare function assertGitInstalled(): Promise<void>;
+/**
+ * Checks if the Git repository is clean, meaning there are no uncommitted changes.
+ *
+ * Throws an error if the Git repository is not clean.
+ *
+ * @throws Error if the Git repository is not clean.
+ */
+export declare function assertGitRepoClean(): Promise<void>;
+/**
+ * Wraps any bare `http(s)://` URL in the given text in angle brackets (`<url>`) so that text emitted
+ * into a Markdown document (such as a generated changelog bullet) passes markdownlint's
+ * `MD034/no-bare-urls` rule while still rendering as a clickable autolink on GitHub.
+ *
+ * URLs that are already wrapped in angle brackets (`<url>`) or that form the target of a Markdown
+ * link (`[text](url)`) are left untouched, so the function is safe to run repeatedly. Trailing
+ * sentence punctuation (`.`, `,`, `;`, `:`, `!`, `?`) is kept outside the angle brackets so it does
+ * not become part of the link.
+ *
+ * @param text - The text possibly containing bare URLs.
+ * @returns The text with every bare URL wrapped in angle brackets.
+ */
+export declare function autolinkBareUrls(text: string): string;
+/**
+ * Generates a new version string based on the current version and the specified update type.
+ *
+ * Uses the `semver` package to compute the next version, supporting all npm increment types:
+ * `major`, `minor`, `patch`, `premajor`, `preminor`, `prepatch`, and `prerelease`.
+ * Pre-release versions use the `beta` identifier by default (e.g., `1.2.4-beta.0`).
+ *
+ * @param versionUpdateType - The type of version update or an explicit version string.
+ * @returns A {@link Promise} that resolves to the new version string.
+ * @throws Error if the current version is invalid or the increment fails.
+ */
+export declare function getNewVersion(versionUpdateType: string): Promise<string>;
+/**
+ * Retrieves the release notes for a specific version from the changelog.
+ *
+ * @param newVersion - The new version number for which to get the release notes.
+ * @returns A {@link Promise} that resolves to the release notes for the specified version.
+ */
+export declare function getReleaseNotes(newVersion: string): Promise<string>;
+/**
+ * Determines the type of version update based on the input string.
+ *
+ * @param versionUpdateType - The input string representing the version update type.
+ * @returns The corresponding `VersionUpdateType`.
+ */
+export declare function getVersionUpdateType(versionUpdateType: string): VersionUpdateType;
+/**
+ * Pushes commits and tags to the remote Git repository.
+ *
+ * @returns A {@link Promise} that resolves when the push operation is complete.
+ */
+export declare function gitPush(): Promise<void>;
+/**
+ * The flags {@link parseVersionArguments} recognizes, in the shape Node's `parseArgs` takes. Exported so a wrapper
+ * that adds flags of its own can parse them all in one pass and still read these through
+ * {@link toUpdateVersionOptions}.
+ */
+export declare const VERSION_ARGUMENT_OPTIONS: {
+    readonly 'changelog-file': {
+        readonly type: "string";
+    };
+    readonly 'no-build': {
+        readonly type: "boolean";
+    };
+    readonly 'no-changelog-editing': {
+        readonly type: "boolean";
+    };
+    readonly 'no-checks': {
+        readonly type: "boolean";
+    };
+    readonly 'no-commit-verification': {
+        readonly type: "boolean";
+    };
+    readonly 'no-issue-closing': {
+        readonly type: "boolean";
+    };
+    readonly 'no-release': {
+        readonly type: "boolean";
+    };
+};
+/**
+ * The values `parseArgs` reports for {@link VERSION_ARGUMENT_OPTIONS}.
+ */
+export type VersionArgumentValues = ReturnType<typeof parseArgs<VersionArgumentParseConfig>>['values'];
+/**
+ * The `parseArgs` configuration {@link VersionArgumentValues} is derived from.
+ */
+interface VersionArgumentParseConfig {
+    /**
+     * The recognized flags.
+     */
+    readonly options: typeof VERSION_ARGUMENT_OPTIONS;
+}
+/**
+ * Whether a version is a pre-release, such as `1.2.4-beta.0`.
+ *
+ * @param version - The version.
+ * @returns Whether it carries a pre-release part.
+ */
+export declare function isPreRelease(version: string): boolean;
+/**
+ * Parses the command-line arguments for a version update into a version update type and
+ * {@link UpdateVersionOptions}.
+ *
+ * Each behavior is enabled by default; the corresponding `--no-*` flag turns it off. `--changelog-file` takes a
+ * value instead and has no default. Recognized flags:
+ * - `--changelog-file=<path>` — use this file's contents as the new version's changelog section instead of
+ *   the commit-derived bullets, and skip the interactive review entirely.
+ * - `--no-build` — skip the build step (only safe when the build output already matches the current code).
+ * - `--no-changelog-editing` — generate the changelog without opening it for manual review.
+ * - `--no-checks` — skip the clean-repo check, format, spellcheck, lint, over-exposure analysis, and tests (the build still runs).
+ * - `--no-commit-verification` — pass `--no-verify` to the release commit, skipping the pre-commit hook.
+ * - `--no-issue-closing` — do not close the issues the release carries once it is published.
+ * - `--no-release` — run all local steps but skip the push and the GitHub release.
+ *
+ * @param $arguments - The command-line arguments to parse (typically `process.argv.slice(2)`).
+ * @returns The {@link ParsedVersionArguments} containing the version update type and the options.
+ */
+export declare function parseVersionArguments($arguments: string[]): ParsedVersionArguments;
+/**
+ * Publishes a GitHub release for the new version.
+ *
+ * Creates the release and attaches the files {@link PublishGitHubReleaseOptions.getReleaseAssetPaths} names.
+ *
+ * Once the release exists, the issues it carries are closed with a link to it (see {@link closeReleasedIssues}),
+ * unless {@link PublishGitHubReleaseOptions.shouldCloseReleasedIssues} is `false`. A failure there is reported and
+ * does not fail the release, which is already published.
+ *
+ * @param newVersion - The new version number for the release.
+ * @param options - The {@link PublishGitHubReleaseOptions}.
+ * @returns A {@link Promise} that resolves when the release has been published.
+ */
+export declare function publishGitHubRelease(newVersion: string, options?: PublishGitHubReleaseOptions): Promise<void>;
+/**
+ * Maps the values `parseArgs` reports for {@link VERSION_ARGUMENT_OPTIONS} onto {@link UpdateVersionOptions}.
+ *
+ * @param values - The parsed values.
+ * @returns The options.
+ */
+export declare function toUpdateVersionOptions(values: VersionArgumentValues): UpdateVersionOptions;
+/**
+ * Updates the changelog file with new version information and commit messages.
+ *
+ * This function reads the current changelog, appends new entries for the latest version,
+ * and prompts the user to review the changes.
+ *
+ * The review happens on a scratch copy in the OS temporary folder, and the repository's own
+ * `CHANGELOG.md` is written only once the review is over — so interrupting the review leaves the
+ * repository untouched.
+ *
+ * @param newVersion - The new version number to be added to the changelog.
+ * @param options - The {@link UpdateChangelogOptions} controlling the changelog review behavior.
+ * @returns A {@link Promise} that resolves when the changelog update is complete.
+ */
+export declare function updateChangelog(newVersion: string, options?: UpdateChangelogOptions): Promise<void>;
+/**
+ * Updates the version of the project based on the specified update type.
+ *
+ * This function performs a series of tasks to handle version updates:
+ * 1. Validates the version update type.
+ * 2. Checks if Git and GitHub CLI are installed.
+ * 3. Verifies that the interactive changelog review, if one is due, can actually be answered.
+ * 4. Verifies that the bump is not lower than the commits since the last tag force it to be.
+ * 5. Verifies that the Git repository is clean.
+ * 6. Runs spellcheck and linting.
+ * 7. Builds the project.
+ * 8. Settles the changelog — the only step that can block on a human, and deliberately the last one before
+ *    anything is written, so an interrupt here leaves the working tree clean and the release re-runnable.
+ *    The settled text is linted here too: `lint:md` ran in step 6, before a character of it existed.
+ * 9. Updates version in files (and in whatever {@link UpdateVersionOptions.updateVersionInExtraFiles} adds), then
+ *    writes the settled changelog.
+ * 10. Adds updated files to Git, tags the commit, and pushes to the repository.
+ * 11. Prepares and publishes a GitHub release.
+ * 12. Closes the issues the release carries, with a link to it.
+ *
+ * @param versionUpdateType - The type of version update to perform (major, minor, patch, premajor, preminor, prepatch, prerelease, or x.y.z[-suffix]).
+ * @param options - The {@link UpdateVersionOptions} controlling the release behavior.
+ * @returns A {@link Promise} that resolves when the version update is complete.
+ */
+export declare function updateVersion(versionUpdateType?: string, options?: UpdateVersionOptions): Promise<void>;
+/**
+ * Updates the version in `package.json` and, where they exist, `package-lock.json` and `npm-shrinkwrap.json`.
+ *
+ * @param newVersion - The new version string to update in the files.
+ * @returns A {@link Promise} that resolves when the update is complete.
+ */
+export declare function updateVersionInFiles(newVersion: string): Promise<void>;
+/**
+ * Validates the version update type to ensure it is either a recognized type
+ * or a valid manual version string.
+ *
+ * @param versionUpdateType - The version update type to validate.
+ * @throws Error if the version update type is invalid.
+ */
+export declare function validate(versionUpdateType: string): void;
+export {};

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

@@ -0,0 +1,59 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * This module provides utility functions to handle the build process for static assets and cleaning
+ * the build output folder. It includes functions to copy static files to the distribution folder
+ * and to remove the existing build output.
+ */
+/**
+ * Removes the distribution folder and its contents.
+ *
+ * This function deletes the entire distribution folder to ensure a clean build environment.
+ *
+ * @returns A {@link Promise} that resolves when the folder has been removed.
+ */
+export declare function buildClean(): Promise<void>;
+/**
+ * Compiles the code.
+ *
+ * @returns A {@link Promise} that resolves when the code compiles successfully.
+ */
+export declare function buildCompile(): Promise<void>;
+/**
+ * Compiles the Svelte code.
+ *
+ * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig
+ * `include` patterns and filtering that list would never match: `include` lists TypeScript globs
+ * (`./src/**\/*.ts`, …), so no `.svelte` path can ever appear in it and the check would always be skipped.
+ *
+ * @returns A {@link Promise} that resolves when the code compiles successfully.
+ * @throws If the project has Svelte files but does not declare `svelte-check`.
+ */
+export declare function buildCompileSvelte(): Promise<void>;
+/**
+ * Compiles the TypeScript code.
+ *
+ * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does
+ * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}
+ * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the
+ * files we own, so the declarations we author are still fully validated.
+ *
+ * @returns A {@link Promise} that resolves when the code compiles successfully.
+ * @throws If the project's own declarations fail validation.
+ */
+export declare function buildCompileTypeScript(): Promise<void>;
+/**
+ * Copies all template files from the templates folder to the `templates` folder within the
+ * distribution folder.
+ *
+ * This function recursively reads the contents of the templates folder and copies each file to the
+ * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the
+ * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source
+ * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as
+ * `eslint.config.mts`), so an active config template can live in the repo under a name that the
+ * corresponding tool does not auto-discover.
+ *
+ * @returns A {@link Promise} that resolves when all files have been copied.
+ */
+export declare function buildTemplates(): Promise<void>;

package/dist/lib/esm/build.mjs

@@ -0,0 +1,165 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toArray } from "@mnaoumov/typescript-lib/async";
+import { getLibDebugger } from "@mnaoumov/typescript-lib/debug";
+import { join } from "@mnaoumov/typescript-lib/path";
+import { trimStart } from "@mnaoumov/typescript-lib/string";
+import {
+  cp,
+  glob,
+  rm
+} from "node:fs/promises";
+import {
+  checkProjectTypes,
+  parseTsConfig,
+  toCanonical
+} from "./check-project-types.mjs";
+import { readdirPosix } from "./fs.mjs";
+import { readJson } from "./json.mjs";
+import {
+  npmRunOptional,
+  NpmRunOptionalResult
+} from "./npm-run.mjs";
+import { readPackageJson } from "./npm.mjs";
+import { resolveToolCommand } from "./package-manager.mjs";
+import { RepoPaths } from "./repo-paths.mjs";
+import {
+  execFromRoot,
+  getRootFolder,
+  resolvePathFromRootSafe
+} from "./root.mjs";
+async function buildClean() {
+  await rm(RepoPaths.Dist, { force: true, recursive: true });
+}
+async function buildCompile() {
+  if (await npmRunOptional("build:compile:svelte") === NpmRunOptionalResult.Skipped) {
+    await buildCompileSvelte();
+  }
+  if (await npmRunOptional("build:compile:typescript") === NpmRunOptionalResult.Skipped) {
+    await buildCompileTypeScript();
+  }
+}
+async function buildCompileSvelte() {
+  const tsConfigPath = resolvePathFromRootSafe({ path: RepoPaths.TsConfigJson });
+  const tsConfig = await readJson(tsConfigPath);
+  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {
+    cwd: resolvePathFromRootSafe({ path: RepoPaths.CurrentFolder }),
+    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]
+  }));
+  const [firstSvelteFile] = svelteFiles;
+  if (firstSvelteFile === void 0) {
+    getLibDebugger("build:buildCompileSvelte")("No Svelte files found in the project, skipping Svelte compilation");
+    return;
+  }
+  const packageJson = await readPackageJson();
+  if (!checkSvelteCheckDeclared(packageJson)) {
+    throw new Error(
+      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \`${SVELTE_CHECK_PACKAGE_NAME}\` is not declared in package.json. Add \`${SVELTE_CHECK_PACKAGE_NAME}\` as a devDependency to type-check the Svelte code.`
+    );
+  }
+  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), "--tsconfig", RepoPaths.TsConfigJson]);
+}
+async function buildCompileTypeScript() {
+  await execFromRoot([...resolveToolCommand({ tool: "tsc" }), "--build", "--force"]);
+  if (!areProjectTypesValid()) {
+    throw new Error("TypeScript declaration validation failed.");
+  }
+}
+async function buildTemplates() {
+  for (const dirent of await readdirPosix(RepoPaths.Templates, { recursive: true, withFileTypes: true })) {
+    if (!dirent.isFile()) {
+      continue;
+    }
+    const path = trimStart({
+      $string: join(dirent.parentPath, dirent.name),
+      prefix: `${RepoPaths.Templates}/`
+    });
+    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;
+    await cp(join(RepoPaths.Templates, path), join(RepoPaths.DistTemplates, destinationPath));
+  }
+}
+const TEMPLATE_FILE_SUFFIX = ".template";
+const NODE_MODULES_SEGMENT = "/node_modules/";
+const SVELTE_CHECK_PACKAGE_NAME = "svelte-check";
+const SVELTE_FILE_PATTERNS = [
+  `${RepoPaths.AnyPath}/*.svelte`,
+  `${RepoPaths.AnyPath}/*.svelte.js`,
+  `${RepoPaths.AnyPath}/*.svelte.ts`
+];
+const SVELTE_FILE_EXCLUDE_PATTERNS = [
+  `${RepoPaths.AnyPath}/${RepoPaths.NodeModules}/${RepoPaths.AnyPath}`,
+  `${RepoPaths.AnyPath}/${RepoPaths.Dist}/${RepoPaths.AnyPath}`
+];
+function areProjectTypesValid() {
+  const root = getRootFolder();
+  if (!root) {
+    throw new Error("Could not find root folder");
+  }
+  const rootCanonical = toCanonical(root);
+  const { fileNames, options } = parseTsConfig(join(root, RepoPaths.TsConfigJson));
+  return checkProjectTypes({
+    options,
+    rootNames: fileNames,
+    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })
+  });
+}
+function checkSvelteCheckDeclared(packageJson) {
+  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies].some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== void 0);
+}
+function shouldKeepProjectFile(params) {
+  const { fileName, rootCanonical } = params;
+  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);
+}
+export {
+  buildClean,
+  buildCompile,
+  buildCompileSvelte,
+  buildCompileTypeScript,
+  buildTemplates
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/build.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions to handle the build process for static assets and cleaning\n * the build output folder. It includes functions to copy static files to the distribution folder\n * and to remove the existing build output.\n */\n\nimport type {\n  PackageJson,\n  TsConfigJson\n} from 'type-fest';\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { trimStart } from '@mnaoumov/typescript-lib/string';\nimport {\n  cp,\n  glob,\n  rm\n} from 'node:fs/promises';\n\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { readdirPosix } from './fs.ts';\nimport { readJson } from './json.ts';\nimport {\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { readPackageJson } from './npm.ts';\nimport { resolveToolCommand } from './package-manager.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Removes the distribution folder and its contents.\n *\n * This function deletes the entire distribution folder to ensure a clean build environment.\n *\n * @returns A {@link Promise} that resolves when the folder has been removed.\n */\nexport async function buildClean(): Promise<void> {\n  await rm(RepoPaths.Dist, { force: true, recursive: true });\n}\n\n/**\n * Compiles the code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompile(): Promise<void> {\n  if (await npmRunOptional('build:compile:svelte') === NpmRunOptionalResult.Skipped) {\n    await buildCompileSvelte();\n  }\n  if (await npmRunOptional('build:compile:typescript') === NpmRunOptionalResult.Skipped) {\n    await buildCompileTypeScript();\n  }\n}\n\n/**\n * Compiles the Svelte code.\n *\n * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig\n * `include` patterns and filtering that list would never match: `include` lists TypeScript globs\n * (`./src/**\\/*.ts`, \u2026), so no `.svelte` path can ever appear in it and the check would always be skipped.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project has Svelte files but does not declare `svelte-check`.\n */\nexport async function buildCompileSvelte(): Promise<void> {\n  const tsConfigPath = resolvePathFromRootSafe({ path: RepoPaths.TsConfigJson });\n  const tsConfig = await readJson<TsConfigJson>(tsConfigPath);\n  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {\n    cwd: resolvePathFromRootSafe({ path: RepoPaths.CurrentFolder }),\n    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]\n  }));\n\n  const [firstSvelteFile] = svelteFiles;\n\n  if (firstSvelteFile === undefined) {\n    getLibDebugger('build:buildCompileSvelte')('No Svelte files found in the project, skipping Svelte compilation');\n    return;\n  }\n\n  const packageJson = await readPackageJson();\n\n  if (!checkSvelteCheckDeclared(packageJson)) {\n    throw new Error(\n      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \\`${SVELTE_CHECK_PACKAGE_NAME}\\` is not declared in package.json.`\n        + ` Add \\`${SVELTE_CHECK_PACKAGE_NAME}\\` as a devDependency to type-check the Svelte code.`\n    );\n  }\n\n  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), '--tsconfig', RepoPaths.TsConfigJson]);\n}\n\n/**\n * Compiles the TypeScript code.\n *\n * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does\n * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}\n * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the\n * files we own, so the declarations we author are still fully validated.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project's own declarations fail validation.\n */\nexport async function buildCompileTypeScript(): Promise<void> {\n  await execFromRoot([...resolveToolCommand({ tool: 'tsc' }), '--build', '--force']);\n\n  if (!areProjectTypesValid()) {\n    throw new Error('TypeScript declaration validation failed.');\n  }\n}\n\n/**\n * Copies all template files from the templates folder to the `templates` folder within the\n * distribution folder.\n *\n * This function recursively reads the contents of the templates folder and copies each file to the\n * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the\n * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source\n * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as\n * `eslint.config.mts`), so an active config template can live in the repo under a name that the\n * corresponding tool does not auto-discover.\n *\n * @returns A {@link Promise} that resolves when all files have been copied.\n */\nexport async function buildTemplates(): Promise<void> {\n  for (const dirent of await readdirPosix(RepoPaths.Templates, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = trimStart({\n      $string: join(dirent.parentPath, dirent.name),\n      prefix: `${RepoPaths.Templates}/`\n    });\n    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;\n    await cp(join(RepoPaths.Templates, path), join(RepoPaths.DistTemplates, destinationPath));\n  }\n}\n\nconst TEMPLATE_FILE_SUFFIX = '.template';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\n\nconst SVELTE_CHECK_PACKAGE_NAME = 'svelte-check';\n\nconst SVELTE_FILE_PATTERNS = [\n  `${RepoPaths.AnyPath}/*.svelte`,\n  `${RepoPaths.AnyPath}/*.svelte.js`,\n  `${RepoPaths.AnyPath}/*.svelte.ts`\n];\n\n/**\n * `node_modules` must be listed explicitly: a tsconfig that sets `exclude` at all **replaces** TypeScript's\n * default `node_modules` exclusion, so it cannot be relied on to keep dependencies out of the glob.\n */\nconst SVELTE_FILE_EXCLUDE_PATTERNS = [\n  `${RepoPaths.AnyPath}/${RepoPaths.NodeModules}/${RepoPaths.AnyPath}`,\n  `${RepoPaths.AnyPath}/${RepoPaths.Dist}/${RepoPaths.AnyPath}`\n];\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Re-runs the project type-check in-memory with `skipLibCheck: false`, reporting only diagnostics\n * whose source file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @returns `true` when the project's own files have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nfunction areProjectTypesValid(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n  const { fileNames, options } = parseTsConfig(join(root, RepoPaths.TsConfigJson));\n\n  return checkProjectTypes({\n    options,\n    rootNames: fileNames,\n    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n  });\n}\n\n/**\n * Determines whether the project declares `svelte-check`.\n *\n * The declaration is read from `package.json` rather than probed in `node_modules/.bin`, because\n * {@link resolveToolCommand} deliberately falls back to the package manager's exec form for tools that have\n * no bin shim \u2014 the only way a locally installed tool resolves under yarn PnP. Treating a missing shim as a\n * missing tool would therefore break PnP projects.\n *\n * @param packageJson - The project's parsed `package.json`.\n * @returns `true` when `svelte-check` is declared as a regular, dev, or peer dependency.\n */\nfunction checkSvelteCheckDeclared(packageJson: PackageJson): boolean {\n  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies]\n    .some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== undefined);\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],
  "mappings": "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",
  "names": []
}
