@wpelevator/wp-release 0.12.0 → 0.13.0

package/dist/changeset-files.js

@@ -28,17 +28,19 @@ export async function readChangesets(directory) {
 /**
  * Pick the changesets that were added or changed since a ref.
  *
- * @param repository Repository of the changesets.
- * @param directory  Changeset directory.
- * @param changesets Pending changesets.
- * @param since      Base ref, like origin/main.
+ * @param repository  Repository of the changesets.
+ * @param directory   Changeset directory.
+ * @param changesets  Pending changesets.
+ * @param since       Base ref, like origin/main.
+ * @param uncommitted Whether to include uncommitted and untracked changesets.
  * @return Changesets of the diff.
  */
-export async function readChangesetsSince(repository, directory, changesets, since) {
+export async function readChangesetsSince(repository, directory, changesets, since, uncommitted = false) {
     const relativeDirectory = repository.relativePath(directory);
     const changedFiles = new Set(await repository.getChangedFiles(since, {
         directory,
         diffFilter: 'ACMR',
+        uncommitted,
     }));
     return changesets.filter((changeset) => changedFiles.has(path.posix.join(relativeDirectory, changeset.fileName)));
 }

package/dist/changeset-packages.d.ts

@@ -1,4 +1,4 @@
-import type { ChangesetConfig, ChangesetPackageGroup } from './changeset-config.ts';
+import type { ChangesetConfig, ChangesetPackageGroup, DeployPackage, PackageVersionConfig } from './changeset-config.ts';
 import type { ChangesetPackage } from './changesets.ts';
 import type { ReleaseRepository } from './release-repository.ts';
 /**
@@ -6,7 +6,14 @@ import type { ReleaseRepository } from './release-repository.ts';
  */
 export interface ConfiguredPackage extends ChangesetPackage {
     group: ChangesetPackageGroup;
-    versionConfig: ChangesetPackageGroup['version'];
+    versionConfig: PackageVersionConfig;
+}
+/**
+ * A discovered package of a group with deploy targets, which may have no
+ * version configuration.
+ */
+export interface ConfiguredDeployPackage extends DeployPackage {
+    group: ChangesetPackageGroup;
 }
 export interface ChangedPackages {
     /** Packages with changed files, in the configured order. */
@@ -16,7 +23,8 @@ export interface ChangedPackages {
 }
 /**
  * Find the packages of the configured package groups, with their current
- * versions.
+ * versions. Groups without a version configuration aren't released with
+ * changesets, so they're left out.
  *
  * @param  repository Repository the packages are in.
  * @param  config     Repository release configuration.
@@ -24,6 +32,16 @@ export interface ChangedPackages {
  * @throws {ValidationError} For a glob without matches or a duplicate package name.
  */
 export declare function discoverPackages(repository: ReleaseRepository, config: ChangesetConfig): Promise<ConfiguredPackage[]>;
+/**
+ * Find the packages of the package groups with deploy targets, including the
+ * groups without a version configuration, without reading their versions.
+ *
+ * @param  repository Repository the packages are in.
+ * @param  config     Repository release configuration.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} For a glob without matches or a duplicate package name.
+ */
+export declare function discoverDeployPackages(repository: ReleaseRepository, config: ChangesetConfig): Promise<ConfiguredDeployPackage[]>;
 /**
  * Fail for package names that aren't configured.
  *
@@ -33,15 +51,34 @@ export declare function discoverPackages(repository: ReleaseRepository, config:
  */
 export declare function assertKnownPackages(packages: ChangesetPackage[], names: string[]): void;
 /**
- * Find the packages with files changed between the merge base of a ref and
- * HEAD.
+ * Find a package by its identifier, or by its path under the configured root,
+ * so that contributors can name a package by the directory they changed.
  *
- * @param repository Repository the packages are in.
  * @param packages   Discovered packages.
- * @param since      Base ref, like origin/main.
+ * @param identifier Package identifier or path, like plugins/alpha or plugins/alpha/.
+ * @return The package, or undefined when none matches.
+ */
+export declare function findPackage<Package extends Pick<ChangesetPackage, 'name' | 'path'>>(packages: Package[], identifier: string): Package | undefined;
+/**
+ * Resolve package identifiers or paths to the package identifiers.
+ *
+ * @param  packages    Discovered packages.
+ * @param  identifiers Package identifiers or paths under the configured root.
+ * @return Package identifiers, in the given order.
+ * @throws {ValidationError} For an unknown package.
+ */
+export declare function resolvePackageNames(packages: ChangesetPackage[], identifiers: string[]): string[];
+/**
+ * Find the packages with files changed between the merge base of a ref and
+ * HEAD, or the working tree.
+ *
+ * @param repository  Repository the packages are in.
+ * @param packages    Discovered packages.
+ * @param since       Base ref, like origin/main.
+ * @param uncommitted Whether to include uncommitted and untracked files.
  * @return Changed packages and their changed files.
  */
-export declare function getChangedPackages(repository: ReleaseRepository, packages: ConfiguredPackage[], since: string): Promise<ChangedPackages>;
+export declare function getChangedPackages(repository: ReleaseRepository, packages: ConfiguredPackage[], since: string, uncommitted?: boolean): Promise<ChangedPackages>;
 /**
  * Remove the release configuration from a package passed to config callbacks.
  *

package/dist/changeset-packages.js

@@ -7,7 +7,8 @@ import { readVersion } from "./version-files.js";
 const SKIPPED_DIRECTORIES = ['.git', 'node_modules', 'vendor', 'dist'];
 /**
  * Find the packages of the configured package groups, with their current
- * versions.
+ * versions. Groups without a version configuration aren't released with
+ * changesets, so they're left out.
  *
  * @param  repository Repository the packages are in.
  * @param  config     Repository release configuration.
@@ -15,13 +16,38 @@ const SKIPPED_DIRECTORIES = ['.git', 'node_modules', 'vendor', 'dist'];
  * @throws {ValidationError} For a glob without matches or a duplicate package name.
  */
 export async function discoverPackages(repository, config) {
+    const found = await findGroupPackages(repository, config, config.packages.filter((group) => group.version));
+    const packages = [];
+    for (const pkg of found) {
+        const versionConfig = pkg.group.version;
+        packages.push({
+            ...pkg,
+            currentVersion: await readVersion(repository, pkg.directory, versionConfig.from, pkg.path, pkg.group.tagType),
+            versionConfig,
+        });
+    }
+    return packages;
+}
+/**
+ * Find the packages of the package groups with deploy targets, including the
+ * groups without a version configuration, without reading their versions.
+ *
+ * @param  repository Repository the packages are in.
+ * @param  config     Repository release configuration.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} For a glob without matches or a duplicate package name.
+ */
+export async function discoverDeployPackages(repository, config) {
+    return findGroupPackages(repository, config, config.packages.filter((group) => group.deploy));
+}
+async function findGroupPackages(repository, config, groups) {
     const root = path.resolve(repository.cwd, config.root ?? '.');
     const packages = [];
-    const hasRecursiveGlob = config.packages.some((item) => item.glob.split('/').includes('**'));
+    const hasRecursiveGlob = groups.some((item) => item.glob.split('/').includes('**'));
     const directories = await findDirectories(root, '', hasRecursiveGlob
         ? Infinity
-        : Math.max(1, ...config.packages.map((item) => item.glob.split('/').length + 2)));
-    for (const group of config.packages) {
+        : Math.max(1, ...groups.map((item) => item.glob.split('/').length + 2)));
+    for (const group of groups) {
         const matcher = globRegExp(group.glob);
         const candidates = matcher.test('.')
             ? ['.', ...directories]
@@ -36,7 +62,6 @@ export async function discoverPackages(repository, config) {
         for (const relativePath of matches) {
             const directory = path.join(root, relativePath);
             const name = await packageName(directory, relativePath, group.idFrom ?? 'path');
-            const currentVersion = await readVersion(repository, directory, group.version.from, relativePath, group.tagType);
             if (packages.some((pkg) => pkg.name === name)) {
                 throw new ValidationError(`Package identifier "${name}" is configured more than once.`);
             }
@@ -45,9 +70,7 @@ export async function discoverPackages(repository, config) {
                 directory,
                 path: relativePath,
                 type: packageType(group),
-                currentVersion,
                 group,
-                versionConfig: group.version,
             });
         }
     }
@@ -68,16 +91,52 @@ export function assertKnownPackages(packages, names) {
     });
 }
 /**
- * Find the packages with files changed between the merge base of a ref and
- * HEAD.
+ * Find a package by its identifier, or by its path under the configured root,
+ * so that contributors can name a package by the directory they changed.
  *
- * @param repository Repository the packages are in.
  * @param packages   Discovered packages.
- * @param since      Base ref, like origin/main.
+ * @param identifier Package identifier or path, like plugins/alpha or plugins/alpha/.
+ * @return The package, or undefined when none matches.
+ */
+export function findPackage(packages, identifier) {
+    const packagePath = identifier
+        .replaceAll('\\', '/')
+        .replace(/^\.\//, '')
+        .replace(/\/+$/, '');
+    return (packages.find((pkg) => pkg.name === identifier) ??
+        packages.find((pkg) => pkg.path === packagePath));
+}
+/**
+ * Resolve package identifiers or paths to the package identifiers.
+ *
+ * @param  packages    Discovered packages.
+ * @param  identifiers Package identifiers or paths under the configured root.
+ * @return Package identifiers, in the given order.
+ * @throws {ValidationError} For an unknown package.
+ */
+export function resolvePackageNames(packages, identifiers) {
+    return identifiers.map((identifier) => {
+        const pkg = findPackage(packages, identifier);
+        if (!pkg) {
+            throw new ValidationError(`Unknown package "${identifier}".`);
+        }
+        return pkg.name;
+    });
+}
+/**
+ * Find the packages with files changed between the merge base of a ref and
+ * HEAD, or the working tree.
+ *
+ * @param repository  Repository the packages are in.
+ * @param packages    Discovered packages.
+ * @param since       Base ref, like origin/main.
+ * @param uncommitted Whether to include uncommitted and untracked files.
  * @return Changed packages and their changed files.
  */
-export async function getChangedPackages(repository, packages, since) {
-    const changedFiles = await repository.getChangedFiles(since);
+export async function getChangedPackages(repository, packages, since, uncommitted = false) {
+    const changedFiles = await repository.getChangedFiles(since, {
+        uncommitted,
+    });
     const filesByPackage = {};
     const changed = packages.filter((pkg) => {
         const packageFromRepo = repository.relativePath(pkg.directory);
@@ -172,7 +231,7 @@ async function packageName(directory, relativePath, idFrom) {
     return name;
 }
 function packageType(group) {
-    const kind = group.version.from.kind;
+    const kind = group.version?.from.kind;
     if ('wordpress-plugin-header' === kind) {
         return 'plugin';
     }

package/dist/changeset-prompt.d.ts

@@ -0,0 +1,119 @@
+import type { ChangesetPackage, ChangesetPackages } from './changesets.ts';
+import type { OutputStream } from './logger.ts';
+/** Terminal that the prompts read answers from and write questions to. */
+export interface PromptTerminal {
+    input: NodeJS.ReadableStream;
+    output: OutputStream;
+}
+/** Packages to choose from, and the changed ones that are preselected. */
+export interface ChangesetPromptInput {
+    /** Configured packages. */
+    packages: ChangesetPackage[];
+    /** Identifiers of the changed packages without a changeset. */
+    changed: string[];
+    /** Base ref that the changed packages were compared with. */
+    since?: string;
+    /** Release note to use instead of asking for one. */
+    summary?: string;
+}
+/** Answers of the prompts: no packages for an empty changeset. */
+export interface ChangesetPromptAnswers {
+    packages: ChangesetPackages;
+    summary: string;
+}
+/**
+ * Ask for the packages, bumps and release note of a changeset, line by line,
+ * so that it works in any terminal and with piped input.
+ */
+export declare class ChangesetPrompt {
+    readonly terminal: PromptTerminal;
+    private lines;
+    private readline;
+    /**
+     * @param terminal Input to read answers from and output for the questions.
+     */
+    constructor(terminal: PromptTerminal);
+    /**
+     * Ask for the changeset, preselecting the changed packages.
+     *
+     * @param  input Packages, changed packages and an optional release note.
+     * @return Package bumps, empty for no release, and the release note.
+     * @throws {ValidationError} If the input ends before the changeset is complete.
+     */
+    ask(input: ChangesetPromptInput): Promise<ChangesetPromptAnswers>;
+    /**
+     * Stop reading the input, so that the process can exit.
+     */
+    close(): void;
+    /**
+     * Print the numbered packages, marking the changed ones.
+     *
+     * @param input Packages and changed packages.
+     */
+    private listPackages;
+    /**
+     * Get the package question, with the changed packages as the default.
+     *
+     * @param input Packages and changed packages.
+     * @return Question text.
+     */
+    private getPackagesQuestion;
+    /**
+     * Parse the chosen packages.
+     *
+     * @param  answer Comma or space separated numbers, identifiers or paths.
+     * @param  input  Packages and changed packages.
+     * @return Package identifiers, empty for no release.
+     * @throws {ValidationError} For unknown, repeated or missing packages.
+     */
+    private parsePackages;
+    /**
+     * Parse one chosen package.
+     *
+     * @param  token    Package number, identifier or path.
+     * @param  packages Configured packages.
+     * @return Package identifier.
+     * @throws {ValidationError} For an unknown package.
+     */
+    private parsePackage;
+    /**
+     * Parse a bump, patch by default.
+     *
+     * @param  answer Bump name.
+     * @return Bump.
+     * @throws {ValidationError} For an unknown bump.
+     */
+    private parseBump;
+    /**
+     * Parse a release note.
+     *
+     * @param  answer Release note.
+     * @return Trimmed release note.
+     * @throws {ValidationError} For an empty release note.
+     */
+    private parseSummary;
+    /**
+     * Ask a question until the answer parses, printing why it didn't.
+     *
+     * @param question Question text.
+     * @param parse    Parser that throws a ValidationError for invalid answers.
+     * @return Parsed answer.
+     */
+    private askUntilValid;
+    /**
+     * Write a question and read the next line of the input.
+     *
+     * @param  question Question text.
+     * @return Answer line.
+     * @throws {ValidationError} If the input ended.
+     */
+    private readAnswer;
+    /**
+     * Get the lines of the input, reading it from the first question on. The
+     * interface stays in line mode, so the terminal echoes and edits the
+     * answers and Ctrl+C ends the process.
+     *
+     * @return Line iterator.
+     */
+    private getLines;
+}

package/dist/changeset-prompt.js

@@ -0,0 +1,203 @@
+import { createInterface } from 'node:readline';
+import { findPackage } from "./changeset-packages.js";
+import { CHANGESET_BUMPS } from "./changesets.js";
+import { ValidationError } from "./errors.js";
+/**
+ * Ask for the packages, bumps and release note of a changeset, line by line,
+ * so that it works in any terminal and with piped input.
+ */
+export class ChangesetPrompt {
+    terminal;
+    lines;
+    readline;
+    /**
+     * @param terminal Input to read answers from and output for the questions.
+     */
+    constructor(terminal) {
+        this.terminal = terminal;
+    }
+    /**
+     * Ask for the changeset, preselecting the changed packages.
+     *
+     * @param  input Packages, changed packages and an optional release note.
+     * @return Package bumps, empty for no release, and the release note.
+     * @throws {ValidationError} If the input ends before the changeset is complete.
+     */
+    async ask(input) {
+        this.listPackages(input);
+        const names = await this.askUntilValid(this.getPackagesQuestion(input), (answer) => this.parsePackages(answer, input));
+        const packages = {};
+        for (const name of names) {
+            packages[name] = await this.askUntilValid(`Bump for ${name} (patch, minor or major) [patch]: `, (answer) => this.parseBump(answer));
+        }
+        const summary = input.summary ??
+            (names.length
+                ? await this.askUntilValid('Release note: ', (answer) => this.parseSummary(answer))
+                : '');
+        return { packages, summary };
+    }
+    /**
+     * Stop reading the input, so that the process can exit.
+     */
+    close() {
+        this.readline?.close();
+    }
+    /**
+     * Print the numbered packages, marking the changed ones.
+     *
+     * @param input Packages and changed packages.
+     */
+    listPackages(input) {
+        const width = String(input.packages.length).length;
+        const rows = input.packages.map((pkg, index) => {
+            const marker = input.changed.includes(pkg.name) ? '*' : ' ';
+            const label = pkg.name === pkg.path
+                ? pkg.name
+                : `${pkg.name} (${pkg.path})`;
+            return `  ${String(index + 1).padStart(width)} ${marker} ${label}`;
+        });
+        const legend = input.changed.length
+            ? `* changed${input.since ? ` since ${input.since}` : ''} without a changeset`
+            : 'No changed packages without a changeset.';
+        this.terminal.output.write(`Packages:\n${rows.join('\n')}\n${legend}\n`);
+    }
+    /**
+     * Get the package question, with the changed packages as the default.
+     *
+     * @param input Packages and changed packages.
+     * @return Question text.
+     */
+    getPackagesQuestion(input) {
+        const defaults = input.changed.length
+            ? ` [${input.changed.join(', ')}]`
+            : '';
+        return `Packages to release, by number, identifier or path, comma-separated, or "none" for no release${defaults}: `;
+    }
+    /**
+     * Parse the chosen packages.
+     *
+     * @param  answer Comma or space separated numbers, identifiers or paths.
+     * @param  input  Packages and changed packages.
+     * @return Package identifiers, empty for no release.
+     * @throws {ValidationError} For unknown, repeated or missing packages.
+     */
+    parsePackages(answer, input) {
+        const tokens = answer.split(/[\s,]+/).filter(Boolean);
+        let names = input.changed;
+        if (1 === tokens.length && 'none' === tokens[0]) {
+            names = [];
+        }
+        else if (tokens.length) {
+            names = tokens.map((token) => this.parsePackage(token, input.packages));
+        }
+        else if (!names.length) {
+            throw new ValidationError('Choose at least one package, or "none" for no release.');
+        }
+        const repeated = names.find((name, index) => names.indexOf(name) !== index);
+        if (repeated) {
+            throw new ValidationError(`Package "${repeated}" was chosen more than once.`);
+        }
+        return names;
+    }
+    /**
+     * Parse one chosen package.
+     *
+     * @param  token    Package number, identifier or path.
+     * @param  packages Configured packages.
+     * @return Package identifier.
+     * @throws {ValidationError} For an unknown package.
+     */
+    parsePackage(token, packages) {
+        const pkg = /^\d+$/.test(token)
+            ? packages[Number(token) - 1]
+            : findPackage(packages, token);
+        if (!pkg) {
+            throw new ValidationError(`Unknown package "${token}".`);
+        }
+        return pkg.name;
+    }
+    /**
+     * Parse a bump, patch by default.
+     *
+     * @param  answer Bump name.
+     * @return Bump.
+     * @throws {ValidationError} For an unknown bump.
+     */
+    parseBump(answer) {
+        const bump = answer.trim().toLowerCase() || 'patch';
+        if (!CHANGESET_BUMPS.includes(bump)) {
+            throw new ValidationError(`Invalid bump "${bump}"; expected patch, minor or major.`);
+        }
+        return bump;
+    }
+    /**
+     * Parse a release note.
+     *
+     * @param  answer Release note.
+     * @return Trimmed release note.
+     * @throws {ValidationError} For an empty release note.
+     */
+    parseSummary(answer) {
+        const summary = answer.trim();
+        if (!summary) {
+            throw new ValidationError('The release note must not be empty.');
+        }
+        return summary;
+    }
+    /**
+     * Ask a question until the answer parses, printing why it didn't.
+     *
+     * @param question Question text.
+     * @param parse    Parser that throws a ValidationError for invalid answers.
+     * @return Parsed answer.
+     */
+    async askUntilValid(question, parse) {
+        let parsed;
+        while (undefined === parsed) {
+            const answer = await this.readAnswer(question);
+            try {
+                parsed = { answer: parse(answer) };
+            }
+            catch (error) {
+                if (!(error instanceof ValidationError)) {
+                    throw error;
+                }
+                this.terminal.output.write(`${error.message}\n`);
+            }
+        }
+        return parsed.answer;
+    }
+    /**
+     * Write a question and read the next line of the input.
+     *
+     * @param  question Question text.
+     * @return Answer line.
+     * @throws {ValidationError} If the input ended.
+     */
+    async readAnswer(question) {
+        this.terminal.output.write(question);
+        const line = await this.getLines().next();
+        if (line.done) {
+            throw new ValidationError('The input ended before the changeset was complete.');
+        }
+        return line.value;
+    }
+    /**
+     * Get the lines of the input, reading it from the first question on. The
+     * interface stays in line mode, so the terminal echoes and edits the
+     * answers and Ctrl+C ends the process.
+     *
+     * @return Line iterator.
+     */
+    getLines() {
+        if (!this.lines) {
+            this.readline = createInterface({
+                input: this.terminal.input,
+                terminal: false,
+                crlfDelay: Infinity,
+            });
+            this.lines = this.readline[Symbol.asyncIterator]();
+        }
+        return this.lines;
+    }
+}

package/dist/changeset-release.d.ts

@@ -10,7 +10,7 @@ export interface ChangesetReleaseOptions extends ChangesetRepository {
     git?: GitRunner;
 }
 export interface ChangesetAddOptions {
-    /** Bump of each package. */
+    /** Bump of each package, by package identifier or path under the configured root. */
     packages: Record<string, ChangesetBump>;
     /** Changelog summary. */
     summary: string;
@@ -20,10 +20,22 @@ export interface ChangesetAddOptions {
 export interface ChangesetVersionOptions {
     dryRun?: boolean;
     date?: string;
-    /** Version only these packages, leaving the other changesets pending. */
+    /** Version only these packages, by identifier or path under the configured root, leaving the other changesets pending. */
     packages?: string[];
     /** Whether the selected sources release their configured dependents; defaults to true. */
     dependents?: boolean;
+    /**
+     * Release pre-releases of the next versions, with this identifier and an
+     * optional number, like rc or rc.1, numbered from the package tags without one.
+     */
+    prerelease?: string;
+    /**
+     * Release snapshots of the next versions, like 1.3.0-pr-251.20261012183000,
+     * with this identifier and the UTC time, for test builds that aren't committed.
+     */
+    snapshot?: string;
+    /** Time of a snapshot, now by default. */
+    snapshotTime?: Date;
 }
 export type ChangesetVersionInput = ChangesetRepository & ChangesetVersionOptions;
 /** Versioned releases, the applied changesets and whether files were changed. */
@@ -38,7 +50,7 @@ export interface ChangesetTagOptions {
     untagged?: boolean;
     push?: boolean;
     since?: string;
-    /** Tag only these packages. */
+    /** Tag only these packages, by identifier or path under the configured root. */
     packages?: string[];
     /** Expected version of the single package in `packages`. */
     version?: string;
@@ -61,8 +73,12 @@ export interface ChangesetTagResult {
 export interface ChangesetStatusOptions {
     /** Base ref to diff against, origin/<baseBranch> by default. */
     since?: string;
+    /** Whether to include uncommitted and untracked files, like before adding a changeset. */
+    uncommitted?: boolean;
 }
 export interface ChangesetStatusResult {
+    /** Base ref that the changed files were compared with, if any. */
+    since?: string;
     changesets: Changeset[];
     releases: PackageRelease[];
     changedPackages: string[];
@@ -135,6 +151,25 @@ export declare class ChangesetRelease {
      * @throws {ValidationError} Without a config.
      */
     getStatus(options?: ChangesetStatusOptions): Promise<ChangesetStatusResult>;
+    /**
+     * 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.
+     */
+    private toPrereleases;
+    /**
+     * List the versions of the tags with a prefix.
+     *
+     * @param prefix Tag prefix of a package, like `plugins/alpha/`.
+     * @return Tagged versions.
+     */
+    private listTaggedVersions;
     /**
      * Write the versions, dependency specs and changelogs of the releases and
      * consume the applied changesets, restoring every changed file when a