@wpelevator/wp-release 0.0.0-stage → 0.1.1

package/dist/commands/zip.js

@@ -0,0 +1,138 @@
+import { existsSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
+import { CHECKSUMS_EXTENSION, createChecksums, writeChecksums, } from "../checksums.js";
+import { ValidationError } from "../errors.js";
+import { loadFileRules, resolveFileSelection, selectFiles, } from "../file-selection.js";
+import { FILENAME_FORMAT, formatFilename } from "../filename.js";
+import { readPackageMeta } from "../package-meta.js";
+import { createZip } from "../zip.js";
+import { checkDirectory, fileSelectionArgs, getFileSelectionInput, getSourceDirArg, ignoreOwnFile, resolveOutput, sourceDirArgs, } from "./args.js";
+import { getBoolean, getString } from "./command.js";
+const ZIP_EXTENSION = '.zip';
+/**
+ * Get the checksums manifest path next to an archive, with .checksums.json
+ * instead of .zip.
+ *
+ * @param zipPath Archive path.
+ * @return Manifest path.
+ */
+function getChecksumsPath(zipPath) {
+    const name = zipPath.endsWith(ZIP_EXTENSION)
+        ? zipPath.slice(0, -ZIP_EXTENSION.length)
+        : zipPath;
+    return name + CHECKSUMS_EXTENSION;
+}
+/**
+ * Fail before writing anything when an output file exists.
+ *
+ * @param  paths Output paths.
+ * @param  force Whether existing files are overwritten.
+ * @throws {ValidationError} If a file exists and force isn't set.
+ */
+function checkOverwrite(paths, force) {
+    const existing = paths.filter((path) => !force && existsSync(path));
+    if (existing.length) {
+        throw new ValidationError(`${existing.join(' and ')} already exists, pass --force to overwrite it.`);
+    }
+}
+export default {
+    name: 'zip',
+    usage: 'zip [<source-dir>] [options]',
+    summary: 'Create a ZIP archive of a plugin or theme with a {slug}/ root folder.',
+    help: `Arguments:
+  <source-dir>                Directory to archive (default: .), also accepted
+                              as --source-dir <dir>
+
+Options:
+  --output <file>             ZIP file (default: the --filename-format name with
+                              .zip in the current directory)
+  --slug <slug>               Plugin or theme slug (default: project directory name)
+  --version <version>         Version for the filename (default: Version header)
+  --root-folder <name>        Folder inside the ZIP (default: --slug)
+  --no-root-folder            Place files at the ZIP root
+  --filename-format <format>  Filename with {slug} and {version} (default: {slug}.{version})
+  --distignore <file>         Ignore file (default: <source-dir>/.distignore when present)
+  --no-distignore             Don't read any ignore file
+  --exclude <patterns>        Extra gitignore-style patterns, comma-separated or
+                              repeated, like build/,assets/*,images/**/*
+  --checksums                 Also write the checksums manifest of the archived
+                              files next to the ZIP, with .checksums.json
+                              instead of .zip
+  --force                     Overwrite existing output files
+
+Entries are sorted and use a fixed timestamp and file mode, so the same files
+always give the same ZIP.`,
+    options: {
+        slug: { type: 'string' },
+        version: { type: 'string' },
+        'root-folder': { type: 'string' },
+        'no-root-folder': { type: 'boolean' },
+        'filename-format': { type: 'string' },
+        output: { type: 'string' },
+        ...sourceDirArgs,
+        ...fileSelectionArgs,
+        checksums: { type: 'boolean' },
+        force: { type: 'boolean' },
+    },
+    async run({ values, positionals, cwd, logger }) {
+        const sourceDir = resolve(cwd, getSourceDirArg(values, positionals));
+        const slug = getString(values, 'slug') ?? basename(cwd);
+        const force = getBoolean(values, 'force');
+        await checkDirectory(sourceDir);
+        const meta = await readPackageMeta({ dir: sourceDir, slug });
+        const version = getString(values, 'version') ?? meta?.version ?? null;
+        const filename = formatFilename(getString(values, 'filename-format') ?? FILENAME_FORMAT, { slug, version });
+        const zipPath = resolveOutput({
+            cwd,
+            output: getString(values, 'output'),
+            filename: filename + ZIP_EXTENSION,
+        });
+        const checksumsPath = getBoolean(values, 'checksums')
+            ? getChecksumsPath(zipPath)
+            : null;
+        const selection = resolveFileSelection({
+            cwd,
+            sourceDir,
+            ...getFileSelectionInput(values),
+        });
+        const rules = ignoreOwnFile(await loadFileRules(selection), sourceDir, zipPath);
+        if (checksumsPath) {
+            ignoreOwnFile(rules, sourceDir, checksumsPath);
+        }
+        const files = await selectFiles(sourceDir, rules);
+        if (!files.length) {
+            throw new ValidationError(`No files to archive in ${sourceDir}.`);
+        }
+        checkOverwrite([zipPath, checksumsPath ?? ''].filter(Boolean), force);
+        await createZip({
+            sourceDir,
+            files,
+            zipPath,
+            rootFolder: getBoolean(values, 'no-root-folder')
+                ? null
+                : getString(values, 'root-folder') ?? slug,
+            force,
+        });
+        logger.debug(`Archived ${files.length} files from ${sourceDir}.`);
+        logger.info(zipPath);
+        if (checksumsPath) {
+            const manifest = await createChecksums({
+                sourceDir,
+                rules,
+                slug,
+                version,
+                type: meta?.type,
+            });
+            await writeChecksums(checksumsPath, manifest, force);
+            logger.info(checksumsPath);
+        }
+        return {
+            exitCode: 0,
+            result: {
+                zipPath,
+                ...(checksumsPath ? { checksumsPath } : {}),
+                files: files.length,
+            },
+        };
+    },
+};

package/dist/deploy-options.d.ts

@@ -0,0 +1,136 @@
+import type { FileSelection } from './file-selection.ts';
+export declare const SVN_URL = "https://plugins.svn.wordpress.org/{slug}/";
+/**
+ * Deploy options from the CLI, the GitHub Action or a library caller. Unset
+ * options fall back to the defaults in resolveDeployOptions().
+ */
+export interface DeployInput {
+    /** Directory that relative paths resolve against. */
+    cwd?: string;
+    /** Plugin slug, defaults to the cwd directory name. */
+    slug?: string;
+    /** Version to check, defaults to svnTag, then the Version header of the deployed files. */
+    version?: string;
+    /** Sync the full source directory to trunk/. */
+    trunk?: boolean;
+    /** Sync only the readme to trunk/. */
+    readmeOnly?: boolean;
+    /** Copy trunk/ to tags/<svnTag>. */
+    svnTag?: string;
+    /** Sync the assets directory, defaults to on when assetsDir is set. */
+    assets?: boolean;
+    /** Directory with banners, icons and screenshots. */
+    assetsDir?: string;
+    /** Directory with the plugin files, defaults to cwd. */
+    sourceDir?: string;
+    /** Ignore file path, or false to not read one. */
+    distignore?: string | false;
+    /** Extra gitignore-style patterns. */
+    exclude?: string | string[];
+    /** Readme file name. */
+    readme?: string;
+    /** ZIP archive to deploy instead of sourceDir. */
+    fromZip?: string;
+    /** SVN repository URL with a {slug} placeholder. */
+    svnUrl?: string;
+    /** SVN username, defaults to the SVN_USERNAME env var. */
+    svnUsername?: string;
+    /** SVN password, defaults to the SVN_PASSWORD env var. */
+    svnPassword?: string;
+    /** Git ref of the run, like refs/tags/1.2.0. */
+    gitRef?: string;
+    /** SVN commit message. */
+    message?: string;
+    /** Replace an existing tag. */
+    force?: boolean;
+    /** Run everything except the commit. */
+    dryRun?: boolean;
+}
+/**
+ * Deploy options with the defaults applied, from resolveDeployOptions().
+ */
+export interface DeployOptions extends FileSelection {
+    cwd: string;
+    slug: string;
+    version: string | null;
+    trunk: boolean;
+    readmeOnly: boolean;
+    svnTag: string | null;
+    assets: boolean;
+    assetsDir: string | null;
+    sourceDir: string;
+    readme: string;
+    fromZip: string | null;
+    svnUrl: string;
+    svnUsername: string | null;
+    /** Never logged or printed. */
+    svnPassword: string | null;
+    gitRef: string | null;
+    message: string | null;
+    force: boolean;
+    dryRun: boolean;
+}
+/**
+ * Check if a version has a pre-release suffix like 1.2.0-rc.1.
+ *
+ * @param version Version string.
+ * @return Whether it is a pre-release.
+ */
+export declare function isPrerelease(version: string): boolean;
+/**
+ * Strip the leading "v" from a version or tag like v1.2.0, since WordPress.org
+ * tags and plugin versions never use the prefix.
+ *
+ * @param tag Tag name.
+ * @return Tag without the prefix.
+ */
+export declare function normalizeTag(tag: string): string;
+/**
+ * Check if a git ref points to a tag.
+ *
+ * @param ref Git ref like refs/tags/1.0.0.
+ * @return Whether the ref is a tag.
+ */
+export declare function isTagRef(ref?: string | null): boolean;
+/**
+ * Check if a slug is a valid WordPress.org plugin slug, so that it's safe in
+ * SVN URLs and paths.
+ *
+ * @param slug Plugin slug.
+ * @return Whether the slug is valid.
+ */
+export declare function isValidSlug(slug: string): boolean;
+/**
+ * Check if a version can be used as an SVN tag directory name, without path
+ * separators or "." and ".." names.
+ *
+ * @param version Version string.
+ * @return Whether the version is valid.
+ */
+export declare function isValidVersion(version: string): boolean;
+/**
+ * Collect the problems with resolved deploy options.
+ *
+ * @param options Resolved options.
+ * @return Error messages, empty when valid.
+ */
+export declare function getDeployOptionErrors(options: DeployOptions): string[];
+/**
+ * Collect the notices about valid but unusual deploy options.
+ *
+ * @param options Resolved options.
+ * @return Warning messages.
+ */
+export declare function getDeployOptionWarnings(options: DeployOptions): string[];
+/**
+ * Apply defaults to deploy options and validate them. Trunk, readme and tag
+ * writes happen only when requested, and assets are synced whenever an
+ * assets directory is set, unless turned off. The version defaults to the
+ * SVN tag; without either, SvnDeploy reads the Version header of the
+ * deployed files, which can be in a ZIP.
+ *
+ * @param  input Options from the CLI, action or library caller.
+ * @return Resolved options.
+ * @throws {ValidationError} When the options are invalid.
+ */
+export declare function resolveDeployOptions(input?: DeployInput): DeployOptions;

package/dist/deploy-options.js

@@ -0,0 +1,168 @@
+import { existsSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
+import { ValidationError } from "./errors.js";
+import { resolveFileSelection } from "./file-selection.js";
+export const SVN_URL = 'https://plugins.svn.wordpress.org/{slug}/';
+/**
+ * Check if a version has a pre-release suffix like 1.2.0-rc.1.
+ *
+ * @param version Version string.
+ * @return Whether it is a pre-release.
+ */
+export function isPrerelease(version) {
+    return /^[^-+]+-/.test(version);
+}
+/**
+ * Strip the leading "v" from a version or tag like v1.2.0, since WordPress.org
+ * tags and plugin versions never use the prefix.
+ *
+ * @param tag Tag name.
+ * @return Tag without the prefix.
+ */
+export function normalizeTag(tag) {
+    return tag.replace(/^v(?=\d)/, '');
+}
+/**
+ * Check if a git ref points to a tag.
+ *
+ * @param ref Git ref like refs/tags/1.0.0.
+ * @return Whether the ref is a tag.
+ */
+export function isTagRef(ref) {
+    return Boolean(ref?.startsWith('refs/tags/'));
+}
+/**
+ * Check if a slug is a valid WordPress.org plugin slug, so that it's safe in
+ * SVN URLs and paths.
+ *
+ * @param slug Plugin slug.
+ * @return Whether the slug is valid.
+ */
+export function isValidSlug(slug) {
+    return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug);
+}
+/**
+ * Check if a version can be used as an SVN tag directory name, without path
+ * separators or "." and ".." names.
+ *
+ * @param version Version string.
+ * @return Whether the version is valid.
+ */
+export function isValidVersion(version) {
+    return /^[0-9A-Za-z][0-9A-Za-z.+_-]*$/.test(version);
+}
+function isValidFilename(name) {
+    return (Boolean(name) && !/[\\/]/.test(name) && !/^\.\.?$/.test(name));
+}
+/**
+ * Collect the problems with resolved deploy options.
+ *
+ * @param options Resolved options.
+ * @return Error messages, empty when valid.
+ */
+export function getDeployOptionErrors(options) {
+    const errors = [];
+    const { trunk, readmeOnly, svnTag, version, assets, assetsDir, slug } = options;
+    if (svnTag && !trunk) {
+        errors.push('--svn-tag requires --trunk, since the tag is copied from trunk.');
+    }
+    if (trunk && readmeOnly) {
+        errors.push('Use either --trunk or --readme-only, not both.');
+    }
+    if (svnTag && isPrerelease(svnTag)) {
+        errors.push(`Pre-release version ${svnTag} can't be tagged on WordPress.org.`);
+    }
+    if (svnTag && !isValidVersion(svnTag)) {
+        errors.push(`SVN tag "${svnTag}" isn't a valid version, use only letters, digits, dots, dashes, plus signs and underscores.`);
+    }
+    if (version && !isValidVersion(version)) {
+        errors.push(`Version "${version}" isn't valid, use only letters, digits, dots, dashes, plus signs and underscores.`);
+    }
+    if (svnTag && version && svnTag !== version) {
+        errors.push(`SVN tag ${svnTag} doesn't match version ${version}.`);
+    }
+    if (readmeOnly && isTagRef(options.gitRef)) {
+        errors.push(`--readme-only isn't allowed when running for tag ${options.gitRef}. Did you mean --trunk --svn-tag?`);
+    }
+    if (assets && !assetsDir) {
+        errors.push('Syncing assets requires --assets-dir.');
+    }
+    if (assets && assetsDir && !existsSync(assetsDir)) {
+        errors.push(`Assets directory ${assetsDir} doesn't exist.`);
+    }
+    if (!isValidFilename(options.readme)) {
+        errors.push(`Readme "${options.readme}" must be a file name in the source directory.`);
+    }
+    if (!slug) {
+        errors.push('Missing the plugin slug.');
+    }
+    if (slug && !isValidSlug(slug)) {
+        errors.push(`Slug "${slug}" isn't valid, use only lowercase letters, digits and dashes.`);
+    }
+    return errors;
+}
+/**
+ * Collect the notices about valid but unusual deploy options.
+ *
+ * @param options Resolved options.
+ * @return Warning messages.
+ */
+export function getDeployOptionWarnings(options) {
+    const warnings = [];
+    if (options.trunk && !options.svnTag) {
+        warnings.push('Syncing the full build to trunk without a tag makes trunk differ from the stable tag.');
+    }
+    if (options.trunk && options.version && isPrerelease(options.version)) {
+        warnings.push(`Syncing pre-release version ${options.version} to trunk.`);
+    }
+    return warnings;
+}
+/**
+ * Apply defaults to deploy options and validate them. Trunk, readme and tag
+ * writes happen only when requested, and assets are synced whenever an
+ * assets directory is set, unless turned off. The version defaults to the
+ * SVN tag; without either, SvnDeploy reads the Version header of the
+ * deployed files, which can be in a ZIP.
+ *
+ * @param  input Options from the CLI, action or library caller.
+ * @return Resolved options.
+ * @throws {ValidationError} When the options are invalid.
+ */
+export function resolveDeployOptions(input = {}) {
+    const cwd = resolve(input.cwd ?? process.cwd());
+    const slug = input.slug || basename(cwd);
+    const svnTag = input.svnTag ? normalizeTag(input.svnTag) : null;
+    const sourceDir = resolve(cwd, input.sourceDir || '.');
+    const assetsDir = input.assetsDir ? resolve(cwd, input.assetsDir) : null;
+    const options = {
+        cwd,
+        slug,
+        version: input.version ? normalizeTag(input.version) : svnTag,
+        trunk: Boolean(input.trunk),
+        readmeOnly: Boolean(input.readmeOnly),
+        assets: input.assets ?? Boolean(assetsDir),
+        svnTag,
+        sourceDir,
+        ...resolveFileSelection({
+            cwd,
+            sourceDir,
+            distignore: input.distignore,
+            exclude: input.exclude,
+        }),
+        assetsDir,
+        readme: input.readme || 'readme.txt',
+        fromZip: input.fromZip ? resolve(cwd, input.fromZip) : null,
+        svnUrl: (input.svnUrl || SVN_URL).replace('{slug}', slug),
+        svnUsername: input.svnUsername || process.env.SVN_USERNAME || null,
+        svnPassword: input.svnPassword || process.env.SVN_PASSWORD || null,
+        gitRef: input.gitRef || null,
+        message: input.message || null,
+        force: Boolean(input.force),
+        dryRun: Boolean(input.dryRun),
+    };
+    const errors = getDeployOptionErrors(options);
+    if (errors.length) {
+        throw new ValidationError(errors.join('\n'));
+    }
+    return options;
+}

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Invalid options or failed release checks, reported with exit code 2.
+ */
+export declare class ValidationError extends Error {
+    name: string;
+    exitCode: number;
+}
+/**
+ * Missing SVN credentials or a failed login or permission check, reported
+ * with exit code 3.
+ */
+export declare class CredentialsError extends Error {
+    static readonly EXIT_CODE = 3;
+    name: string;
+    exitCode: number;
+}

package/dist/errors.js

@@ -0,0 +1,16 @@
+/**
+ * Invalid options or failed release checks, reported with exit code 2.
+ */
+export class ValidationError extends Error {
+    name = 'ValidationError';
+    exitCode = 2;
+}
+/**
+ * Missing SVN credentials or a failed login or permission check, reported
+ * with exit code 3.
+ */
+export class CredentialsError extends Error {
+    static EXIT_CODE = 3;
+    name = 'CredentialsError';
+    exitCode = CredentialsError.EXIT_CODE;
+}

package/dist/file-selection.d.ts

@@ -0,0 +1,78 @@
+import ignore from 'ignore';
+export declare const DISTIGNORE_FILENAME = ".distignore";
+/**
+ * Version control metadata that is never released, at any depth. Without
+ * these, a repository without an ignore file would ship its .git/ directory,
+ * with the full history, in every ZIP and SVN deploy. Matching the name
+ * without a trailing slash also covers the .git file of worktrees and
+ * submodules.
+ */
+export declare const ALWAYS_EXCLUDED: string[];
+/**
+ * Gitignore-style matcher from the ignore package, with ignores( path ).
+ */
+export type FileRules = ignore.Ignore;
+export interface FileSelectionInput {
+    /** Directory that relative paths resolve against. */
+    cwd: string;
+    /** Directory with the files to select. */
+    sourceDir: string;
+    /** Ignore file path, or false to not read one. */
+    distignore?: string | false;
+    /** Extra gitignore-style patterns, comma or newline separated. */
+    exclude?: string | string[];
+}
+export interface FileSelection {
+    /** Ignore file path, or null when disabled. */
+    distignore: string | null;
+    /** Whether the ignore file must exist. */
+    distignoreRequired: boolean;
+    /** Extra gitignore-style patterns. */
+    exclude: string[];
+}
+/**
+ * Parse exclude patterns from a comma or newline separated string, an array
+ * of such strings (repeated CLI flags), or nothing.
+ *
+ * @param value Exclude patterns.
+ * @return Trimmed, non-empty patterns.
+ */
+export declare function parseExclude(value?: string | string[]): string[];
+/**
+ * Resolve which ignore file and extra patterns select the files to package
+ * or deploy. The default ignore file is optional, while an explicitly passed
+ * one must exist.
+ *
+ * @param input File selection input.
+ * @return Ignore file path (or null), whether it's required, and the patterns.
+ */
+export declare function resolveFileSelection(input: FileSelectionInput): FileSelection;
+/**
+ * Load the ignore file and exclude patterns into one gitignore-style matcher.
+ * The default ignore file is skipped when it doesn't exist. Version control
+ * metadata in ALWAYS_EXCLUDED is added last, so that no rule can re-include
+ * it.
+ *
+ * @param selection File selection from resolveFileSelection().
+ * @return Matcher with ignores( path ).
+ */
+export declare function loadFileRules(selection: Partial<FileSelection>): Promise<FileRules>;
+/**
+ * Check if an error is a Node.js system error with the given code.
+ *
+ * @param error Caught error.
+ * @param code  Error code like ENOENT.
+ * @return Whether the error has the code.
+ */
+export declare function isErrorCode(error: unknown, code: string): boolean;
+/**
+ * List the files in a directory that the rules don't ignore, as sorted
+ * relative paths with forward slashes. Ignored directories aren't read, so
+ * like in git, a file can't be re-included from an ignored directory.
+ *
+ * @param  sourceDir Directory to list.
+ * @param  rules     Matcher from loadFileRules().
+ * @return Relative file paths, sorted by code point.
+ * @throws {ValidationError} For selected symbolic links, which ZIP archives and WordPress.org SVN don't support.
+ */
+export declare function selectFiles(sourceDir: string, rules: FileRules): Promise<string[]>;

package/dist/file-selection.js

@@ -0,0 +1,133 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, posix, resolve } from 'node:path';
+import ignore from 'ignore';
+import { ValidationError } from "./errors.js";
+export const DISTIGNORE_FILENAME = '.distignore';
+/**
+ * Version control metadata that is never released, at any depth. Without
+ * these, a repository without an ignore file would ship its .git/ directory,
+ * with the full history, in every ZIP and SVN deploy. Matching the name
+ * without a trailing slash also covers the .git file of worktrees and
+ * submodules.
+ */
+export const ALWAYS_EXCLUDED = ['.git', '.svn', '.hg'];
+/**
+ * Parse exclude patterns from a comma or newline separated string, an array
+ * of such strings (repeated CLI flags), or nothing.
+ *
+ * @param value Exclude patterns.
+ * @return Trimmed, non-empty patterns.
+ */
+export function parseExclude(value) {
+    return [value]
+        .flat()
+        .filter((item) => 'string' === typeof item)
+        .flatMap((item) => item.split(/[,\n]/))
+        .map((pattern) => pattern.trim())
+        .filter(Boolean);
+}
+/**
+ * Resolve which ignore file and extra patterns select the files to package
+ * or deploy. The default ignore file is optional, while an explicitly passed
+ * one must exist.
+ *
+ * @param input File selection input.
+ * @return Ignore file path (or null), whether it's required, and the patterns.
+ */
+export function resolveFileSelection(input) {
+    const { cwd, sourceDir, distignore, exclude } = input;
+    const selection = {
+        distignore: join(sourceDir, DISTIGNORE_FILENAME),
+        distignoreRequired: false,
+        exclude: parseExclude(exclude),
+    };
+    if (false === distignore) {
+        selection.distignore = null;
+    }
+    if ('string' === typeof distignore && distignore) {
+        selection.distignore = resolve(cwd, distignore);
+        selection.distignoreRequired = true;
+    }
+    return selection;
+}
+/**
+ * Load the ignore file and exclude patterns into one gitignore-style matcher.
+ * The default ignore file is skipped when it doesn't exist. Version control
+ * metadata in ALWAYS_EXCLUDED is added last, so that no rule can re-include
+ * it.
+ *
+ * @param selection File selection from resolveFileSelection().
+ * @return Matcher with ignores( path ).
+ */
+export async function loadFileRules(selection) {
+    const { distignore = null, distignoreRequired = false, exclude = [], } = selection;
+    const rules = await readIgnoreFile(distignore, distignoreRequired);
+    return ignore().add(rules).add(exclude).add(ALWAYS_EXCLUDED);
+}
+/**
+ * Read the ignore file, or nothing when there's no file to read.
+ *
+ * @param path     Ignore file path, or null.
+ * @param required Whether the file must exist.
+ * @return Ignore file contents.
+ */
+async function readIgnoreFile(path, required) {
+    if (!path) {
+        return '';
+    }
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (!isErrorCode(error, 'ENOENT')) {
+            throw error;
+        }
+        if (required) {
+            throw new ValidationError(`Ignore file ${path} doesn't exist.`);
+        }
+        return '';
+    }
+}
+/**
+ * Check if an error is a Node.js system error with the given code.
+ *
+ * @param error Caught error.
+ * @param code  Error code like ENOENT.
+ * @return Whether the error has the code.
+ */
+export function isErrorCode(error, code) {
+    return error instanceof Error && 'code' in error && code === error.code;
+}
+/**
+ * List the files in a directory that the rules don't ignore, as sorted
+ * relative paths with forward slashes. Ignored directories aren't read, so
+ * like in git, a file can't be re-included from an ignored directory.
+ *
+ * @param  sourceDir Directory to list.
+ * @param  rules     Matcher from loadFileRules().
+ * @return Relative file paths, sorted by code point.
+ * @throws {ValidationError} For selected symbolic links, which ZIP archives and WordPress.org SVN don't support.
+ */
+export async function selectFiles(sourceDir, rules) {
+    const files = await findFiles(sourceDir, '', rules);
+    return files.sort();
+}
+async function findFiles(sourceDir, dir, rules) {
+    const entries = await readdir(join(sourceDir, dir), {
+        withFileTypes: true,
+    });
+    const files = await Promise.all(entries.map((entry) => findEntryFiles(sourceDir, posix.join(dir, entry.name), entry, rules)));
+    return files.flat();
+}
+async function findEntryFiles(sourceDir, path, entry, rules) {
+    if (entry.isDirectory() && !rules.ignores(`${path}/`)) {
+        return findFiles(sourceDir, path, rules);
+    }
+    if (entry.isFile() && !rules.ignores(path)) {
+        return [path];
+    }
+    if (entry.isSymbolicLink() && !rules.ignores(path)) {
+        throw new ValidationError(`${path} is a symbolic link, which isn't supported. Exclude it or replace it with the file.`);
+    }
+    return [];
+}