@wpelevator/wp-release 0.12.0 → 0.13.0

package/dist/changeset-release.js

@@ -3,7 +3,7 @@ import { getVersionedReleases, prependChangelog } from "./changelog.js";
 import { loadChangesetConfig } from "./changeset-config.js";
 import { applyDependents, assertDependentsSourcesReleased, collectPinDriftWarnings, expandDependentsPlan, findBundledPinChanges, hasChangeset, selectReleasePlan, stripDependentsPlan, updateDependencyDeclaration, } from "./changeset-dependents.js";
 import { consumeChangeset, readChangesets, readChangesetsSince, writeChangeset, } from "./changeset-files.js";
-import { assertKnownPackages, discoverPackages, getChangedPackages, toChangesetPackage, } from "./changeset-packages.js";
+import { discoverPackages, getChangedPackages, resolvePackageNames, toChangesetPackage, } from "./changeset-packages.js";
 import { getChangesetBump, getNextVersion } from "./changesets.js";
 import { ValidationError } from "./errors.js";
 import { FileJournal } from "./file-journal.js";
@@ -11,7 +11,7 @@ import { getPreviousTag, getReleaseNotes, getTagVersion, selectTagPackages, } fr
 import { ReleaseRepository } from "./release-repository.js";
 import { formatTag } from "./tag-format.js";
 import { verifyVersionTargets, writeVersion } from "./version-files.js";
-import { isPrerelease } from "./versions.js";
+import { getPrereleaseVersion, getSnapshotVersion, isPrerelease, } from "./versions.js";
 const MISSING_CONFIG = 'No wp-release config found. Add wp-release.config.js or pass --config <path>.';
 /**
  * Changeset releases of a repository: recording changesets, versioning the
@@ -67,8 +67,17 @@ export class ChangesetRelease {
     async add(options) {
         const config = await this.requireConfig();
         const packages = await discoverPackages(this.repository, config);
-        assertKnownPackages(packages, Object.keys(options.packages));
-        return writeChangeset(this.getChangesetDirectory(config), options.packages, options.summary, options.name);
+        const entries = Object.entries(options.packages);
+        const names = resolvePackageNames(packages, entries.map(([name]) => name));
+        const resolved = {};
+        entries.forEach(([, bump], index) => {
+            const name = names[index] ?? '';
+            if (Object.hasOwn(resolved, name)) {
+                throw new ValidationError(`Package "${name}" was passed more than once.`);
+            }
+            resolved[name] = bump;
+        });
+        return writeChangeset(this.getChangesetDirectory(config), resolved, options.summary, options.name);
     }
     /**
      * Apply pending package versions and changelogs. A failed run restores
@@ -82,9 +91,12 @@ export class ChangesetRelease {
         const context = await this.requireContext();
         const { config, packages } = context;
         const withDependents = options.dependents ?? true;
+        const selected = options.packages
+            ? resolvePackageNames(packages, options.packages)
+            : undefined;
         let releasePlan = context.plan;
-        if (options.packages) {
-            releasePlan = expandDependentsPlan(await selectReleasePlan(context.plan, packages, options.packages, config, withDependents));
+        if (selected) {
+            releasePlan = expandDependentsPlan(await selectReleasePlan(context.plan, packages, selected, config, withDependents));
         }
         else if (!withDependents) {
             releasePlan = stripDependentsPlan(context.plan);
@@ -96,10 +108,31 @@ export class ChangesetRelease {
         if (withDependents && config.dependents) {
             await assertDependentsSourcesReleased(releasePlan, context.plan, packages, config);
         }
+        if (undefined !== options.prerelease &&
+            undefined !== options.snapshot) {
+            throw new ValidationError('A release cannot be both a pre-release and a snapshot.');
+        }
+        if (undefined !== options.snapshot) {
+            const id = options.snapshot;
+            const time = options.snapshotTime ?? new Date();
+            releasePlan = {
+                ...releasePlan,
+                releases: releasePlan.releases.map((release) => ({
+                    ...release,
+                    nextVersion: getSnapshotVersion(release.nextVersion, id, time),
+                })),
+            };
+        }
+        if (undefined !== options.prerelease) {
+            releasePlan = {
+                ...releasePlan,
+                releases: await this.toPrereleases(context, releasePlan.releases, options.prerelease),
+            };
+        }
         const date = options.date ?? new Date().toISOString().slice(0, 10);
         const releases = await getVersionedReleases(this.repository, config, releasePlan.releases, this.getChangesetDirectory(config));
         if (!options.dryRun) {
-            await this.writeReleases(context, releasePlan, releases, date, options.packages);
+            await this.writeReleases(context, releasePlan, releases, date, selected);
         }
         return {
             changesets: releasePlan.changesets,
@@ -124,7 +157,7 @@ export class ChangesetRelease {
             throw new ValidationError('Listing untagged releases cannot be combined with pushing tags.');
         }
         const context = await this.requireContext();
-        const selected = selectTagPackages(context.packages, options.packages ?? [], options.version);
+        const selected = selectTagPackages(context.packages, resolvePackageNames(context.packages, options.packages ?? []), options.version);
         const packages = options.since
             ? (await getChangedPackages(this.repository, selected, options.since)).packages
             : selected;
@@ -185,14 +218,23 @@ export class ChangesetRelease {
         const since = options.since ??
             (config.baseBranch ? `origin/${config.baseBranch}` : undefined);
         const changed = since
-            ? await getChangedPackages(this.repository, packages, since)
+            ? await getChangedPackages(this.repository, packages, since, options.uncommitted)
             : { packages: [], filesByPackage: {} };
         const changedPackages = changed.packages.map((pkg) => pkg.name);
         const changesetsInDiff = since
-            ? await readChangesetsSince(this.repository, this.getChangesetDirectory(config), changesets, since)
+            ? await readChangesetsSince(this.repository, this.getChangesetDirectory(config), changesets, since, options.uncommitted)
             : [];
         const hasEmptyChangeset = changesetsInDiff.some((changeset) => 0 === Object.keys(changeset.packages).length);
-        const bundled = await findBundledPinChanges(changed, changesetsInDiff, packages, config);
+        const bundled = since
+            ? await findBundledPinChanges({
+                changed,
+                changesetsInDiff,
+                packages,
+                config,
+                repository: this.repository,
+                since,
+            })
+            : new Set();
         const missingChangesets = hasEmptyChangeset
             ? []
             : changedPackages.filter((name) => !hasChangeset(changesetsInDiff, name) &&
@@ -203,6 +245,7 @@ export class ChangesetRelease {
             ? await collectPinDriftWarnings(config, packages)
             : [];
         return {
+            ...(since ? { since } : {}),
             changesets,
             releases,
             changedPackages,
@@ -211,6 +254,40 @@ export class ChangesetRelease {
             warnings,
         };
     }
+    /**
+     * Turn the next versions of releases into pre-releases, like 1.3.0-rc.1
+     * for 1.3.0, numbered from the existing tags of each package. Dependents
+     * become pre-releases too, so they bundle the pre-releases of their sources.
+     *
+     * @param  context    Release context.
+     * @param  releases   Releases with their stable next versions.
+     * @param  prerelease Pre-release identifier with an optional number, like rc or rc.1.
+     * @return Releases with their pre-release next versions.
+     * @throws {ValidationError} For an invalid pre-release or an existing version.
+     */
+    async toPrereleases(context, releases, prerelease) {
+        const tagFormat = context.config.tagFormat ?? '{path}/{version}';
+        return Promise.all(releases.map(async (release) => {
+            const configured = context.packages.find((pkg) => pkg.name === release.package.name);
+            const versions = configured
+                ? await this.listTaggedVersions(formatTag(tagFormat, configured, ''))
+                : [];
+            return {
+                ...release,
+                nextVersion: getPrereleaseVersion(release.nextVersion, prerelease, versions),
+            };
+        }));
+    }
+    /**
+     * List the versions of the tags with a prefix.
+     *
+     * @param prefix Tag prefix of a package, like `plugins/alpha/`.
+     * @return Tagged versions.
+     */
+    async listTaggedVersions(prefix) {
+        const tags = await this.repository.listTags(prefix);
+        return tags.map((tag) => tag.slice(prefix.length));
+    }
     /**
      * Write the versions, dependency specs and changelogs of the releases and
      * consume the applied changesets, restoring every changed file when a

package/dist/changesets.d.ts

@@ -83,11 +83,15 @@ export declare function formatChangelogList(entries: string[]): string;
  */
 export declare function getChangesetBump(changesets: Changeset[], packageName: string): ChangesetBump | undefined;
 /**
- * Calculate the next stable semantic version using literal SemVer bump rules.
+ * Calculate the next stable version using literal SemVer bump rules. Besides
+ * x.y.z, it accepts the x.y and x.y.z.w versions common in WordPress plugins:
+ * the bumped part is raised, the parts after it reset to 0, and the version
+ * keeps its number of parts, so a minor bump of 2.1 is 2.2 and of 1.2.3.4 is
+ * 1.3.0.0. A patch bump of x.y adds the third part, so 2.1 becomes 2.1.1.
  *
  * @param  currentVersion Current package version.
  * @param  bump           Requested bump.
  * @return Next version.
- * @throws {ValidationError} If currentVersion is not a stable x.y.z version.
+ * @throws {ValidationError} If currentVersion is not a stable x.y, x.y.z or x.y.z.w version.
  */
 export declare function getNextVersion(currentVersion: string, bump: ChangesetBump): string;

package/dist/changesets.js

@@ -99,26 +99,32 @@ export function getChangesetBump(changesets, packageName) {
     return bumps.sort((a, b) => BUMP_RANK[b] - BUMP_RANK[a])[0];
 }
 /**
- * Calculate the next stable semantic version using literal SemVer bump rules.
+ * Calculate the next stable version using literal SemVer bump rules. Besides
+ * x.y.z, it accepts the x.y and x.y.z.w versions common in WordPress plugins:
+ * the bumped part is raised, the parts after it reset to 0, and the version
+ * keeps its number of parts, so a minor bump of 2.1 is 2.2 and of 1.2.3.4 is
+ * 1.3.0.0. A patch bump of x.y adds the third part, so 2.1 becomes 2.1.1.
  *
  * @param  currentVersion Current package version.
  * @param  bump           Requested bump.
  * @return Next version.
- * @throws {ValidationError} If currentVersion is not a stable x.y.z version.
+ * @throws {ValidationError} If currentVersion is not a stable x.y, x.y.z or x.y.z.w version.
  */
 export function getNextVersion(currentVersion, bump) {
     if (!CHANGESET_BUMPS.includes(bump)) {
         throw new ValidationError(`Invalid bump "${bump}"; expected patch, minor or major.`);
     }
-    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(currentVersion);
-    if (!match) {
-        throw new ValidationError(`Cannot bump "${currentVersion}": expected a stable semantic version in x.y.z format.`);
+    if (!/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){1,3}$/.test(currentVersion)) {
+        throw new ValidationError(`Cannot bump "${currentVersion}": expected a stable version in x.y, x.y.z or x.y.z.w format.`);
     }
-    if ('major' === bump) {
-        return `${Number(match[1]) + 1}.0.0`;
-    }
-    if ('minor' === bump) {
-        return `${match[1]}.${Number(match[2]) + 1}.0`;
-    }
-    return `${match[1]}.${match[2]}.${Number(match[3]) + 1}`;
+    const parts = currentVersion.split('.').map(Number);
+    const index = { major: 0, minor: 1, patch: 2 }[bump];
+    const length = Math.max(parts.length, index + 1);
+    return Array.from({ length }, (_, position) => {
+        const part = parts[position] ?? 0;
+        if (position === index) {
+            return part + 1;
+        }
+        return position < index ? part : 0;
+    }).join('.');
 }

package/dist/cli.d.ts

@@ -6,7 +6,13 @@ import type { ChangesetVersionResult } from './commands/changeset-version.ts';
 import { Logger } from './logger.ts';
 import type { OutputStream } from './logger.ts';
 import type { Command, CommandOutcome } from './commands/command.ts';
+/** Input stream that interactive prompts read from in a terminal. */
+export type InputStream = NodeJS.ReadableStream & {
+    isTTY?: boolean;
+};
 export interface CliIo {
+    /** Input for interactive prompts, used when it and stdout are a terminal. */
+    stdin?: InputStream;
     /** Stream for regular output. */
     stdout?: OutputStream;
     /** Stream for errors. */
@@ -74,7 +80,7 @@ export declare function execute<Name extends keyof CommandResults>(name: Name, a
  * Run the CLI.
  *
  * @param args CLI arguments without the node and script paths.
- * @param io   Output streams and working directory.
+ * @param io   Input and output streams and working directory.
  * @return Exit code.
  */
 export declare function run(args: string[], io?: CliIo): Promise<number>;

package/dist/cli.js

@@ -176,11 +176,11 @@ function getGitHubOutputFile(values) {
  *
  * @param command Command definition with options and run().
  * @param args    Arguments after the command name.
- * @param io      Output streams and working directory.
+ * @param io      Input and output streams and working directory.
  * @return Exit code.
  */
 async function runCommand(command, args, io) {
-    const { stdout, stderr, cwd } = io;
+    const { stdin, stdout, stderr, cwd } = io;
     let logger = new Logger({ writer: new TextWriter({ stdout, stderr }) });
     try {
         const { values, positionals } = parseArgs({
@@ -198,12 +198,20 @@ async function runCommand(command, args, io) {
             quiet: getBoolean(values, 'quiet') || getBoolean(values, 'json'),
             verbose: getBoolean(values, 'verbose'),
         });
+        // Prompts need a person at a terminal, and would corrupt JSON output.
+        const interactive = true === stdin.isTTY &&
+            true === stdout.isTTY &&
+            !getBoolean(values, 'json') &&
+            !githubOutputFile;
         const { exitCode, result } = await command.run({
             values,
             positionals,
             cwd,
             ...(configFile ? { configFile } : {}),
             logger,
+            ...(interactive
+                ? { terminal: { input: stdin, output: stdout } }
+                : {}),
         });
         if (getBoolean(values, 'json')) {
             stdout.write(JSON.stringify(result, null, '\t') + '\n');
@@ -259,11 +267,11 @@ export async function execute(name, args, context) {
  * Run the CLI.
  *
  * @param args CLI arguments without the node and script paths.
- * @param io   Output streams and working directory.
+ * @param io   Input and output streams and working directory.
  * @return Exit code.
  */
 export async function run(args, io = {}) {
-    const { stdout = process.stdout, stderr = process.stderr, cwd = process.cwd(), } = io;
+    const { stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, cwd = process.cwd(), } = io;
     const wantsHelp = args.includes('--help') || args.includes('-h');
     const command = findCommand(args);
     if (command && wantsHelp) {
@@ -271,7 +279,12 @@ export async function run(args, io = {}) {
         return EXIT_SUCCESS;
     }
     if (command) {
-        return runCommand(command, args.slice(1), { stdout, stderr, cwd });
+        return runCommand(command, args.slice(1), {
+            stdin,
+            stdout,
+            stderr,
+            cwd,
+        });
     }
     if (0 === args.length || wantsHelp || 'help' === args[0]) {
         stdout.write(getHelp() + '\n');

package/dist/commands/changeset-add.d.ts

@@ -22,15 +22,18 @@ declare const _default: {
         readonly empty: {
             readonly type: "boolean";
         };
+        readonly since: {
+            readonly type: "string";
+        };
         readonly name: {
             readonly type: "string";
         };
     };
-    run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+    run({ values, cwd, configFile, logger, terminal }: import("./command.ts").CommandContext): Promise<{
         exitCode: number;
         result: {
             file: string;
-            packages: import("../changesets.ts").ChangesetPackages;
+            packages: any;
         };
     }>;
 };

package/dist/commands/changeset-add.js

@@ -1,34 +1,133 @@
-import { addChangeset } from "../changeset-release.js";
+import { resolvePackageNames } from "../changeset-packages.js";
+import { ChangesetPrompt } from "../changeset-prompt.js";
+import { ChangesetRelease } from "../changeset-release.js";
+import { ValidationError } from "../errors.js";
 import { parseChangesetAddArgs, changesetAddArgs } from "./changeset-args.js";
+/**
+ * Get the bumps of the changed packages that have no changeset yet.
+ *
+ * @param  release Changeset release of the repository.
+ * @param  input   Parsed options with the base ref.
+ * @param  bump    Bump of the changed packages.
+ * @return Bump of each changed package.
+ * @throws {ValidationError} If no changed package needs a changeset.
+ */
+async function getChangedPackageBumps(release, input, bump) {
+    const status = await release.getStatus({
+        ...(input.since ? { since: input.since } : {}),
+        uncommitted: true,
+    });
+    if (!status.missingChangesets.length) {
+        const since = status.since ? ` since ${status.since}` : '';
+        throw new ValidationError(`No package changed${since} without a changeset. Pass --package <name> to choose the packages.`);
+    }
+    return Object.fromEntries(status.missingChangesets.map((name) => [name, bump]));
+}
+/**
+ * Ask for the changeset, preselecting the changed packages without one.
+ *
+ * @param release  Changeset release of the repository.
+ * @param input    Parsed options with the base ref and release note.
+ * @param terminal Terminal to ask in.
+ * @return Package bumps and release note.
+ */
+async function askChangeset(release, input, terminal) {
+    const packages = await release.getPackages();
+    const status = await release.getStatus({
+        ...(input.since ? { since: input.since } : {}),
+        uncommitted: true,
+    });
+    const prompt = new ChangesetPrompt(terminal);
+    try {
+        return await prompt.ask({
+            packages,
+            changed: status.missingChangesets,
+            ...(status.since ? { since: status.since } : {}),
+            ...(input.summary ? { summary: input.summary } : {}),
+        });
+    }
+    finally {
+        prompt.close();
+    }
+}
+/**
+ * Get the package bumps and release note from the options, the changed
+ * packages or the prompts.
+ *
+ * @param  release  Changeset release of the repository.
+ * @param  input    Parsed options.
+ * @param  terminal Terminal to ask in, when the CLI runs in one.
+ * @return Package bumps, empty for no release, and release note.
+ * @throws {ValidationError} Without packages outside a terminal.
+ */
+async function getChangeset(release, input, terminal) {
+    const summary = input.summary ?? '';
+    let changeset;
+    if (input.empty) {
+        changeset = { packages: {}, summary };
+    }
+    else if (Object.keys(input.packages).length) {
+        changeset = { packages: input.packages, summary };
+    }
+    else if (input.bump) {
+        changeset = {
+            packages: await getChangedPackageBumps(release, input, input.bump),
+            summary,
+        };
+    }
+    else if (terminal) {
+        changeset = await askChangeset(release, input, terminal);
+    }
+    else {
+        throw new ValidationError('Pass matching repeated --package <name> and --bump <patch|minor|major> options, a single --bump for the changed packages, or --empty.');
+    }
+    return changeset;
+}
 export default {
     name: 'changeset-add',
-    usage: 'changeset-add (--empty | --package <name> --bump <bump> ...) [options]',
+    usage: 'changeset-add [--empty | --package <name> --bump <bump> ... | --bump <bump>] [options]',
     summary: 'Add a package release note for the next release PR.',
     help: `Options:
-  --package <name>       Package identifier (repeatable)
+  --package <name>       Package identifier, or its path under the configured
+                         root (repeatable)
   --bump <bump>          patch, minor or major (repeatable, in package order)
   --summary <text>       Customer-facing release note
   --empty                Record that this change does not need a release
+  --since <ref>          Compare changed files with this git ref (default:
+                         origin/<baseBranch>)
   --name <name>          Changeset filename (default: random identifier)
 
 Use --package and --bump pairs for package releases, or --empty for changes
-that should pass the status check without producing a release.`,
+that should pass the status check without producing a release. A single
+--bump without --package releases the packages that changed since the base
+ref, including uncommitted files, and have no changeset yet. Without
+--package and --bump in a terminal, the command asks for the packages, with
+the changed ones preselected, their bumps and the release note.`,
     options: changesetAddArgs,
-    async run({ values, cwd, configFile, logger }) {
+    async run({ values, cwd, configFile, logger, terminal }) {
         const input = parseChangesetAddArgs(values);
-        const file = await addChangeset({
+        const release = new ChangesetRelease({
             cwd,
             ...(configFile ? { configFile } : {}),
-            packages: input.packages,
-            summary: input.summary,
+        });
+        const changeset = await getChangeset(release, input, terminal);
+        // Adding resolves the package paths and rejects a package passed twice.
+        const file = await release.add({
+            packages: changeset.packages,
+            summary: changeset.summary,
             ...(input.name ? { name: input.name } : {}),
         });
+        const names = resolvePackageNames(await release.getPackages(), Object.keys(changeset.packages));
+        const packages = Object.fromEntries(Object.values(changeset.packages).map((bump, index) => [
+            names[index],
+            bump,
+        ]));
         logger.info(`Created ${file}.`);
         return {
             exitCode: 0,
             result: {
                 file,
-                packages: input.packages,
+                packages,
             },
         };
     },

package/dist/commands/changeset-args.d.ts

@@ -1,10 +1,14 @@
-import type { ChangesetPackages } from '../changesets.ts';
+import type { ChangesetBump, ChangesetPackages } from '../changesets.ts';
 import type { ParsedValues } from './command.ts';
 /** Parsed input for `changeset-add`. */
 export interface ChangesetAddArgs {
+    /** Bump of each package passed with --package, by identifier or path. */
     packages: ChangesetPackages;
-    summary: string;
+    /** Bump for the changed packages without a changeset, passed without --package. */
+    bump?: ChangesetBump;
+    summary?: string;
     empty: boolean;
+    since?: string;
     name?: string;
 }
 /** Parse-args options for `changeset-add`. */
@@ -23,16 +27,21 @@ export declare const changesetAddArgs: {
     readonly empty: {
         readonly type: "boolean";
     };
+    readonly since: {
+        readonly type: "string";
+    };
     readonly name: {
         readonly type: "string";
     };
 };
 /**
- * Parse and validate the `changeset-add` options.
+ * Parse and validate the `changeset-add` options. Without --package, a
+ * single --bump applies to the changed packages without a changeset, and
+ * without --bump either the command asks for the changeset in a terminal.
  *
  * @param  values Parsed CLI options.
  * @return Normalized changeset input.
- * @throws {ValidationError} If required options are missing or conflicting.
+ * @throws {ValidationError} If options are conflicting or incomplete.
  */
 export declare function parseChangesetAddArgs(values: ParsedValues): ChangesetAddArgs;
 /** Parse-args options for `changeset-status`. */
@@ -68,6 +77,12 @@ export declare const changesetVersionArgs: {
     readonly 'no-dependents': {
         readonly type: "boolean";
     };
+    readonly prerelease: {
+        readonly type: "string";
+    };
+    readonly snapshot: {
+        readonly type: "string";
+    };
 };
 /** Parsed input for `changeset-version`. */
 export interface ChangesetVersionArgs {
@@ -76,6 +91,10 @@ export interface ChangesetVersionArgs {
     packages?: string[];
     /** Whether the selected sources release their configured dependents; defaults to true. */
     dependents: boolean;
+    /** Pre-release identifier with an optional number, like rc or rc.1. */
+    prerelease?: string;
+    /** Snapshot identifier, like pr-251. */
+    snapshot?: string;
 }
 /**
  * Validate and normalize a release date option.
@@ -90,7 +109,7 @@ export declare function parseChangesetDate(value: string | undefined): string |
  *
  * @param  values Parsed CLI options.
  * @return Normalized versioning input.
- * @throws {ValidationError} If --date is invalid.
+ * @throws {ValidationError} If --date is invalid, or an option is empty or conflicting.
  */
 export declare function parseChangesetVersionArgs(values: ParsedValues): ChangesetVersionArgs;
 /** Parse-args options for `changeset-tag`. */