@wpelevator/wp-release 0.15.0 → 0.17.0

package/dist/commands/i18n.js

@@ -0,0 +1,174 @@
+import { resolve } from 'node:path';
+import { hasFatalDiagnostics } from "../i18n/catalog.js";
+import { extractCatalog, generatePackagePot } from "../i18n/generate.js";
+import { auditCatalog } from "../i18n/audit.js";
+import { resolveI18nPackages } from "../i18n/packages.js";
+import { ValidationError } from "../errors.js";
+import { getBoolean, getString, getStrings } from "./command.js";
+function cliOptions(values) {
+    const headers = {};
+    for (const header of getStrings(values, 'header')) {
+        const index = header.indexOf('=');
+        if (0 === index || !header) {
+            throw new ValidationError('--header requires NAME=VALUE, with an empty value allowed, or NAME to remove the header.');
+        }
+        if (-1 === index) {
+            headers[header] = false;
+        }
+        else {
+            headers[header.slice(0, index)] = header.slice(index + 1);
+        }
+    }
+    const domain = getString(values, 'domain');
+    const destination = getString(values, 'destination');
+    const fileComment = getString(values, 'file-comment');
+    return {
+        ...(undefined !== domain ? { domain } : {}),
+        ...(undefined !== destination ? { destination } : {}),
+        ...(undefined !== fileComment ? { fileComment } : {}),
+        ...(values.include
+            ? { include: getStrings(values, 'include') }
+            : {}),
+        ...(values.exclude
+            ? { exclude: getStrings(values, 'exclude') }
+            : {}),
+        ...(values.suppress
+            ? { suppress: getStrings(values, 'suppress') }
+            : {}),
+        ...(getBoolean(values, 'strict') ? { strict: true } : {}),
+        ...(getBoolean(values, 'all-domains') ? { allDomains: true } : {}),
+        ...(getBoolean(values, 'no-references')
+            ? { references: false }
+            : {}),
+        ...(getBoolean(values, 'no-legacy-globals')
+            ? { legacyGlobals: false }
+            : {}),
+        ...(Object.keys(headers).length ? { headers } : {}),
+    };
+}
+function report(context, diagnostics, sourceDir) {
+    for (const diagnostic of diagnostics) {
+        context.logger[diagnostic.severity](diagnostic.message, {
+            file: resolve(sourceDir, diagnostic.file),
+            line: diagnostic.line,
+            title: diagnostic.code,
+        });
+    }
+}
+/**
+ * Small command adapters share selection/reporting; domain logic stays in the library.
+ * @param operation
+ */
+export function createI18nCommand(operation) {
+    return {
+        name: `i18n-${operation}`,
+        usage: `i18n-${operation} [<source-dir>] [options]`,
+        summary: 'pot' === operation
+            ? 'Extract WordPress source strings into a reproducible POT.'
+            : 'Audit WordPress source strings without writing files.',
+        help: `Options:
+  --package <name>       Configured package (extraction overrides allowed)
+  --all                  All enabled configured WordPress packages
+  --source-dir <dir>     Plugin/theme directory, or positional argument (default .)
+  --domain <domain>      Select one domain (default Text Domain, then slug)
+  --all-domains          Explicitly combine domains
+  --include <glob>       Repeatable source globs, replacing inherited includes
+  --exclude <glob>       Repeatable exclusion globs, replacing inherited excludes
+  --destination <dir>    Package-relative POT directory
+  --header <NAME=VALUE>  Repeatable gettext header override; NAME alone removes it
+${'pot' === operation
+            ? '  --file-comment <text>  Static comment prepended to the POT\n'
+            : ''}
+  --no-references        Omit source references
+  --no-legacy-globals    JS requires imports or wp.i18n calls
+  --strict               Warnings fail with exit code 2
+${'pot' === operation
+            ? '  --output <file.pot>    Explicit output relative to cwd; one package only\n  --check                Compare bytes without writing'
+            : '  --suppress <code>      Repeatable audit finding codes to suppress'}
+
+No PHP, WordPress, WP-CLI or network needed. Distribution file rules do not apply.
+Each package writes atomically; a multi-package run is not a transaction.`,
+        options: {
+            package: { type: 'string' },
+            all: { type: 'boolean' },
+            'source-dir': { type: 'string' },
+            domain: { type: 'string' },
+            'all-domains': { type: 'boolean' },
+            include: { type: 'string', multiple: true },
+            exclude: { type: 'string', multiple: true },
+            destination: { type: 'string' },
+            header: { type: 'string', multiple: true },
+            'no-references': { type: 'boolean' },
+            'no-legacy-globals': { type: 'boolean' },
+            strict: { type: 'boolean' },
+            ...('pot' === operation
+                ? {
+                    'file-comment': { type: 'string' },
+                    output: { type: 'string' },
+                    check: { type: 'boolean' },
+                }
+                : { suppress: { type: 'string', multiple: true } }),
+        },
+        async run(context) {
+            const { values, positionals, cwd, configFile, logger } = context;
+            if (positionals.length > 1 ||
+                (positionals.length && undefined !== values['source-dir'])) {
+                throw new ValidationError('Pass only one source directory.');
+            }
+            const source = getString(values, 'source-dir');
+            if (undefined !== source && !source.trim()) {
+                throw new ValidationError('--source-dir must not be empty.');
+            }
+            const output = getString(values, 'output');
+            if (undefined !== output && !output.trim()) {
+                throw new ValidationError('--output must not be empty.');
+            }
+            const selected = await resolveI18nPackages({
+                cwd,
+                configFile,
+                package: getString(values, 'package'),
+                all: getBoolean(values, 'all'),
+                sourceDir: getString(values, 'source-dir') ?? positionals[0],
+                options: cliOptions(values),
+                validateOutputs: 'pot' === operation,
+                ...(output ? { outputPath: resolve(cwd, output) } : {}),
+            });
+            const result = { packages: [] };
+            let failed = false;
+            for (const pkg of selected) {
+                let generated;
+                if ('pot' === operation) {
+                    generated = await generatePackagePot({
+                        ...pkg,
+                        check: getBoolean(values, 'check'),
+                    });
+                }
+                else {
+                    const extracted = await extractCatalog(pkg);
+                    generated = {
+                        outputPath: pkg.outputPath,
+                        messages: extracted.catalog.messages.length,
+                        files: extracted.files,
+                        diagnostics: [
+                            ...extracted.diagnostics,
+                            ...auditCatalog(extracted.catalog, pkg.options.suppress),
+                        ],
+                        written: false,
+                        current: false,
+                    };
+                }
+                result.packages.push({
+                    ...generated,
+                    ...(pkg.package ? { package: pkg.package } : {}),
+                });
+                failed ||= hasFatalDiagnostics(generated.diagnostics, pkg.options.strict);
+                report(context, generated.diagnostics, pkg.sourceDir);
+                logger.info(`${pkg.package ?? pkg.sourceDir}: ${generated.messages} messages, ${generated.files} files.`);
+            }
+            logger.summary(() => `### wp-release i18n-${operation}\n\n${result.packages
+                .map((pkg) => `- ${pkg.package ?? pkg.outputPath}: ${pkg.messages} messages, ${pkg.diagnostics.length} diagnostics.`)
+                .join('\n')}\n`);
+            return { exitCode: failed ? 2 : 0, result };
+        },
+    };
+}

package/dist/commands/package-source.d.ts

@@ -0,0 +1,43 @@
+import type { PackageType } from '../checksums.ts';
+import type { FileSelection } from '../file-selection.ts';
+import type { ParsedValues } from './command.ts';
+/** Release source, file selection and package metadata. */
+export interface PackageSource {
+    sourceDir: string;
+    selection: FileSelection;
+    slug: string;
+    version: string | null;
+    type?: PackageType;
+    package?: string;
+}
+/**
+ * Get the configured package to release, failing for the options that set the
+ * source directory and the files instead.
+ *
+ * @param  values      Parsed CLI values.
+ * @param  positionals Positional arguments.
+ * @return The package identifier or path, or undefined without --package.
+ * @throws {ValidationError} For an empty --package, or --package with a source directory or file selection option.
+ */
+export declare function getPackageArg(values: ParsedValues, positionals: string[]): string | undefined;
+/**
+ * Get the files of a source directory from the CLI options.
+ *
+ * @param values      Parsed CLI values.
+ * @param positionals Positional arguments.
+ * @param cwd         Working directory.
+ * @return Source directory, file selection, slug and version.
+ */
+export declare function getDirectorySource(values: ParsedValues, positionals: string[], cwd: string): Promise<PackageSource>;
+/**
+ * Get the directory of a configured package with the files config of its
+ * package group, which its deploys use too.
+ *
+ * @param  values     Parsed CLI values.
+ * @param  cwd        Repository root with the wp-release config.
+ * @param  name       Package identifier or path under the configured root.
+ * @param  configFile Config file, instead of the conventional one.
+ * @return Source directory, file selection, slug, version and package.
+ * @throws {ValidationError} Without a config or for an unknown package.
+ */
+export declare function getPackageSource(values: ParsedValues, cwd: string, name: string, configFile?: string): Promise<PackageSource>;

package/dist/commands/package-source.js

@@ -0,0 +1,101 @@
+import { basename, resolve } from 'node:path';
+import { ValidationError } from "../errors.js";
+import { resolveFileSelection } from "../file-selection.js";
+import { getPackageFiles } from "../package-deploy.js";
+import { readPackageMeta } from "../package-meta.js";
+import { checkDirectory, getFileSelectionInput, getSourceDirArg, } from "./args.js";
+import { getBoolean, getString, getStrings } from "./command.js";
+/** Options of a source directory and its files, which --package takes from the config. */
+const SOURCE_FLAGS = [
+    'source-dir',
+    'distignore',
+    'no-distignore',
+    'exclude',
+    'exclude-gitattributes',
+];
+/**
+ * Get the configured package to release, failing for the options that set the
+ * source directory and the files instead.
+ *
+ * @param  values      Parsed CLI values.
+ * @param  positionals Positional arguments.
+ * @return The package identifier or path, or undefined without --package.
+ * @throws {ValidationError} For an empty --package, or --package with a source directory or file selection option.
+ */
+export function getPackageArg(values, positionals) {
+    const name = getString(values, 'package')?.trim();
+    const conflicts = SOURCE_FLAGS.filter((flag) => undefined !== getString(values, flag) ||
+        getBoolean(values, flag) ||
+        getStrings(values, flag).length);
+    if ('' === name) {
+        throw new ValidationError('--package <name> must not be empty.');
+    }
+    if (name && (positionals.length || conflicts.length)) {
+        throw new ValidationError(`--package takes the directory and files of the package from the config, so it can't be combined with ${positionals.length
+            ? 'a source directory'
+            : conflicts.map((flag) => `--${flag}`).join(', ')}.`);
+    }
+    return name;
+}
+/**
+ * Describe the files of a directory with the slug and the version from the
+ * options, or from the plugin or theme headers.
+ *
+ * @param values    Parsed CLI values.
+ * @param sourceDir Directory to release.
+ * @param selection File selection.
+ * @param slug      Default slug.
+ * @return Source directory, file selection, slug, version and type.
+ */
+async function describeSource(values, sourceDir, selection, slug) {
+    const name = getString(values, 'slug') ?? slug;
+    const meta = await readPackageMeta({ dir: sourceDir, slug: name });
+    return {
+        sourceDir,
+        selection,
+        slug: name,
+        version: getString(values, 'version') ?? meta?.version ?? null,
+        ...(meta ? { type: meta.type } : {}),
+    };
+}
+/**
+ * Get the files of a source directory from the CLI options.
+ *
+ * @param values      Parsed CLI values.
+ * @param positionals Positional arguments.
+ * @param cwd         Working directory.
+ * @return Source directory, file selection, slug and version.
+ */
+export async function getDirectorySource(values, positionals, cwd) {
+    const sourceDir = resolve(cwd, getSourceDirArg(values, positionals));
+    await checkDirectory(sourceDir);
+    return describeSource(values, sourceDir, resolveFileSelection({
+        cwd,
+        sourceDir,
+        ...getFileSelectionInput(values),
+    }), basename(cwd));
+}
+/**
+ * Get the directory of a configured package with the files config of its
+ * package group, which its deploys use too.
+ *
+ * @param  values     Parsed CLI values.
+ * @param  cwd        Repository root with the wp-release config.
+ * @param  name       Package identifier or path under the configured root.
+ * @param  configFile Config file, instead of the conventional one.
+ * @return Source directory, file selection, slug, version and package.
+ * @throws {ValidationError} Without a config or for an unknown package.
+ */
+export async function getPackageSource(values, cwd, name, configFile) {
+    const pkg = await getPackageFiles({
+        cwd,
+        package: name,
+        ...(configFile ? { configFile } : {}),
+    });
+    const source = await describeSource(values, pkg.directory, resolveFileSelection({
+        cwd,
+        sourceDir: pkg.directory,
+        ...pkg.files,
+    }), basename(pkg.directory));
+    return { ...source, package: pkg.name };
+}

package/dist/commands/verify.d.ts

@@ -12,6 +12,12 @@ declare const _default: {
         checksums: {
             type: "string";
         };
+        'checksums-format': {
+            type: "string";
+        };
+        'checksums-file': {
+            type: "string";
+        };
         zip: {
             type: "string";
         };
@@ -28,6 +34,6 @@ declare const _default: {
             type: "string";
         };
     };
-    run({ values, positionals, cwd, logger }: import("./command.ts").CommandContext): Promise<CommandOutcome<unknown>>;
+    run({ values, positionals, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<CommandOutcome<unknown>>;
 };
 export default _default;

package/dist/commands/verify.js

@@ -1,8 +1,10 @@
+import { readIntegrity, checkChecksumsFile, resolveManifestCodec, } from "../integrity.js";
+import { loadChangesetConfig } from "../changeset-config.js";
 import { existsSync } from 'node:fs';
 import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, isAbsolute, join, posix, resolve } from 'node:path';
-import { readChecksums, verifyChecksums } from "../checksums.js";
+import { verifyChecksums } from "../checksums.js";
 import { downloadFile, isUrl } from "../download.js";
 import { ignoreOwnFile, ignoreOwnSignature, loadFileRules, parseExclude, } from "../file-selection.js";
 import { ValidationError } from "../errors.js";
@@ -105,7 +107,7 @@ function getEmbeddedPath(checksumsPath, embedded) {
             ['.', '..'].includes(path))) {
         throw new ValidationError(`--embedded must be a path inside the plugin with forward slashes, got "${embedded}".`);
     }
-    return embedded || path.endsWith('.json') ? path : null;
+    return path;
 }
 /**
  * Get the manifest and signature pairs to look for inside the checked files.
@@ -180,9 +182,22 @@ async function hasSameContents(original, file) {
  */
 async function checkEmbeddedCopies(input) {
     const { dir, manifest, checksumsPath, embedded, format } = input;
-    const pairs = getCopyPairs(checksumsPath, getEmbeddedPath(checksumsPath, embedded), format);
+    const path = getEmbeddedPath(checksumsPath, embedded);
+    const pairs = getCopyPairs(checksumsPath, path, format).filter((pair) => pair.original !== join(dir, pair.copy) ||
+        existsSync(pair.original));
+    for (const other of Object.keys(SIGNATURE_FORMATS)) {
+        if (other !== format &&
+            path &&
+            existsSync(getSignaturePath(checksumsPath, other))) {
+            pairs.push({
+                original: getSignaturePath(checksumsPath, other),
+                copy: getSignaturePath(path, other),
+            });
+        }
+    }
     if (embedded) {
-        checkExplicitPairs(pairs, manifest);
+        checkExplicitPairs(pairs.filter((pair) => pair.original !== join(dir, pair.copy) ||
+            existsSync(pair.original)), manifest);
     }
     const found = pairs.filter(({ original, copy }) => existsSync(join(dir, copy)) &&
         (embedded ||
@@ -336,8 +351,10 @@ export default {
                           accepted as --source-dir <dir>
 
 Options:
-  --checksums <file>      Checksums manifest from "wp-release checksums" or the
-                          WordPress.org checksums API (required)
+  --checksums-file <file> Relative embedded manifest path (default: checksums.json)
+  --checksums-format <name> wordpress-json or sha256sum; custom codecs via --config
+  --checksums <file>      External checksums manifest from "wp-release checksums" or the
+                          WordPress.org checksums API (optional; otherwise reads embedded manifest)
   --zip <file|url>        Check the files of this ZIP, a local file or an
                           http(s) URL such as the ZIP that WordPress.org
                           builds for a release, instead of <source-dir>
@@ -381,6 +398,8 @@ file that isn't a matching copy is reported as extra. See --embedded for
 where the copies are looked for.`,
     options: {
         checksums: { type: 'string' },
+        'checksums-format': { type: 'string' },
+        'checksums-file': { type: 'string' },
         zip: { type: 'string' },
         'root-folder': { type: 'string' },
         embedded: { type: 'string' },
@@ -389,42 +408,59 @@ where the copies are looked for.`,
         ...sourceDirArgs,
         exclude: { type: 'string', multiple: true },
     },
-    async run({ values, positionals, cwd, logger }) {
+    async run({ values, positionals, cwd, configFile, logger }) {
         const zip = getString(values, 'zip');
         const sourceArg = positionals.length
             ? getSourceDirArg(values, positionals)
             : getString(values, 'source-dir');
         const checksums = getString(values, 'checksums');
-        if (!checksums) {
-            throw new ValidationError('Pass the checksums manifest with --checksums <file>.');
-        }
         if (zip && sourceArg) {
             throw new ValidationError('Pass either --zip or a source directory, not both.');
         }
-        const checksumsPath = resolve(cwd, checksums);
+        // Only load caller-selected configuration, never configuration inside the package.
+        const loaded = configFile
+            ? await loadChangesetConfig({ cwd, configFile })
+            : undefined;
+        const integrity = loaded?.config.integrity;
+        const codec = getString(values, 'checksums-format') ?? integrity?.codec;
+        const file = checkChecksumsFile(getString(values, 'checksums-file') ??
+            integrity?.file ??
+            resolveManifestCodec(codec).filename);
         const publicKey = getString(values, 'public-key');
         const format = getString(values, 'signature-format') ?? DEFAULT_SIGNATURE_FORMAT;
         if (!isSignatureFormat(format)) {
             throw new ValidationError(`Unknown signature format ${format}, use ${Object.keys(SIGNATURE_FORMATS).join(', ')}.`);
         }
-        if (publicKey) {
-            await checkSignature(checksumsPath, publicKey, format);
-            logger.info(`Signature of ${checksumsPath} is valid.`);
-        }
-        const manifest = await readChecksums(checksumsPath);
         const target = await resolveTarget({
             sourceDir: resolve(cwd, sourceArg ?? '.'),
             zip,
             cwd,
             rootFolder: getString(values, 'root-folder'),
         });
+        const checksumsPath = checksums
+            ? resolve(cwd, checksums)
+            : join(target.dir, file);
         try {
+            if (publicKey) {
+                await checkSignature(checksumsPath, publicKey, format);
+                if (!checksums) {
+                    for (const other of Object.keys(SIGNATURE_FORMATS)) {
+                        if (other !== format &&
+                            existsSync(getSignaturePath(checksumsPath, other))) {
+                            await checkSignature(checksumsPath, publicKey, other);
+                        }
+                    }
+                }
+                logger.info(`Signature of ${checksumsPath} is valid.`);
+            }
+            const manifest = await readIntegrity(checksumsPath, codec);
             return await verifyTarget({
                 target,
                 manifest,
                 checksumsPath,
                 exclude: getStrings(values, 'exclude'),
-                embedded: getString(values, 'embedded'),
+                embedded: getString(values, 'embedded') ??
+                    (checksums ? undefined : file),
                 format,
                 logger,
             });

package/dist/commands/zip.d.ts

@@ -8,9 +8,9 @@ export interface ZipResult extends ZipPackageResult {
     version: string | null;
     /** Zipped package, with --package. */
     package?: string;
-    /** Absolute paths of the signatures of the ZIP and the manifest, with --sign. */
+    /** External signature paths and package-relative embedded manifest signature paths. */
     signatures?: string[];
-    /** Base64 public key of the signing key, with --sign. */
+    /** Base64 public key of the signing key, with ZIP or manifest signing. */
     publicKey?: string;
 }
 declare const _default: {
@@ -19,22 +19,34 @@ declare const _default: {
     summary: string;
     help: string;
     options: {
-        package: {
+        'checksums-file': {
+            type: "string";
+        };
+        'checksums-format': {
+            type: "string";
+        };
+        'checksums-algorithms': {
             type: "string";
+            multiple: true;
         };
-        checksums: {
+        'embed-checksums': {
             type: "boolean";
         };
-        sign: {
+        'no-embed-checksums': {
             type: "boolean";
         };
-        'sign-format': {
-            type: "string";
-            multiple: true;
+        'no-sign-checksums': {
+            type: "boolean";
+        };
+        sign: {
+            type: "boolean";
         };
         force: {
             type: "boolean";
         };
+        package: {
+            type: "string";
+        };
         slug: {
             type: "string";
         };