@wpelevator/wp-release 0.15.0 → 0.17.0

package/dist/package-zip.js

@@ -1,8 +1,13 @@
-import { existsSync } from 'node:fs';
-import { CHECKSUMS_EXTENSION, createChecksums, writeChecksums, } from "./checksums.js";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { checkChecksumsFile, resolveManifestCodec, encodeIntegrity, } from "./integrity.js";
+import { checkSigningInput, signFiles, getSignaturePath } from "./signing.js";
+import { CHECKSUMS_EXTENSION, createChecksums } from "./checksums.js";
 import { ValidationError } from "./errors.js";
-import { ignoreOwnFile, ignoreOwnSignature, loadFileRules, selectFiles, } from "./file-selection.js";
-import { createZip } from "./zip.js";
+import { checkOutputFiles } from "./output-files.js";
+import { getPackageFilesToRelease } from "./package-files.js";
+import { createZip, isValidRootFolder } from "./zip.js";
 const ZIP_EXTENSION = '.zip';
 /**
  * Get the checksums manifest path next to an archive, with .checksums.json
@@ -17,19 +22,6 @@ export function getChecksumsPath(zipPath) {
         : 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.`);
-    }
-}
 /**
  * Write a ZIP of the selected files of a plugin, theme or package, and
  * optionally the checksums manifest of the same files next to it. The zip
@@ -44,35 +36,134 @@ function checkOverwrite(paths, force) {
  */
 export async function zipPackage(input) {
     const { sourceDir, zipPath, force = false } = input;
-    const checksumsPath = input.checksums ? getChecksumsPath(zipPath) : null;
-    const outputs = [zipPath, checksumsPath].filter((path) => null !== path);
-    const rules = await loadFileRules(input.selection);
-    outputs.forEach((path) => ignoreOwnSignature(ignoreOwnFile(rules, sourceDir, path), sourceDir, path));
-    const files = await selectFiles(sourceDir, rules);
-    if (!files.length) {
-        throw new ValidationError(`No files to archive in ${sourceDir}.`);
+    if (input.rootFolder && !isValidRootFolder(input.rootFolder)) {
+        throw new ValidationError(`Invalid root folder "${input.rootFolder}", use a single folder name.`);
+    }
+    const enabled = input.checksums ||
+        input.checksumsFile ||
+        input.embedChecksums ||
+        input.signChecksums;
+    const codec = resolveManifestCodec(input.integrity?.codec);
+    const file = checkChecksumsFile(input.checksumsFile ??
+        (codec.id === 'wordpress-json'
+            ? basename(getChecksumsPath(zipPath))
+            : codec.filename));
+    const checksumsPath = enabled && !input.embedChecksums
+        ? resolve(dirname(zipPath), file)
+        : null;
+    if (checksumsPath === resolve(zipPath)) {
+        throw new ValidationError('The ZIP and checksums file must have different destinations.');
     }
-    checkOverwrite(outputs, force);
-    await createZip({
+    if (input.signChecksums) {
+        checkSigningInput({
+            paths: checksumsPath ? [checksumsPath] : [],
+            formats: input.signChecksums,
+            force,
+        });
+    }
+    const outputs = [zipPath, checksumsPath].filter((path) => null !== path);
+    const { files, rules } = await getPackageFilesToRelease({
         sourceDir,
-        files,
-        zipPath,
-        rootFolder: input.rootFolder,
-        force,
+        selection: input.selection,
+        outputs,
+        excludeSignatures: true,
+        operation: 'archive',
     });
-    if (checksumsPath) {
-        const manifest = await createChecksums({
+    checkOutputFiles(outputs, force);
+    const entries = {};
+    let checksumsSigning;
+    let stage;
+    const metadata = [
+        file,
+        ...['wordpress', 'minisign', 'ssh'].map((format) => getSignaturePath(file, format)),
+    ];
+    if (enabled &&
+        input.embedChecksums &&
+        metadata.some((path) => files.some((selected) => selected === path ||
+            selected.startsWith(path + '/') ||
+            path.startsWith(selected + '/')))) {
+        throw new ValidationError('Embedded checksums collide with selected source files. Remove the generated metadata or exclude it from the payload.');
+    }
+    try {
+        if (enabled) {
+            const manifest = await createChecksums({
+                sourceDir,
+                rules,
+                slug: input.slug,
+                version: input.version ?? null,
+                type: input.type,
+            });
+            const algorithms = input.integrity?.algorithms;
+            if (algorithms) {
+                if (!algorithms.length ||
+                    algorithms.some((algorithm) => !['md5', 'sha256'].includes(algorithm))) {
+                    throw new ValidationError('Checksums algorithms must be md5 and/or sha256.');
+                }
+                Object.values(manifest.files).forEach((hashes) => {
+                    if (!algorithms.includes('md5')) {
+                        delete hashes.md5;
+                    }
+                    if (!algorithms.includes('sha256')) {
+                        delete hashes.sha256;
+                    }
+                });
+            }
+            const bytes = await encodeIntegrity(codec, manifest);
+            stage = await mkdtemp(join(tmpdir(), 'wp-release-integrity-'));
+            const stagedFile = join(stage, file);
+            await mkdir(dirname(stagedFile), { recursive: true });
+            await writeFile(stagedFile, bytes);
+            if (input.signChecksums) {
+                checksumsSigning = await signFiles({
+                    paths: [stagedFile],
+                    formats: input.signChecksums,
+                });
+            }
+            if (input.embedChecksums) {
+                entries[file] = bytes;
+                for (const format of input.signChecksums ?? []) {
+                    entries[getSignaturePath(file, format)] =
+                        await readFile(getSignaturePath(stagedFile, format));
+                }
+            }
+            else if (checksumsPath) {
+                await mkdir(dirname(checksumsPath), { recursive: true });
+                await writeFile(checksumsPath, bytes, {
+                    flag: force ? 'w' : 'wx',
+                });
+                for (const format of input.signChecksums ?? []) {
+                    await writeFile(getSignaturePath(checksumsPath, format), await readFile(getSignaturePath(stagedFile, format)), { flag: force ? 'w' : 'wx' });
+                }
+            }
+        }
+        await mkdir(dirname(zipPath), { recursive: true });
+        await createZip({
             sourceDir,
-            rules,
-            slug: input.slug,
-            version: input.version ?? null,
-            type: input.type,
+            files,
+            entries,
+            zipPath,
+            rootFolder: input.rootFolder,
+            force,
         });
-        await writeChecksums(checksumsPath, manifest, force);
     }
+    finally {
+        if (stage) {
+            await rm(stage, { recursive: true, force: true });
+        }
+    }
+    const signatures = (input.signChecksums ?? []).map((format) => getSignaturePath(checksumsPath ?? file, format));
     return {
         zipPath,
         ...(checksumsPath ? { checksumsPath } : {}),
-        files: files.length,
+        ...(enabled && input.embedChecksums
+            ? { checksumsEmbedded: file }
+            : {}),
+        ...(checksumsSigning
+            ? {
+                checksumsSigning: { ...checksumsSigning, signatures },
+                checksumsSignatures: signatures,
+            }
+            : {}),
+        files: files.length + Object.keys(entries).length,
     };
 }

package/dist/release-tags.js

@@ -12,6 +12,12 @@ import { compareVersions, isPrerelease, isVersion } from "./versions.js";
  * @throws {ValidationError} For unknown packages, or an expected version without a single package.
  */
 export function selectTagPackages(packages, names, version) {
+    if (undefined !== version &&
+        !names.length &&
+        1 === packages.length &&
+        '.' === packages[0]?.path) {
+        names = [packages[0].name];
+    }
     if (undefined !== version && 1 !== names.length) {
         throw new ValidationError('An expected version requires exactly one package.');
     }

package/dist/single-project.d.ts

@@ -0,0 +1,32 @@
+import type { ChangesetConfig, PackageVersionSource } from './changeset-config.ts';
+/** Options used only when changesets have no JavaScript release config. */
+export interface SingleProjectOptions {
+    /** Explicit descriptors replace automatic version detection. Git tags are source-only. */
+    versions?: PackageVersionSource[];
+    /** Descriptor kind, optionally qualified with :file or :file#constant. */
+    versionFrom?: string;
+    baseBranch?: string;
+    remote?: string;
+    changesets?: string;
+    readmeChangelog?: boolean;
+    changelogInsertAfter?: string;
+}
+/** CLI names of version descriptor kinds. */
+export declare const VERSION_KINDS: {
+    readonly 'package-json': "package-json";
+    readonly 'composer-json': "composer-json";
+    readonly 'wordpress-plugin': "wordpress-plugin-header";
+    readonly 'wordpress-theme': "wordpress-theme-header";
+    readonly 'wordpress-stable-tag': "wordpress-stable-tag";
+    readonly 'php-constant': "php-constant";
+    readonly 'git-tag': "git-tag";
+};
+/**
+ * Build the root package config, without creating a configuration file.
+ *
+ * @param cwd       Project root directory.
+ * @param options   Explicit descriptors and shared release settings.
+ * @param tagFormat Tag format override, otherwise v{version}.
+ * @return Root package config, or undefined without a version source.
+ */
+export declare function resolveSingleProjectConfig(cwd: string, options?: SingleProjectOptions, tagFormat?: string): Promise<ChangesetConfig | undefined>;

package/dist/single-project.js

@@ -0,0 +1,144 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { packageJsonVersion, composerJsonVersion, wordpressPluginVersion, wordpressThemeVersion, wordpressStableTag, } from "./changeset-config.js";
+import { ValidationError } from "./errors.js";
+import { readJsonIfExists } from "./json-files.js";
+import { parseFileHeaders, readFileStart } from "./package-meta.js";
+/** CLI names of version descriptor kinds. */
+export const VERSION_KINDS = {
+    'package-json': 'package-json',
+    'composer-json': 'composer-json',
+    'wordpress-plugin': 'wordpress-plugin-header',
+    'wordpress-theme': 'wordpress-theme-header',
+    'wordpress-stable-tag': 'wordpress-stable-tag',
+    'php-constant': 'php-constant',
+    'git-tag': 'git-tag',
+};
+function descriptorId(descriptor) {
+    if ('git-tag' === descriptor.kind) {
+        return descriptor.pattern ?? '';
+    }
+    return 'php-constant' === descriptor.kind
+        ? `${descriptor.file}#${descriptor.constant}`
+        : descriptor.file ?? '';
+}
+function selectSource(versions, selector) {
+    let candidates = versions;
+    if (selector) {
+        const separator = selector.indexOf(':');
+        const kind = separator < 0 ? selector : selector.slice(0, separator);
+        const id = separator < 0 ? undefined : selector.slice(separator + 1);
+        const descriptorKind = VERSION_KINDS[kind];
+        candidates = versions.filter((descriptor) => descriptor.kind === descriptorKind &&
+            (undefined === id || descriptorId(descriptor) === id));
+    }
+    else if (versions.length > 1) {
+        // A Stable tag can accompany a unique authoritative version file.
+        candidates = versions.filter((descriptor) => 'wordpress-stable-tag' !== descriptor.kind);
+    }
+    if (candidates.length !== 1) {
+        throw new ValidationError('Cannot choose the current version source. Pass --version-from <kind> or --version-from <kind>:<file> (PHP constants use <file>#<constant>), or add a wp-release config.');
+    }
+    return candidates[0];
+}
+async function detectVersions(cwd) {
+    const versions = [];
+    const entries = await readdir(cwd, { withFileTypes: true });
+    for (const entry of entries
+        .filter((item) => item.isFile() &&
+        (item.name.endsWith('.php') || 'style.css' === item.name))
+        .sort((a, b) => a.name.localeCompare(b.name))) {
+        const contents = await readFileStart(path.join(cwd, entry.name));
+        const theme = 'style.css' === entry.name;
+        const nameHeader = theme ? 'Theme Name' : 'Plugin Name';
+        const headers = parseFileHeaders({
+            contents: contents ?? '',
+            headers: [nameHeader, 'Version'],
+        });
+        if (headers[nameHeader]) {
+            versions.push(theme
+                ? wordpressThemeVersion({ file: entry.name })
+                : wordpressPluginVersion({ file: entry.name }));
+        }
+    }
+    for (const file of ['package.json', 'composer.json']) {
+        const manifest = await readJsonIfExists(path.join(cwd, file)).catch((error) => {
+            throw new ValidationError(`Could not read ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        if (manifest && 'package.json' === file && manifest.workspaces) {
+            throw new ValidationError('Automatic changeset configuration is for a single root project. Configure workspace packages in a wp-release config or pass explicit --version-* descriptors.');
+        }
+        if (manifest &&
+            'string' === typeof manifest.version &&
+            manifest.version.trim()) {
+            versions.push('package.json' === file
+                ? packageJsonVersion()
+                : composerJsonVersion());
+        }
+    }
+    if (versions.length > 1) {
+        throw new ValidationError('Cannot choose among multiple root version sources. Pass explicit --version-* descriptors or add a wp-release config.');
+    }
+    if (1 === versions.length &&
+        'wordpress-plugin-header' === versions[0]?.kind) {
+        const readmes = await Promise.all(['readme.txt', 'readme.md'].map(async (file) => {
+            const contents = await readFileStart(path.join(cwd, file));
+            const headers = parseFileHeaders({
+                contents: contents ?? '',
+                headers: ['Stable tag'],
+            });
+            return headers['Stable tag'] ? file : undefined;
+        }));
+        const readme = readmes.find(Boolean);
+        if (readme) {
+            versions.push(wordpressStableTag({ file: readme }));
+        }
+    }
+    return versions;
+}
+/**
+ * Build the root package config, without creating a configuration file.
+ *
+ * @param cwd       Project root directory.
+ * @param options   Explicit descriptors and shared release settings.
+ * @param tagFormat Tag format override, otherwise v{version}.
+ * @return Root package config, or undefined without a version source.
+ */
+export async function resolveSingleProjectConfig(cwd, options = {}, tagFormat) {
+    const versions = options.versions ?? (await detectVersions(cwd));
+    if (!versions.length) {
+        return undefined;
+    }
+    const ids = versions.map((descriptor) => `${descriptor.kind}:${descriptorId(descriptor)}`);
+    if (new Set(ids).size !== ids.length) {
+        throw new ValidationError('A version descriptor was supplied more than once. Pass each --version-* file or constant only once.');
+    }
+    const from = selectSource(versions, options.versionFrom);
+    const to = versions.filter((descriptor) => 'git-tag' !== descriptor.kind);
+    // Composer targets preserve the existing optional-version convention.
+    const targets = to.map((descriptor) => 'composer-json' === descriptor.kind
+        ? { ...descriptor, ifPresent: descriptor.ifPresent ?? true }
+        : descriptor);
+    let idFrom = 'path';
+    if ('package-json' === from.kind && 'package.json' === from.file) {
+        idFrom = 'package.json#name';
+    }
+    else if ('composer-json' === from.kind &&
+        'composer.json' === from.file) {
+        idFrom = 'composer.json#name';
+    }
+    return {
+        ...(options.baseBranch ? { baseBranch: options.baseBranch } : {}),
+        ...(options.remote ? { remote: options.remote } : {}),
+        ...(undefined !== options.readmeChangelog
+            ? { readmeChangelog: options.readmeChangelog }
+            : {}),
+        ...(options.changelogInsertAfter
+            ? { changelogInsertAfter: options.changelogInsertAfter }
+            : {}),
+        root: '.',
+        changesets: options.changesets ?? '.changeset',
+        tagFormat: tagFormat ?? 'v{version}',
+        packages: [{ glob: '.', idFrom, version: { from, to: targets } }],
+    };
+}

package/dist/summary.d.ts

@@ -1,5 +1,6 @@
 import type { ChecksumsResult } from './commands/checksums.ts';
 import type { SignResult } from './commands/sign.ts';
+import type { BuildPackageResult } from './package-build.ts';
 import type { ZipPackageResult } from './package-zip.ts';
 import type { ChangesetTagResult } from './changeset-release.ts';
 import type { PackageRelease } from './changesets.ts';
@@ -69,6 +70,14 @@ export declare function formatTable(header: string[], rows: string[][]): string;
  * @return Markdown code.
  */
 export declare function formatFile(context: SummaryContext, file: string, line?: number | null): string;
+/**
+ * Get the summary of a directory build.
+ *
+ * @param context Workspace directory.
+ * @param result  Output directory and number of copied files.
+ * @return Markdown summary.
+ */
+export declare function getBuildSummary(context: SummaryContext, result: BuildPackageResult): string;
 /**
  * Get the summary of a ZIP.
  *

package/dist/summary.js

@@ -99,6 +99,26 @@ function formatDetails(title, content) {
 function joinBlocks(blocks) {
     return `${blocks.filter(Boolean).join('\n\n')}\n`;
 }
+/**
+ * Get the summary of a directory build.
+ *
+ * @param context Workspace directory.
+ * @param result  Output directory and number of copied files.
+ * @return Markdown summary.
+ */
+export function getBuildSummary(context, result) {
+    return joinBlocks([
+        '### Build',
+        formatList([
+            `**Directory:** ${formatFile(context, result.outputDir)}, ${result.files} files`,
+            ...(result.checksumsPath
+                ? [
+                    `**Checksums:** ${formatFile(context, result.checksumsPath)}`,
+                ]
+                : []),
+        ]),
+    ]);
+}
 /**
  * Get the summary of a ZIP.
  *
@@ -111,6 +131,11 @@ export function getZipSummary(context, result) {
         '### ZIP',
         formatList([
             `**ZIP:** ${formatFile(context, result.zipPath)}, ${result.files} files`,
+            ...(result.checksumsEmbedded
+                ? [
+                    `**Embedded checksums:** ${formatCode(result.checksumsEmbedded)}`,
+                ]
+                : []),
             ...(result.checksumsPath
                 ? [
                     `**Checksums:** ${formatFile(context, result.checksumsPath)}`,

package/dist/zip.d.ts

@@ -14,6 +14,8 @@ export interface CreateZipInput {
     sourceDir: string;
     /** Relative file paths with forward slashes, from selectFiles(). */
     files: string[];
+    /** Generated entries, keyed by relative archive path. */
+    entries?: Record<string, Buffer>;
     /** Archive path. */
     zipPath: string;
     /** Folder to put the files in inside the archive, or null for the root. */
@@ -30,3 +32,4 @@ export interface CreateZipInput {
  * @throws {ValidationError} If the archive exists and force isn't set.
  */
 export declare function createZip(input: CreateZipInput): Promise<void>;
+export declare function isValidRootFolder(name: string): boolean;

package/dist/zip.js

@@ -31,11 +31,21 @@ export async function createZip(input) {
     }
     const zip = new yazl.ZipFile();
     const output = createWriteStream(zipPath, { flags: force ? 'w' : 'wx' });
-    [...files].sort().forEach((file) => zip.addFile(join(sourceDir, file), rootFolder ? posix.join(rootFolder, file) : file, {
-        mtime: ZIP_MTIME,
-        mode: ZIP_FILE_MODE,
-        forceDosTimestamp: true,
-    }));
+    const entries = input.entries ?? {};
+    [...files, ...Object.keys(entries)].sort().forEach((file) => {
+        const path = rootFolder ? posix.join(rootFolder, file) : file;
+        const options = {
+            mtime: ZIP_MTIME,
+            mode: ZIP_FILE_MODE,
+            forceDosTimestamp: true,
+        };
+        if (Object.hasOwn(entries, file)) {
+            zip.addBuffer(entries[file] ?? Buffer.alloc(0), path, options);
+        }
+        else {
+            zip.addFile(join(sourceDir, file), path, options);
+        }
+    });
     zip.end();
     try {
         await pipeline(zip.outputStream, output);
@@ -48,6 +58,6 @@ export async function createZip(input) {
         throw error;
     }
 }
-function isValidRootFolder(name) {
+export function isValidRootFolder(name) {
     return !/[\\/]/.test(name) && '.' !== name && '..' !== name;
 }

package/package.json

@@ -1,8 +1,13 @@
 {
 	"name": "@wpelevator/wp-release",
-	"version": "0.15.0",
-	"description": "Package, checksum, sign, verify and version-check WordPress plugins and themes, and deploy plugins to WordPress.org SVN",
+	"version": "0.17.0",
+	"description": "Package, checksum, sign, verify and version-check WordPress plugins and themes, extract and compile their translations, and deploy plugins to WordPress.org SVN",
 	"license": "MIT",
+	"author": "WP Elevator (https://wpelevator.com)",
+	"homepage": "https://github.com/wpelevator/basement/tree/main/packages/js/wp-release#readme",
+	"bugs": {
+		"url": "https://github.com/wpelevator/basement/issues"
+	},
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/wpelevator/basement.git",
@@ -37,15 +42,27 @@
 		"svn",
 		"zip",
 		"checksums",
-		"signing"
+		"signing",
+		"i18n",
+		"gettext",
+		"pot"
 	],
 	"dependencies": {
+		"@tannin/postfix": "^1.1.0",
+		"@babel/parser": "^7.29.7",
+		"@babel/traverse": "^7.29.7",
+		"gettext-parser": "^8.0.0",
 		"ignore": "^7.0.12",
+		"minimatch": "^10.2.6",
+		"php-parser": "^3.7.0",
 		"semver": "^7.7.1",
 		"yauzl": "^3.4.0",
 		"yazl": "^3.3.1"
 	},
 	"devDependencies": {
+		"@babel/types": "^7.29.7",
+		"@types/babel__traverse": "^7.28.0",
+		"@types/gettext-parser": "^9.0.0",
 		"@types/node": "^22.20.5",
 		"@types/semver": "^7.8.0",
 		"@types/yauzl": "^3.4.0",