@williamthorsen/release-kit 14.2.2 → 14.2.3

package/dist/esm/loadConfig.js

@@ -10,10 +10,6 @@ import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
-import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_PROJECT_TAG_PREFIX, DEFAULT_RELEASE_NOTES_CONFIG, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES, } from "./defaults.js";
-import { deriveDirectoryConfig } from "./deriveDirectoryConfig.js";
-import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
-import { getTargetName, normalizeWorkspacePath, resolveReleaseDeclaration, } from "./resolveReleaseDeclaration.js";
 import { isRecord } from "./typeGuards.js";
 export const ROOT_PACKAGE_JSON_PATH = 'package.json';
 export function readRootPackageVersion() {
@@ -56,239 +52,3 @@ export async function loadConfig(configPath) {
     }
     return resolved;
 }
-export function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
-    const discovered = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
-    assertUniqueTagPrefixes(discovered);
-    const { retained: workspaces, excluded, directories: declaredDirectories, composite, } = resolveReleaseDeclaration(discovered, userConfig);
-    const directories = declaredDirectories.map((declared) => deriveDirectoryConfig(declared));
-    for (const workspace of workspaces) {
-        if (workspace.legacyIdentities !== undefined) {
-            assertLegacyIdentityDoesNotMatchCurrent(workspace.dir, workspace.name, workspace.tagPrefix, workspace.legacyIdentities);
-        }
-    }
-    if (userConfig?.retiredPackages !== undefined) {
-        assertRetiredPackagesDoNotCollideWithActive(workspaces, userConfig.retiredPackages);
-    }
-    const project = resolveProjectConfig(composite, rootPackage, workspaces);
-    const workTypes = resolveWorkTypes(userConfig?.workTypes);
-    const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
-    const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
-    const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
-    assertNoSharedVersionFiles(workspaces, directories, project);
-    assertNoTagPrefixCollisions(workspaces, directories, userConfig?.retiredPackages, project);
-    const result = {
-        workspaces,
-        workTypes,
-        versionPatterns,
-        changelogJson,
-        releaseNotes,
-    };
-    if (excluded.length > 0) {
-        result.excludedWorkspaces = excluded;
-    }
-    if (directories.length > 0) {
-        result.directories = directories;
-    }
-    if (project !== undefined) {
-        result.project = project;
-    }
-    applyOptionalPassthroughFields(result, userConfig);
-    return result;
-}
-function applyOptionalPassthroughFields(result, userConfig) {
-    if (userConfig?.changelogMarkdown !== undefined) {
-        result.changelogMarkdown = userConfig.changelogMarkdown;
-    }
-    if (userConfig?.formatCommand !== undefined) {
-        result.formatCommand = userConfig.formatCommand;
-    }
-    if (userConfig?.scopeAliases !== undefined) {
-        result.scopeAliases = userConfig.scopeAliases;
-    }
-    if (userConfig?.breakingPolicies !== undefined) {
-        result.breakingPolicies = userConfig.breakingPolicies;
-    }
-}
-export function mergeSinglePackageConfig(userConfig) {
-    if (userConfig?.project !== undefined) {
-        throw new Error('project block is not supported in single-package mode');
-    }
-    if (userConfig?.releases !== undefined) {
-        throw new Error('releases block is not supported in single-package mode');
-    }
-    const workTypes = resolveWorkTypes(userConfig?.workTypes);
-    const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
-    const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
-    const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
-    const result = {
-        workTypes,
-        versionPatterns,
-        changelogJson,
-        releaseNotes,
-    };
-    applyOptionalPassthroughFields(result, userConfig);
-    return result;
-}
-export function resolveWorkTypes(userWorkTypes) {
-    return userWorkTypes === undefined ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userWorkTypes };
-}
-function mergeChangelogJsonConfig(partial) {
-    if (partial === undefined) {
-        return { ...DEFAULT_CHANGELOG_JSON_CONFIG };
-    }
-    return {
-        enabled: partial.enabled ?? DEFAULT_CHANGELOG_JSON_CONFIG.enabled,
-        outputPath: partial.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
-        devOnlySections: partial.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections],
-    };
-}
-function assertLegacyIdentityDoesNotMatchCurrent(dir, currentName, currentTagPrefix, legacyIdentities) {
-    for (const identity of legacyIdentities) {
-        if (identity.name === currentName && identity.tagPrefix === currentTagPrefix) {
-            throw new Error(`Workspace '${dir}': legacyIdentities must not match the current identity ` +
-                `(name='${currentName}', tagPrefix='${currentTagPrefix}'). ` +
-                'The current identity is always searched; listing it again is a no-op.');
-        }
-    }
-}
-function assertRetiredPackagesDoNotCollideWithActive(workspaces, retiredPackages) {
-    const workspaceByDerivedPrefix = new Map();
-    for (const workspace of workspaces) {
-        workspaceByDerivedPrefix.set(workspace.tagPrefix, workspace);
-    }
-    for (const retired of retiredPackages) {
-        const active = workspaceByDerivedPrefix.get(retired.tagPrefix);
-        if (active !== undefined) {
-            throw new Error(`retiredPackages: tagPrefix '${retired.tagPrefix}' collides with active workspace '${active.dir}' ` +
-                `(derived prefix '${active.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`);
-        }
-    }
-}
-function resolveProjectConfig(composite, rootPackage, workspaces) {
-    if (composite === undefined) {
-        return undefined;
-    }
-    const subject = composite.name === undefined ? 'project block' : `composite release '${composite.name}'`;
-    if (rootPackage === undefined || !rootPackage.exists) {
-        throw new Error(`${subject} requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`);
-    }
-    if (rootPackage.version === undefined) {
-        throw new Error(`${subject} requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to the root package.json`);
-    }
-    return {
-        paths: composite.paths ?? workspaces.flatMap((workspace) => workspace.paths),
-        tagPrefix: composite.tagPrefix ?? DEFAULT_PROJECT_TAG_PREFIX,
-        ...(composite.name !== undefined && { name: composite.name }),
-        ...(composite.members !== undefined && { members: composite.members }),
-    };
-}
-function assertNoSharedVersionFiles(workspaces, directories, project) {
-    const owners = [
-        ...directories.map((directory) => ({
-            label: `directory release '${directory.name}'`,
-            versionFiles: [directory.versionFile],
-        })),
-        ...workspaces.map((workspace) => ({
-            label: `workspace '${getTargetName(workspace)}'`,
-            versionFiles: workspace.packageFiles.map(normalizeWorkspacePath),
-        })),
-        ...(project === undefined
-            ? []
-            : [
-                {
-                    label: project.name === undefined ? 'the project release' : `composite release '${project.name}'`,
-                    versionFiles: [ROOT_PACKAGE_JSON_PATH],
-                },
-            ]),
-    ];
-    for (const [index, directory] of directories.entries()) {
-        const peer = owners.slice(index + 1).find((owner) => owner.versionFiles.includes(directory.versionFile));
-        if (peer !== undefined) {
-            throw new Error(`directory release '${directory.name}' and ${peer.label} share the version file '${directory.versionFile}', ` +
-                "so each release would overwrite the other's version and changelog; declare only one of them");
-        }
-    }
-}
-function assertNoTagPrefixCollisions(workspaces, directories, retiredPackages, project) {
-    const sources = [];
-    for (const workspace of workspaces) {
-        const owner = `ws:${workspace.dir}`;
-        sources.push({ prefix: workspace.tagPrefix, label: `workspace '${workspace.dir}'`, owner });
-        const legacyIdentities = workspace.legacyIdentities ?? [];
-        for (const identity of legacyIdentities) {
-            sources.push({
-                prefix: identity.tagPrefix,
-                label: `workspace '${workspace.dir}' legacyIdentities entry (name='${identity.name}')`,
-                owner,
-            });
-        }
-    }
-    for (const directory of directories) {
-        const owner = `dir:${directory.path}`;
-        sources.push({ prefix: directory.tagPrefix, label: `directory release '${directory.name}'`, owner });
-        const legacyIdentities = directory.legacyIdentities ?? [];
-        for (const identity of legacyIdentities) {
-            sources.push({
-                prefix: identity.tagPrefix,
-                label: `directory release '${directory.name}' legacyIdentities entry (name='${identity.name}')`,
-                owner,
-            });
-        }
-    }
-    const retiredEntries = (retiredPackages ?? []).entries();
-    for (const [index, retired] of retiredEntries) {
-        sources.push({
-            prefix: retired.tagPrefix,
-            label: `retiredPackages entry (name='${retired.name}')`,
-            owner: `retired:${index}`,
-        });
-    }
-    if (project !== undefined) {
-        sources.push({
-            prefix: project.tagPrefix,
-            label: project.name === undefined ? 'project' : `composite release '${project.name}'`,
-            owner: 'project',
-        });
-    }
-    for (let i = 0; i < sources.length; i++) {
-        for (let j = i + 1; j < sources.length; j++) {
-            const a = sources[i];
-            const b = sources[j];
-            if (a === undefined || b === undefined || a.owner === b.owner)
-                continue;
-            if (isPrefixCollision(a.prefix, b.prefix)) {
-                throw new Error(`Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). ` +
-                    'One prefix is identical to or a strict prefix of the other; ' +
-                    'a tag under the longer prefix can then match the shorter one and be counted among its releases.');
-            }
-        }
-    }
-}
-function isPrefixCollision(a, b) {
-    return a === b || a.startsWith(b) || b.startsWith(a);
-}
-function assertUniqueTagPrefixes(workspaces) {
-    const pathsByPrefix = new Map();
-    for (const workspace of workspaces) {
-        const existing = pathsByPrefix.get(workspace.tagPrefix);
-        if (existing === undefined) {
-            pathsByPrefix.set(workspace.tagPrefix, [workspace.workspacePath]);
-        }
-        else {
-            existing.push(workspace.workspacePath);
-        }
-    }
-    for (const [prefix, paths] of pathsByPrefix) {
-        if (paths.length > 1) {
-            throw new Error(`Duplicate tag prefix '${prefix}' for workspaces: ${paths.join(', ')}`);
-        }
-    }
-}
-function mergeReleaseNotesConfig(partial) {
-    if (partial === undefined) {
-        return { ...DEFAULT_RELEASE_NOTES_CONFIG };
-    }
-    return {
-        shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
-    };
-}

package/dist/esm/loadValidatedConfig.d.ts

@@ -1,5 +1,5 @@
 import { type OutputStyle } from '@williamthorsen/nmr-core';
-import type { ReleaseKitConfig } from './types.js';
+import type { ReleaseKitConfig } from './configSchema.js';
 /**
  * Why a config file could not be used: The import threw, or the contents failed the schema.
  *

package/dist/esm/mergeConfig.d.ts

@@ -0,0 +1,41 @@
+import type { ReleaseKitConfig } from './configSchema.js';
+import type { MonorepoReleaseConfig, ReleaseSettings, WorkTypeConfig } from './types.js';
+/**
+ * Resolves a final monorepo config from discovered workspaces and an optional user config overlay.
+ *
+ * Merging rules:
+ * - Release targets: `resolveReleaseDeclaration` projects the `releases` block, or the `workspaces` overrides and the
+ *   `project` block, onto the discovered workspaces. Excluded workspaces move to `excludedWorkspaces`, and the
+ *   directories that `releases` declares resolve through `deriveDirectoryConfig` into `directories`, which must not
+ *   share a version file with any other target.
+ * - `workTypes`: Shallow merge; consumer entries override or add to defaults by key.
+ * - `versionPatterns`: Consumer value replaces defaults entirely.
+ * - Pass-through fields (see `applyOptionalPassthroughFields`): Consumer value wins.
+ * - `project`: Present iff the config declares a composite. Resolves `tagPrefix` to `DEFAULT_PROJECT_TAG_PREFIX` and
+ *   `paths` to the union of its members' `paths` when omitted. Requires `rootPackage` to be passed and to contain a
+ *   valid `version` field; throws otherwise. The resolved prefix is included in the strict-prefix collision check
+ *   across all workspace and retired-package prefixes.
+ */
+export declare function mergeMonorepoConfig(discoveredPaths: string[], userConfig: ReleaseKitConfig | undefined, rootPackage?: RootPackageInfo): MonorepoReleaseConfig;
+/**
+ * Resolves the release settings of a single-package repo from an optional user config overlay.
+ *
+ * Rejects a configured `project` or `releases` block: Both declare the targets of a monorepo, and a single-package
+ * repo has one target, its root package.
+ */
+export declare function mergeSinglePackageConfig(userConfig: ReleaseKitConfig | undefined): ReleaseSettings;
+/**
+ * Merges consumer work-type overrides onto `DEFAULT_WORK_TYPES`.
+ *
+ * Preserves the declaration order of defaults; net-new consumer keys append at the end.
+ */
+export declare function resolveWorkTypes(userWorkTypes?: ReleaseKitConfig['workTypes']): Record<string, WorkTypeConfig>;
+/**
+ * Information about the root `package.json` passed into `mergeMonorepoConfig` when a
+ * `project` block is configured. `readRootPackageVersion` performs the read, so that
+ * `mergeMonorepoConfig` does not perform any I/O.
+ */
+export interface RootPackageInfo {
+    exists: boolean;
+    version: string | undefined;
+}

package/dist/esm/mergeConfig.js

@@ -0,0 +1,118 @@
+import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_PROJECT_TAG_PREFIX, DEFAULT_RELEASE_NOTES_CONFIG, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES, } from "./defaults.js";
+import { deriveDirectoryConfig } from "./deriveDirectoryConfig.js";
+import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
+import { ROOT_PACKAGE_JSON_PATH } from "./loadConfig.js";
+import { assertLegacyIdentityDoesNotMatchCurrent, assertNoSharedVersionFiles, assertNoTagPrefixCollisions, assertRetiredPackagesDoNotCollideWithActive, assertUniqueTagPrefixes, } from "./monorepoConfigAssertions.js";
+import { resolveReleaseDeclaration } from "./resolveReleaseDeclaration.js";
+export function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
+    const discovered = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
+    assertUniqueTagPrefixes(discovered);
+    const { retained: workspaces, excluded, directories: declaredDirectories, composite, } = resolveReleaseDeclaration(discovered, userConfig);
+    const directories = declaredDirectories.map((declared) => deriveDirectoryConfig(declared));
+    for (const workspace of workspaces) {
+        if (workspace.legacyIdentities !== undefined) {
+            assertLegacyIdentityDoesNotMatchCurrent(workspace.dir, workspace.name, workspace.tagPrefix, workspace.legacyIdentities);
+        }
+    }
+    if (userConfig?.retiredPackages !== undefined) {
+        assertRetiredPackagesDoNotCollideWithActive(workspaces, userConfig.retiredPackages);
+    }
+    const project = resolveProjectConfig(composite, rootPackage, workspaces);
+    const workTypes = resolveWorkTypes(userConfig?.workTypes);
+    const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+    const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
+    const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
+    assertNoSharedVersionFiles(workspaces, directories, project);
+    assertNoTagPrefixCollisions(workspaces, directories, userConfig?.retiredPackages, project);
+    const result = {
+        workspaces,
+        workTypes,
+        versionPatterns,
+        changelogJson,
+        releaseNotes,
+    };
+    if (excluded.length > 0) {
+        result.excludedWorkspaces = excluded;
+    }
+    if (directories.length > 0) {
+        result.directories = directories;
+    }
+    if (project !== undefined) {
+        result.project = project;
+    }
+    applyOptionalPassthroughFields(result, userConfig);
+    return result;
+}
+export function mergeSinglePackageConfig(userConfig) {
+    if (userConfig?.project !== undefined) {
+        throw new Error('project block is not supported in single-package mode');
+    }
+    if (userConfig?.releases !== undefined) {
+        throw new Error('releases block is not supported in single-package mode');
+    }
+    const workTypes = resolveWorkTypes(userConfig?.workTypes);
+    const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+    const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
+    const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
+    const result = {
+        workTypes,
+        versionPatterns,
+        changelogJson,
+        releaseNotes,
+    };
+    applyOptionalPassthroughFields(result, userConfig);
+    return result;
+}
+export function resolveWorkTypes(userWorkTypes) {
+    return userWorkTypes === undefined ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userWorkTypes };
+}
+function applyOptionalPassthroughFields(result, userConfig) {
+    if (userConfig?.changelogMarkdown !== undefined) {
+        result.changelogMarkdown = userConfig.changelogMarkdown;
+    }
+    if (userConfig?.formatCommand !== undefined) {
+        result.formatCommand = userConfig.formatCommand;
+    }
+    if (userConfig?.scopeAliases !== undefined) {
+        result.scopeAliases = userConfig.scopeAliases;
+    }
+    if (userConfig?.breakingPolicies !== undefined) {
+        result.breakingPolicies = userConfig.breakingPolicies;
+    }
+}
+function mergeChangelogJsonConfig(partial) {
+    if (partial === undefined) {
+        return { ...DEFAULT_CHANGELOG_JSON_CONFIG };
+    }
+    return {
+        enabled: partial.enabled ?? DEFAULT_CHANGELOG_JSON_CONFIG.enabled,
+        outputPath: partial.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+        devOnlySections: partial.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections],
+    };
+}
+function mergeReleaseNotesConfig(partial) {
+    if (partial === undefined) {
+        return { ...DEFAULT_RELEASE_NOTES_CONFIG };
+    }
+    return {
+        shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
+    };
+}
+function resolveProjectConfig(composite, rootPackage, workspaces) {
+    if (composite === undefined) {
+        return undefined;
+    }
+    const subject = composite.name === undefined ? 'project block' : `composite release '${composite.name}'`;
+    if (rootPackage === undefined || !rootPackage.exists) {
+        throw new Error(`${subject} requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`);
+    }
+    if (rootPackage.version === undefined) {
+        throw new Error(`${subject} requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to the root package.json`);
+    }
+    return {
+        paths: composite.paths ?? workspaces.flatMap((workspace) => workspace.paths),
+        tagPrefix: composite.tagPrefix ?? DEFAULT_PROJECT_TAG_PREFIX,
+        ...(composite.name !== undefined && { name: composite.name }),
+        ...(composite.members !== undefined && { members: composite.members }),
+    };
+}

package/dist/esm/monorepoConfigAssertions.d.ts

@@ -0,0 +1,49 @@
+import type { LegacyIdentity, RetiredPackage } from './configSchema.js';
+import type { DirectoryConfig, ResolvedProjectConfig, WorkspaceConfig } from './types.js';
+/**
+ * Throws when a workspace's `legacyIdentities` contains its current identity.
+ *
+ * An identity whose full `(name, tagPrefix)` tuple equals the current workspace's
+ * `(name, tagPrefix)` is a guaranteed no-op duplicate, almost always a copy-paste mistake.
+ * An entry whose `tagPrefix` matches but whose `name` differs is valid: It documents a prior
+ * rename that reused the same tag shape.
+ */
+export declare function assertLegacyIdentityDoesNotMatchCurrent(dir: string, currentName: string, currentTagPrefix: string, legacyIdentities: readonly LegacyIdentity[]): void;
+/**
+ * Throws when a directory target shares its version file with another target, whose release would bump the same
+ * `version` and write the same `CHANGELOG.md`: the repo root beside a composite, which the root `package.json` also
+ * versions. Pairs of other targets keep the behavior that they had before directories existed, so the check covers
+ * only pairs that include a directory.
+ */
+export declare function assertNoSharedVersionFiles(workspaces: readonly WorkspaceConfig[], directories: readonly DirectoryConfig[], project: ResolvedProjectConfig | undefined): void;
+/**
+ * Throws when any pair of tag prefixes from distinct owners is identical or one is a strict
+ * prefix of the other.
+ *
+ * A tag matches a prefix when the rest of its name is a complete SemVer version, so a prefix
+ * `'pkg-'` matches `'pkg-1.0.0-v1.2.3'` through its pre-release suffix. The owners are each
+ * workspace, each directory, each retired package, and the project. A workspace or a directory owns
+ * both its current prefix and its legacy-identity prefixes, because a prior identity may reuse the
+ * current tag shape under a different name.
+ */
+export declare function assertNoTagPrefixCollisions(workspaces: readonly WorkspaceConfig[], directories: readonly DirectoryConfig[], retiredPackages: readonly RetiredPackage[] | undefined, project: ResolvedProjectConfig | undefined): void;
+/**
+ * Throws when a retired package's `tagPrefix` matches an active workspace's derived prefix.
+ *
+ * A retired package is, by definition, no longer hosted by any active workspace in this repo.
+ * If its declared `tagPrefix` equals an active workspace's derived prefix, new tags from that
+ * workspace would collide with the retired package's historical tags.
+ */
+export declare function assertRetiredPackagesDoNotCollideWithActive(workspaces: readonly WorkspaceConfig[], retiredPackages: readonly RetiredPackage[]): void;
+/**
+ * Throws when two or more workspaces share the same `tagPrefix`.
+ *
+ * A collision means two workspaces would produce indistinguishable tags, breaking both tag
+ * creation and tag resolution. The error lists every colliding workspace path so that the author
+ * can rename one of the conflicting `package.json` `name` fields.
+ *
+ * This guards the pre-merge state when only workspaces have been derived. The broader
+ * strict-prefix check across legacy, retired, and project prefixes runs later in
+ * `assertNoTagPrefixCollisions`.
+ */
+export declare function assertUniqueTagPrefixes(workspaces: readonly WorkspaceConfig[]): void;

package/dist/esm/monorepoConfigAssertions.js

@@ -0,0 +1,126 @@
+import { ROOT_PACKAGE_JSON_PATH } from "./loadConfig.js";
+import { getTargetName, normalizeWorkspacePath } from "./resolveReleaseDeclaration.js";
+export function assertLegacyIdentityDoesNotMatchCurrent(dir, currentName, currentTagPrefix, legacyIdentities) {
+    for (const identity of legacyIdentities) {
+        if (identity.name === currentName && identity.tagPrefix === currentTagPrefix) {
+            throw new Error(`Workspace '${dir}': legacyIdentities must not match the current identity ` +
+                `(name='${currentName}', tagPrefix='${currentTagPrefix}'). ` +
+                'The current identity is always searched; listing it again is a no-op.');
+        }
+    }
+}
+export function assertNoSharedVersionFiles(workspaces, directories, project) {
+    const owners = [
+        ...directories.map((directory) => ({
+            label: `directory release '${directory.name}'`,
+            versionFiles: [directory.versionFile],
+        })),
+        ...workspaces.map((workspace) => ({
+            label: `workspace '${getTargetName(workspace)}'`,
+            versionFiles: workspace.packageFiles.map(normalizeWorkspacePath),
+        })),
+        ...(project === undefined
+            ? []
+            : [
+                {
+                    label: project.name === undefined ? 'the project release' : `composite release '${project.name}'`,
+                    versionFiles: [ROOT_PACKAGE_JSON_PATH],
+                },
+            ]),
+    ];
+    for (const [index, directory] of directories.entries()) {
+        const peer = owners.slice(index + 1).find((owner) => owner.versionFiles.includes(directory.versionFile));
+        if (peer !== undefined) {
+            throw new Error(`directory release '${directory.name}' and ${peer.label} share the version file '${directory.versionFile}', ` +
+                "so each release would overwrite the other's version and changelog; declare only one of them");
+        }
+    }
+}
+export function assertNoTagPrefixCollisions(workspaces, directories, retiredPackages, project) {
+    const sources = [];
+    for (const workspace of workspaces) {
+        const owner = `ws:${workspace.dir}`;
+        sources.push({ prefix: workspace.tagPrefix, label: `workspace '${workspace.dir}'`, owner });
+        const legacyIdentities = workspace.legacyIdentities ?? [];
+        for (const identity of legacyIdentities) {
+            sources.push({
+                prefix: identity.tagPrefix,
+                label: `workspace '${workspace.dir}' legacyIdentities entry (name='${identity.name}')`,
+                owner,
+            });
+        }
+    }
+    for (const directory of directories) {
+        const owner = `dir:${directory.path}`;
+        sources.push({ prefix: directory.tagPrefix, label: `directory release '${directory.name}'`, owner });
+        const legacyIdentities = directory.legacyIdentities ?? [];
+        for (const identity of legacyIdentities) {
+            sources.push({
+                prefix: identity.tagPrefix,
+                label: `directory release '${directory.name}' legacyIdentities entry (name='${identity.name}')`,
+                owner,
+            });
+        }
+    }
+    const retiredEntries = (retiredPackages ?? []).entries();
+    for (const [index, retired] of retiredEntries) {
+        sources.push({
+            prefix: retired.tagPrefix,
+            label: `retiredPackages entry (name='${retired.name}')`,
+            owner: `retired:${index}`,
+        });
+    }
+    if (project !== undefined) {
+        sources.push({
+            prefix: project.tagPrefix,
+            label: project.name === undefined ? 'project' : `composite release '${project.name}'`,
+            owner: 'project',
+        });
+    }
+    for (let i = 0; i < sources.length; i++) {
+        for (let j = i + 1; j < sources.length; j++) {
+            const a = sources[i];
+            const b = sources[j];
+            if (a === undefined || b === undefined || a.owner === b.owner)
+                continue;
+            if (isPrefixCollision(a.prefix, b.prefix)) {
+                throw new Error(`Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). ` +
+                    'One prefix is identical to or a strict prefix of the other; ' +
+                    'a tag under the longer prefix can then match the shorter one and be counted among its releases.');
+            }
+        }
+    }
+}
+export function assertRetiredPackagesDoNotCollideWithActive(workspaces, retiredPackages) {
+    const workspaceByDerivedPrefix = new Map();
+    for (const workspace of workspaces) {
+        workspaceByDerivedPrefix.set(workspace.tagPrefix, workspace);
+    }
+    for (const retired of retiredPackages) {
+        const active = workspaceByDerivedPrefix.get(retired.tagPrefix);
+        if (active !== undefined) {
+            throw new Error(`retiredPackages: tagPrefix '${retired.tagPrefix}' collides with active workspace '${active.dir}' ` +
+                `(derived prefix '${active.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`);
+        }
+    }
+}
+export function assertUniqueTagPrefixes(workspaces) {
+    const pathsByPrefix = new Map();
+    for (const workspace of workspaces) {
+        const existing = pathsByPrefix.get(workspace.tagPrefix);
+        if (existing === undefined) {
+            pathsByPrefix.set(workspace.tagPrefix, [workspace.workspacePath]);
+        }
+        else {
+            existing.push(workspace.workspacePath);
+        }
+    }
+    for (const [prefix, paths] of pathsByPrefix) {
+        if (paths.length > 1) {
+            throw new Error(`Duplicate tag prefix '${prefix}' for workspaces: ${paths.join(', ')}`);
+        }
+    }
+}
+function isPrefixCollision(a, b) {
+    return a === b || a.startsWith(b) || b.startsWith(a);
+}

package/dist/esm/planChangelogFiles.d.ts

@@ -0,0 +1,16 @@
+import type { PlannedWrite } from './releasePlan.js';
+import type { ChangelogEntry, ChangelogPreservation, ReleaseSettings } from './types.js';
+/**
+ * Plans the `changelog.json` (when enabled), `CHANGELOG.md`, and archive files of one changelog directory from the new
+ * entries merged with the entries on disk, so that the markdown includes prior releases whether or not the JSON is
+ * written. Also plans the removal of every existing archive file that the render does not produce.
+ */
+export declare function planChangelogFiles(changelogDir: string, newEntries: ChangelogEntry[], settings: Pick<ReleaseSettings, 'changelogJson' | 'changelogMarkdown'>, sectionOrder: string[]): {
+    /** The `CHANGELOG.md`, then its archive files. */
+    changelogFiles: string[];
+    changelogJsonFiles: string[];
+    entries: ChangelogEntry[];
+    preservation: ChangelogPreservation | undefined;
+    removals: string[];
+    writes: PlannedWrite[];
+};

package/dist/esm/planChangelogFiles.js

@@ -0,0 +1,41 @@
+import { join as joinPath } from 'node:path';
+import { describeArchivePath, listArchiveFiles } from "./changelogArchive.js";
+import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
+import { planPreservedSections } from "./readChangelogSections.js";
+import { renderChangelogFiles } from "./renderChangelogMarkdown.js";
+export function planChangelogFiles(changelogDir, newEntries, settings, sectionOrder) {
+    const jsonPath = resolveChangelogJsonPath(settings, changelogDir);
+    const entries = mergeChangelogEntriesWithDisk(jsonPath, newEntries);
+    const writes = [];
+    const changelogJsonFiles = [];
+    if (settings.changelogJson.enabled) {
+        writes.push({ path: jsonPath, content: renderChangelogJson(entries) });
+        changelogJsonFiles.push(jsonPath);
+    }
+    const changelogFile = joinPath(changelogDir, 'CHANGELOG.md');
+    const preserved = planPreservedSections(changelogDir, entries);
+    const keepVersions = settings.changelogMarkdown?.keepVersions;
+    const rendered = renderChangelogFiles(entries, {
+        sectionOrder,
+        preservedSections: preserved.sections,
+        ...(keepVersions !== undefined && { keepVersions }),
+    });
+    writes.push({ path: changelogFile, content: rendered.main });
+    const archiveFiles = [];
+    for (const { major, content } of rendered.archives) {
+        const path = joinPath(changelogDir, describeArchivePath(major));
+        writes.push({ path, content });
+        archiveFiles.push(path);
+    }
+    const removals = listArchiveFiles(changelogDir)
+        .map((archive) => archive.path)
+        .filter((path) => !archiveFiles.includes(path));
+    return {
+        changelogFiles: [changelogFile, ...archiveFiles],
+        changelogJsonFiles,
+        entries,
+        preservation: preserved.preservation,
+        removals,
+        writes,
+    };
+}