@wpelevator/wp-release 0.12.0 → 0.13.0

package/dist/commands/package-deploys.js

@@ -0,0 +1,108 @@
+import { ValidationError } from "../errors.js";
+import { getDeployPlan } from "../package-deploy.js";
+import { logError } from "../report.js";
+import { getBoolean, getString, getStrings } from "./command.js";
+/**
+ * Options of the deploy commands that deploy the configured packages of a
+ * ref, in node:util parseArgs() format.
+ */
+export const packageDeployArgs = {
+    'release-ref': { type: 'string' },
+    package: { type: 'string', multiple: true },
+    list: { type: 'boolean' },
+};
+/**
+ * Get the ref and the packages to deploy from the config, failing for the
+ * options that set a single deploy target instead.
+ *
+ * @param  values      Parsed CLI values.
+ * @param  positionals Positional arguments.
+ * @param  targetFlags Options of a single deploy target.
+ * @return The ref and the selected packages.
+ * @throws {ValidationError} For --package without --release-ref, or a single target option with it.
+ */
+export function getPackageDeployArgs(values, positionals, targetFlags) {
+    const ref = getString(values, 'release-ref')?.trim();
+    const packages = getStrings(values, 'package');
+    const list = getBoolean(values, 'list');
+    const conflicts = targetFlags.filter((flag) => undefined !== getString(values, flag) ||
+        getBoolean(values, flag) ||
+        getStrings(values, flag).length);
+    if ('' === ref) {
+        throw new ValidationError('--release-ref <ref> must not be empty.');
+    }
+    if ((packages.length || list) && !ref) {
+        throw new ValidationError(`${list ? '--list' : '--package'} requires --release-ref <ref>.`);
+    }
+    if (ref && (positionals.length || conflicts.length)) {
+        throw new ValidationError(`--release-ref deploys the configured packages and targets, so it can't be combined with ${positionals.length
+            ? 'a source directory'
+            : conflicts.map((flag) => `--${flag}`).join(', ')}.`);
+    }
+    return { ...(ref ? { ref } : {}), packages, list };
+}
+/**
+ * Run the deploys of the configured packages one at a time, in one log group
+ * for each package, continuing after a failed deploy so that one package or
+ * target doesn't block the others.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param deploy  Runs one deploy.
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 1 when a deploy failed, and the result of each deploy.
+ */
+export async function runPackageDeploys(deploys, deploy, logger, ref) {
+    const outcomes = [];
+    const names = [
+        ...new Set(deploys.map((item) => item.package.name)),
+    ];
+    if (!deploys.length) {
+        logger.info(`No configured package deploys ${ref}.`);
+    }
+    for (const name of names) {
+        const items = deploys.filter((item) => item.package.name === name);
+        const release = items[0]?.release ?? {};
+        await logger.group(`${name} ${release.version ?? release.branch ?? ''}`.trim(), async () => {
+            for (const item of items) {
+                outcomes.push(await runDeploy(item, deploy, logger));
+            }
+        });
+    }
+    return {
+        exitCode: outcomes.some((outcome) => outcome.error) ? 1 : 0,
+        result: { deploys: outcomes },
+    };
+}
+async function runDeploy(item, deploy, logger) {
+    const outcome = {
+        package: item.package.name,
+        label: item.label,
+        ...item.release,
+    };
+    try {
+        outcome.result = await deploy(item.input);
+    }
+    catch (error) {
+        outcome.error =
+            error instanceof Error ? error.message : String(error);
+        logError(logger, error, `Deploy of ${item.label}`);
+    }
+    return outcome;
+}
+/**
+ * List the deploys of the configured packages without running them, one line
+ * for each deploy, with the plan as the result for --json and --github-output.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @param logger  Logger.
+ * @param ref     Deployed ref, for the log.
+ * @return Exit code 0 and the deploys of each package.
+ */
+export function listPackageDeploys(deploys, logger, ref) {
+    if (!deploys.length) {
+        logger.info(`No configured package deploys ${ref}.`);
+    }
+    deploys.forEach((item) => logger.info(item.label));
+    return { exitCode: 0, result: { packages: getDeployPlan(deploys) } };
+}

package/dist/git-deploy.d.ts

@@ -28,6 +28,13 @@ export interface GitDeployInput {
     excludeGitattributes?: boolean;
     /** Commit message of the release. */
     message?: string;
+    /**
+     * Token for an HTTPS repository on the GitHub host, sent as an
+     * authorization header instead of in the URL. Defaults to GITHUB_TOKEN for
+     * a URL on github.com, or on the host of GITHUB_SERVER_URL, without
+     * credentials of its own.
+     */
+    token?: string;
     /** Run everything except the push. */
     dryRun?: boolean;
 }
@@ -43,6 +50,8 @@ export interface GitDeployOptions extends FileSelection {
     splitPrefix: string | null;
     sourceRef: string;
     message: string | null;
+    /** Token sent as an authorization header to the repository. */
+    token: string | null;
     dryRun: boolean;
 }
 export interface GitDeployResult {
@@ -70,6 +79,29 @@ export interface GitDeployResult {
  * @return Whether the name can be used.
  */
 export declare function isValidRefName(name: string): boolean;
+/**
+ * Get GITHUB_TOKEN for an HTTPS repository URL on the GitHub host, like
+ * https://github.com/owner/repo.git, unless the URL has credentials.
+ *
+ * @param gitUrl Repository URL.
+ * @param env    Environment variables.
+ * @return The token, or undefined for another URL or without one.
+ */
+export declare function getDefaultToken(gitUrl: string, env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Get the environment variables that make git send a token as the
+ * authorization header to a repository, like actions/checkout, so that the
+ * token stays out of the URL, the arguments and the repository config. An
+ * empty header first resets the headers that git is configured with, like
+ * the one that actions/checkout persists, since a second authorization
+ * header would fail.
+ *
+ * @param gitUrl Repository URL.
+ * @param token  Token, or null for none.
+ * @param env    Environment variables, for the existing GIT_CONFIG_COUNT.
+ * @return Environment variables for git.
+ */
+export declare function getGitAuthEnv(gitUrl: string, token: string | null, env?: NodeJS.ProcessEnv): Record<string, string>;
 /**
  * Apply the defaults to the Git deploy options and validate them.
  *

package/dist/git-deploy.js

@@ -18,6 +18,54 @@ export function isValidRefName(name) {
     return (/^[^\s~^:?*[\\]+$/.test(name) &&
         !/(^[-/.]|\/\.|\.\.|\/\/|@\{|\.lock$|[/.]$)/.test(name));
 }
+/**
+ * Get GITHUB_TOKEN for an HTTPS repository URL on the GitHub host, like
+ * https://github.com/owner/repo.git, unless the URL has credentials.
+ *
+ * @param gitUrl Repository URL.
+ * @param env    Environment variables.
+ * @return The token, or undefined for another URL or without one.
+ */
+export function getDefaultToken(gitUrl, env = process.env) {
+    const url = URL.canParse(gitUrl) ? new URL(gitUrl) : undefined;
+    const hosts = [
+        'github.com',
+        URL.canParse(env.GITHUB_SERVER_URL ?? '')
+            ? new URL(env.GITHUB_SERVER_URL ?? '').host
+            : '',
+    ];
+    const isGitHub = 'https:' === url?.protocol &&
+        !url.username &&
+        hosts.includes(url.host);
+    return isGitHub ? env.GITHUB_TOKEN || undefined : undefined;
+}
+/**
+ * Get the environment variables that make git send a token as the
+ * authorization header to a repository, like actions/checkout, so that the
+ * token stays out of the URL, the arguments and the repository config. An
+ * empty header first resets the headers that git is configured with, like
+ * the one that actions/checkout persists, since a second authorization
+ * header would fail.
+ *
+ * @param gitUrl Repository URL.
+ * @param token  Token, or null for none.
+ * @param env    Environment variables, for the existing GIT_CONFIG_COUNT.
+ * @return Environment variables for git.
+ */
+export function getGitAuthEnv(gitUrl, token, env = process.env) {
+    const count = Number(env.GIT_CONFIG_COUNT) || 0;
+    const key = token ? `http.${new URL(gitUrl).origin}/.extraheader` : '';
+    const credentials = Buffer.from(`x-access-token:${token}`).toString('base64');
+    return token
+        ? {
+            GIT_CONFIG_COUNT: String(count + 2),
+            [`GIT_CONFIG_KEY_${count}`]: key,
+            [`GIT_CONFIG_VALUE_${count}`]: '',
+            [`GIT_CONFIG_KEY_${count + 1}`]: key,
+            [`GIT_CONFIG_VALUE_${count + 1}`]: `AUTHORIZATION: basic ${credentials}`,
+        }
+        : {};
+}
 /**
  * Apply the defaults to the Git deploy options and validate them.
  *
@@ -49,6 +97,7 @@ export function resolveGitDeployOptions(input = {}) {
         splitPrefix: input.splitPrefix || null,
         sourceRef: input.sourceRef || 'HEAD',
         message: input.message || null,
+        token: input.token || getDefaultToken(input.gitUrl) || null,
         dryRun: Boolean(input.dryRun),
         ...resolveFileSelection({
             cwd,
@@ -415,7 +464,14 @@ export class GitDeploy {
     async git(input) {
         const cwd = await this.getRepoRoot();
         this.logger.debug(redactUrls(`git ${input.args.join(' ')}`));
-        const { stdout } = await this.runner({ ...input, cwd });
+        const { stdout } = await this.runner({
+            ...input,
+            cwd,
+            env: {
+                ...getGitAuthEnv(this.options.gitUrl, this.options.token),
+                ...input.env,
+            },
+        });
         return stdout.trim();
     }
 }

package/dist/index.d.ts

@@ -21,8 +21,11 @@ export { Svn, SvnError, createSvnRunner, parseStatus, toSvnPath, } from './svn.t
 export { syncDirectory, copyFileIfChanged } from './sync.ts';
 export { ASSET_MIME_TYPES, SvnDeploy } from './svn-deploy.ts';
 export { GitError, createGitRunner, redactUrls } from './git.ts';
-export { GitDeploy, isValidRefName, resolveGitDeployOptions, } from './git-deploy.ts';
+export { GitDeploy, getDefaultToken, getGitAuthEnv, isValidRefName, resolveGitDeployOptions, } from './git-deploy.ts';
 export { getGitDeployInputFromArgs } from './commands/deploy-git.ts';
+export { getDeployPackages, getGitDeploys, getSvnDeploys, } from './package-deploy.ts';
+export type { PackageDeploy, PackageDeployFiles, PackageDeployOptions, PackageFileSelection, PackageDeployPlanItem, PackageDeployRelease, } from './package-deploy.ts';
+export type { PackageDeployOutcome } from './commands/package-deploys.ts';
 export type { CliIo, CommandResults } from './cli.ts';
 export type { ChecksumsResult } from './commands/checksums.ts';
 export type { SignResult } from './commands/sign.ts';
@@ -43,7 +46,7 @@ export type { ExtractZipInput, ZipEntryInfo, ZipEntryType } from './unzip.ts';
 export type { FindVersionMismatchesInput, GitTagInput, VersionCheckResult, VersionMismatch, } from './version-check.ts';
 export type { Changeset, ChangesetBump, ChangesetPackages, ChangesetConfig, ChangesetPackageType, ChangesetPackage, PackageRelease, VersionedRelease, ChangesetReleasePlan, } from './changesets.ts';
 export type { ChangesetRepository, ChangesetReleaseOptions, ChangesetAddOptions, ChangesetVersionOptions, ChangesetTagOptions, ChangesetStatusOptions, ChangesetStatusResult, ChangesetVersionInput, VersionChangesetsResult, ChangesetTagInput, ChangesetTagResult, } from './changeset-release.ts';
-export type { WpReleaseConfig, ChangesetPackageGroup, PackageVersionConfig, PackageVersionSource, PackageVersionTarget, PackageIdSource, NextVersionInput, ReleaseCommit, ReleaseNotesInput, ChangelogEntryInput, DependentsChangelogInput, DependentsConfig, PackageJsonVersionOptions, ComposerJsonVersionOptions, WordPressVersionFileOptions, GitTagVersionOptions, PhpConstantVersionOptions, LoadChangesetConfigInput, } from './changeset-config.ts';
+export type { WpReleaseConfig, ChangesetPackageGroup, PackageFilesConfig, PackageDeployConfig, GitDeployTarget, SvnDeployTarget, DeployTemplate, DeployTargetInput, DeployPackage, PackageVersionConfig, PackageVersionSource, PackageVersionTarget, PackageIdSource, NextVersionInput, ReleaseCommit, ReleaseNotesInput, ChangelogEntryInput, DependentsChangelogInput, DependentsConfig, PackageJsonVersionOptions, ComposerJsonVersionOptions, WordPressVersionFileOptions, GitTagVersionOptions, PhpConstantVersionOptions, LoadChangesetConfigInput, } from './changeset-config.ts';
 export type { SvnCheckoutInput, SvnCommandInput, SvnCommandOutput, SvnCommitInput, SvnCopyInput, SvnDepth, SvnOptions, SvnPathsInput, SvnPropsetInput, SvnRunner, SvnStatusEntry, SvnStatusType, SvnUpdateInput, } from './svn.ts';
 export type { SyncDirectoryInput, SyncResult } from './sync.ts';
 export type { SummaryContext } from './summary.ts';

package/dist/index.js

@@ -21,5 +21,6 @@ export { Svn, SvnError, createSvnRunner, parseStatus, toSvnPath, } from "./svn.j
 export { syncDirectory, copyFileIfChanged } from "./sync.js";
 export { ASSET_MIME_TYPES, SvnDeploy } from "./svn-deploy.js";
 export { GitError, createGitRunner, redactUrls } from "./git.js";
-export { GitDeploy, isValidRefName, resolveGitDeployOptions, } from "./git-deploy.js";
+export { GitDeploy, getDefaultToken, getGitAuthEnv, isValidRefName, resolveGitDeployOptions, } from "./git-deploy.js";
 export { getGitDeployInputFromArgs } from "./commands/deploy-git.js";
+export { getDeployPackages, getGitDeploys, getSvnDeploys, } from "./package-deploy.js";

package/dist/package-deploy.d.ts

@@ -0,0 +1,105 @@
+import type { DeployPackage } from './changeset-config.ts';
+import type { DeployInput } from './deploy-options.ts';
+import type { GitDeployInput } from './git-deploy.ts';
+import type { GitRunner } from './git.ts';
+export interface PackageDeployOptions {
+    /** Repository root with the wp-release config. */
+    cwd: string;
+    /** Config file, instead of the conventional one at the root. */
+    configFile?: string;
+    /**
+     * Ref to deploy: a package release tag, like refs/tags/plugins/alpha/1.2.0,
+     * or a branch, like refs/heads/main. A name without refs/ is a release tag
+     * when it matches the tag format of a package, otherwise a branch.
+     */
+    ref: string;
+    /** Deploy only these packages, by identifier or path under the root. */
+    packages?: string[];
+    /** Run everything except the writes. */
+    dryRun?: boolean;
+    /** Git runner, spawning git by default. */
+    git?: GitRunner;
+}
+/** The release of a package that a ref deploys. */
+export interface PackageDeployRelease {
+    /** Released version, for a release tag. */
+    version?: string;
+    /** Deployed branch, for a branch. */
+    branch?: string;
+}
+/** One deploy of a package to one of its targets. */
+export interface PackageDeploy<Input> {
+    package: DeployPackage;
+    release: PackageDeployRelease;
+    /** Repository or WordPress.org plugin of the target, with credentials redacted. */
+    target: string;
+    /** Tag or branch that the deploy writes in the target. */
+    targetRef: string;
+    /** Package, target and ref, with credentials redacted, for logs. */
+    label: string;
+    /** Options of the deploy. */
+    input: Input;
+}
+/**
+ * Get the Git deploys of the configured packages that a ref releases: every
+ * Git target of the package of a release tag that releases tags, or of every
+ * package with a Git target that releases the branch.
+ *
+ * @param  options Repository, ref and package selection.
+ * @return Deploys in the configured package and target order.
+ * @throws {ValidationError} Without a config, or for an invalid one or an unknown package.
+ */
+export declare function getGitDeploys(options: PackageDeployOptions): Promise<PackageDeploy<GitDeployInput>[]>;
+/**
+ * Get the WordPress.org SVN deploys of the configured package that a release
+ * tag releases. A stable release syncs trunk/, the tag and the assets, and a
+ * pre-release only creates its tag. Branches aren't deployed to SVN.
+ *
+ * @param  options Repository, ref and package selection.
+ * @return Deploys in the configured target order.
+ * @throws {ValidationError} Without a config, or for an invalid one or an unknown package.
+ */
+export declare function getSvnDeploys(options: PackageDeployOptions): Promise<PackageDeploy<DeployInput>[]>;
+/** A package with deploy targets and the files that its deploys ship. */
+export interface PackageDeployFiles extends DeployPackage {
+    /** File selection of the package, for resolveFileSelection(). */
+    files: PackageFileSelection;
+}
+/**
+ * Get the packages with deploy targets and the files that their deploys
+ * ship, for example to build a ZIP with the same files.
+ *
+ * @param  options            Repository root and config file.
+ * @param  options.cwd        Repository root with the wp-release config.
+ * @param  options.configFile Config file, instead of the conventional one at the root.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} Without a config, or for an invalid one.
+ */
+export declare function getDeployPackages(options: {
+    cwd: string;
+    configFile?: string;
+}): Promise<PackageDeployFiles[]>;
+/** Ignore file and patterns that select the files of a package. */
+export interface PackageFileSelection {
+    /** Absolute ignore file path, or false to not read one. */
+    distignore?: string | false;
+    /** Gitignore-style patterns relative to the package directory. */
+    exclude?: string[];
+}
+/** The deploys of one package in a deploy plan. */
+export interface PackageDeployPlanItem extends PackageDeployRelease {
+    package: string;
+    /** Targets with the tag or branch that each deploy writes. */
+    targets: Array<{
+        target: string;
+        ref: string;
+    }>;
+}
+/**
+ * Group deploys by package, for a preview of what a ref deploys or a CI
+ * matrix with a job for each package.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @return One item for each package, in the deploy order.
+ */
+export declare function getDeployPlan(deploys: PackageDeploy<unknown>[]): PackageDeployPlanItem[];

package/dist/package-deploy.js

@@ -0,0 +1,288 @@
+import { realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { loadChangesetConfig, toTargetList } from "./changeset-config.js";
+import { discoverDeployPackages, findPackage } from "./changeset-packages.js";
+import { ValidationError } from "./errors.js";
+import { redactUrls } from "./git.js";
+import { ReleaseRepository } from "./release-repository.js";
+import { formatTag } from "./tag-format.js";
+import { isPrerelease, isVersion } from "./versions.js";
+/**
+ * Get the Git deploys of the configured packages that a ref releases: every
+ * Git target of the package of a release tag that releases tags, or of every
+ * package with a Git target that releases the branch.
+ *
+ * @param  options Repository, ref and package selection.
+ * @return Deploys in the configured package and target order.
+ * @throws {ValidationError} Without a config, or for an invalid one or an unknown package.
+ */
+export async function getGitDeploys(options) {
+    const { config, releases, root } = await loadDeployContext(options);
+    const deploys = await Promise.all(releases.map(async (release) => {
+        const targets = toTargetList(release.package.group.deploy?.git);
+        const resolved = await Promise.all(targets
+            .filter((target) => isGitTargetReleased(target, release))
+            .map((target) => getGitDeploy(target, release, config, root, options)));
+        return resolved.filter((deploy) => undefined !== deploy);
+    }));
+    return deploys.flat();
+}
+/**
+ * Get the WordPress.org SVN deploys of the configured package that a release
+ * tag releases. A stable release syncs trunk/, the tag and the assets, and a
+ * pre-release only creates its tag. Branches aren't deployed to SVN.
+ *
+ * @param  options Repository, ref and package selection.
+ * @return Deploys in the configured target order.
+ * @throws {ValidationError} Without a config, or for an invalid one or an unknown package.
+ */
+export async function getSvnDeploys(options) {
+    const { config, releases } = await loadDeployContext(options);
+    const deploys = await Promise.all(releases
+        .filter((release) => release.version)
+        .map(async (release) => {
+        const targets = toTargetList(release.package.group.deploy?.svn);
+        const resolved = await Promise.all(targets.map((target) => getSvnDeploy(target, release, config, options)));
+        return resolved.filter((deploy) => undefined !== deploy);
+    }));
+    return deploys.flat();
+}
+/**
+ * Get the packages with deploy targets and the files that their deploys
+ * ship, for example to build a ZIP with the same files.
+ *
+ * @param  options            Repository root and config file.
+ * @param  options.cwd        Repository root with the wp-release config.
+ * @param  options.configFile Config file, instead of the conventional one at the root.
+ * @return Packages in the configured order.
+ * @throws {ValidationError} Without a config, or for an invalid one.
+ */
+export async function getDeployPackages(options) {
+    const config = await requireConfig(options);
+    const packages = await discoverDeployPackages(new ReleaseRepository({ cwd: options.cwd }), config);
+    return packages.map((pkg) => ({
+        ...toDeployPackage(pkg),
+        files: getFileSelection(pkg, config),
+    }));
+}
+async function requireConfig(options) {
+    const loaded = await loadChangesetConfig({
+        cwd: options.cwd,
+        ...(options.configFile ? { configFile: options.configFile } : {}),
+    });
+    if (!loaded) {
+        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
+    }
+    return loaded.config;
+}
+async function loadDeployContext(options) {
+    const config = await requireConfig(options);
+    const repository = new ReleaseRepository({
+        cwd: options.cwd,
+        runner: options.git,
+    });
+    const packages = selectPackages(await discoverDeployPackages(repository, config), options.packages ?? []);
+    const root = await repository.run(['rev-parse', '--show-toplevel']);
+    const revision = await repository.run(['rev-parse', 'HEAD^{commit}']);
+    return {
+        config,
+        releases: getReleases(packages, config, options.ref).map((release) => ({ ...release, revision: revision.trim() })),
+        root: root.trim(),
+    };
+}
+function selectPackages(packages, identifiers) {
+    const selected = identifiers.map((identifier) => {
+        const pkg = findPackage(packages, identifier);
+        if (!pkg) {
+            throw new ValidationError(`Unknown package "${identifier}", or it has no deploy targets.`);
+        }
+        return pkg;
+    });
+    return identifiers.length
+        ? packages.filter((pkg) => selected.includes(pkg))
+        : packages;
+}
+/**
+ * Resolve the releases of a ref: the package of a release tag, or every
+ * package for a branch.
+ *
+ * @param packages Packages with deploy targets.
+ * @param config   Repository release configuration.
+ * @param ref      Ref to deploy.
+ * @return Releases.
+ */
+function getReleases(packages, config, ref) {
+    const tagFormat = config.tagFormat ?? '{path}/{version}';
+    const tag = ref.startsWith('refs/tags/')
+        ? ref.slice('refs/tags/'.length)
+        : ref;
+    const tagged = ref.startsWith('refs/heads/')
+        ? []
+        : packages.flatMap((pkg) => getTaggedVersion(pkg, tagFormat, tag));
+    const branch = ref.replace(/^refs\/heads\//, '');
+    return ref.startsWith('refs/tags/') || tagged.length
+        ? tagged
+        : packages.map((pkg) => ({ package: pkg, branch }));
+}
+function getTaggedVersion(pkg, tagFormat, tag) {
+    const prefix = formatTag(tagFormat, pkg, '');
+    const version = tag.startsWith(prefix) ? tag.slice(prefix.length) : '';
+    return pkg.group.version && isVersion(version)
+        ? [{ package: pkg, version }]
+        : [];
+}
+function isGitTargetReleased(target, release) {
+    const branches = target.branches ?? true;
+    const branchReleased = Array.isArray(branches)
+        ? branches.includes(release.branch ?? '')
+        : branches;
+    return release.version ? false !== target.tag : branchReleased;
+}
+async function getGitDeploy(target, release, config, root, options) {
+    const pkg = release.package;
+    const tag = release.version
+        ? formatTag(target.tag || '{version}', pkg, release.version)
+        : undefined;
+    const ref = tag ?? release.branch ?? '';
+    const repository = await resolveTemplate(target.repository, release, ref);
+    const message = target.message
+        ? await resolveTemplate(target.message, release, ref)
+        : '';
+    // Git reports the real path of the root, so compare it with the real path
+    // of the package, like on macOS where the temporary directory is a link.
+    const splitPrefix = false === target.history
+        ? ''
+        : path
+            .relative(root, await realpath(pkg.directory))
+            .split(path.sep)
+            .join('/');
+    return repository
+        ? {
+            package: toDeployPackage(pkg),
+            release: toRelease(release),
+            target: redactUrls(repository),
+            targetRef: ref,
+            label: `${pkg.name} to ${redactUrls(repository)} ${ref}`,
+            input: {
+                cwd: options.cwd,
+                sourceDir: pkg.directory,
+                gitUrl: repository,
+                ...(release.branch ? { branch: release.branch } : {}),
+                ...(tag ? { tag } : {}),
+                ...(splitPrefix ? { splitPrefix } : {}),
+                ...(message ? { message } : {}),
+                ...getFileSelection(pkg, config),
+                dryRun: Boolean(options.dryRun),
+            },
+        }
+        : undefined;
+}
+async function getSvnDeploy(target, release, config, options) {
+    const pkg = release.package;
+    const version = release.version ?? '';
+    const stable = !isPrerelease(version);
+    const slug = await resolveTemplate(target.slug ?? '{slug}', release, version);
+    const message = target.message
+        ? await resolveTemplate(target.message, release, version)
+        : '';
+    return slug
+        ? {
+            package: toDeployPackage(pkg),
+            release: toRelease(release),
+            target: `WordPress.org ${slug}`,
+            targetRef: version,
+            label: `${pkg.name} to WordPress.org ${slug} ${version}`,
+            input: {
+                cwd: options.cwd,
+                sourceDir: pkg.directory,
+                slug,
+                version,
+                svnTag: version,
+                trunk: stable,
+                ...(stable && target.assetsDir
+                    ? {
+                        assetsDir: path.join(pkg.directory, target.assetsDir),
+                    }
+                    : {}),
+                ...(target.readme ? { readme: target.readme } : {}),
+                ...(target.url ? { svnUrl: target.url } : {}),
+                ...(message ? { message } : {}),
+                ...getFileSelection(pkg, config),
+                dryRun: Boolean(options.dryRun),
+            },
+        }
+        : undefined;
+}
+/**
+ * Resolve a template with the package and release placeholders, or call the
+ * callback with the package and its release.
+ *
+ * @param template Template or callback.
+ * @param release  Release of the package.
+ * @param ref      Tag or branch that the deploy writes in the target.
+ * @return Resolved value, empty for a skipped target or the default message.
+ */
+async function resolveTemplate(template, release, ref) {
+    const value = 'function' === typeof template
+        ? await template({
+            package: toDeployPackage(release.package),
+            ...toRelease(release),
+            ref,
+            revision: release.revision,
+        })
+        : formatTag(template, release.package, release.version ?? '')
+            .replaceAll('{branch}', release.branch ?? '')
+            .replaceAll('{ref}', ref)
+            .replaceAll('{revision}', release.revision);
+    return value?.trim() ?? '';
+}
+function getFileSelection(pkg, config) {
+    const shared = config.files ?? {};
+    const files = pkg.group.files ?? {};
+    const setting = undefined === files.distignore ? shared.distignore : files.distignore;
+    const distignore = 'string' === typeof setting
+        ? path.join(pkg.directory, setting)
+        : setting;
+    const exclude = [...(shared.exclude ?? []), ...(files.exclude ?? [])];
+    return {
+        ...(undefined === distignore ? {} : { distignore }),
+        ...(exclude.length ? { exclude } : {}),
+    };
+}
+function toDeployPackage(pkg) {
+    return {
+        name: pkg.name,
+        directory: pkg.directory,
+        path: pkg.path,
+        type: pkg.type,
+    };
+}
+function toRelease(release) {
+    return {
+        ...(release.version ? { version: release.version } : {}),
+        ...(release.branch ? { branch: release.branch } : {}),
+    };
+}
+/**
+ * Group deploys by package, for a preview of what a ref deploys or a CI
+ * matrix with a job for each package.
+ *
+ * @param deploys Deploys from getGitDeploys() or getSvnDeploys().
+ * @return One item for each package, in the deploy order.
+ */
+export function getDeployPlan(deploys) {
+    const names = [
+        ...new Set(deploys.map((item) => item.package.name)),
+    ];
+    return names.map((name) => {
+        const items = deploys.filter((item) => item.package.name === name);
+        return {
+            package: name,
+            ...items[0]?.release,
+            targets: items.map((item) => ({
+                target: item.target,
+                ref: item.targetRef,
+            })),
+        };
+    });
+}