@wpelevator/wp-release 0.4.1 → 0.6.0

package/dist/changeset-config.js

@@ -0,0 +1,273 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ValidationError } from "./errors.js";
+/**
+ * Return a package.json version descriptor for use as a source or target.
+ *
+ * @param options Version manifest path.
+ * @return Package version descriptor.
+ */
+export function packageJsonVersion(options = {}) {
+    return {
+        kind: 'package-json',
+        file: options.file ?? 'package.json',
+        field: 'version',
+    };
+}
+/**
+ * Return a Composer version descriptor for use as a source or target.
+ *
+ * @param options Composer manifest path and missing-field behavior.
+ * @return Package version descriptor.
+ */
+export function composerJsonVersion(options = {}) {
+    return {
+        kind: 'composer-json',
+        file: options.file ?? 'composer.json',
+        field: 'version',
+        ifPresent: options.ifPresent ?? true,
+    };
+}
+/**
+ * Return a WordPress plugin header version descriptor.
+ *
+ * @param options Optional plugin main file path.
+ * @return Package version descriptor.
+ */
+export function wordpressPluginVersion(options = {}) {
+    return {
+        kind: 'wordpress-plugin-header',
+        ...(options.file ? { file: options.file } : {}),
+    };
+}
+/**
+ * Return a WordPress theme style.css version descriptor.
+ *
+ * @param options Optional theme stylesheet path.
+ * @return Package version descriptor.
+ */
+export function wordpressThemeVersion(options = {}) {
+    return {
+        kind: 'wordpress-theme-header',
+        ...(options.file ? { file: options.file } : {}),
+    };
+}
+/**
+ * Return a WordPress readme Stable tag version descriptor.
+ *
+ * @param options Optional readme path.
+ * @return Package version descriptor.
+ */
+export function wordpressStableTag(options = {}) {
+    return {
+        kind: 'wordpress-stable-tag',
+        ...(options.file ? { file: options.file } : {}),
+        ...(undefined !== options.ifPresent
+            ? { ifPresent: options.ifPresent }
+            : {}),
+    };
+}
+/**
+ * Return a git tag version descriptor for packages without a version file.
+ *
+ * @param options Optional tag pattern.
+ * @return Package version descriptor.
+ */
+export function gitTagVersion(options = {}) {
+    return {
+        kind: 'git-tag',
+        ...(options.pattern ? { pattern: options.pattern } : {}),
+    };
+}
+/**
+ * Return a PHP constant descriptor for use as a version source or target.
+ *
+ * @param options PHP file and constant name.
+ * @return Package version descriptor.
+ */
+export function phpConstantVersion(options) {
+    return { kind: 'php-constant', ...options };
+}
+/**
+ * Add type checking to a JavaScript wp-release configuration.
+ *
+ * @param config Repository release configuration.
+ * @return The same configuration object.
+ */
+export function defineConfig(config) {
+    return config;
+}
+const CONFIG_FILES = [
+    'wp-release.config.js',
+    'wp-release.config.mjs',
+    'wp-release.config.cjs',
+];
+/**
+ * Load and validate the repository's JavaScript wp-release configuration.
+ *
+ * @param  input Working directory and optional explicit config path.
+ * @return Loaded configuration and its absolute file path, or undefined when absent.
+ * @throws {ValidationError} If the module cannot be loaded or its shape is invalid.
+ */
+export async function loadChangesetConfig(input = {}) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const configFile = input.configFile
+        ? path.resolve(cwd, input.configFile)
+        : await findConfigFile(cwd);
+    if (!configFile) {
+        return undefined;
+    }
+    let loaded;
+    try {
+        loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(configFile).href));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ValidationError(`Could not load wp-release config ${configFile}: ${message}`);
+    }
+    const config = 'object' === typeof loaded && null !== loaded && 'default' in loaded
+        ? loaded.default
+        : undefined;
+    validateChangesetConfig(config, configFile);
+    return { config, file: configFile };
+}
+async function findConfigFile(cwd) {
+    for (const fileName of CONFIG_FILES) {
+        const candidate = path.join(cwd, fileName);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            // Try the next conventional filename.
+        }
+    }
+    return undefined;
+}
+/**
+ * Validate the supported config shape before commands consume it.
+ *
+ * @param config     Untrusted default export value.
+ * @param configFile Config file path for error messages.
+ */
+function validateChangesetConfig(config, configFile) {
+    if ('object' !== typeof config ||
+        null === config ||
+        Array.isArray(config)) {
+        throw new ValidationError(`wp-release config ${configFile} must default-export a configuration object.`);
+    }
+    const candidate = config;
+    if (!Array.isArray(candidate.packages)) {
+        throw new ValidationError(`wp-release config ${configFile} must define a packages array.`);
+    }
+    for (const [key, value] of Object.entries({
+        baseBranch: candidate.baseBranch,
+        changesets: candidate.changesets,
+        changelogInsertAfter: candidate.changelogInsertAfter,
+        root: candidate.root,
+    })) {
+        if (undefined !== value && 'string' !== typeof value) {
+            throw new ValidationError(`wp-release config ${configFile}.${key} must be a string.`);
+        }
+    }
+    if ('' === candidate.changelogInsertAfter) {
+        throw new ValidationError(`wp-release config ${configFile}.changelogInsertAfter must not be empty.`);
+    }
+    if (undefined !== candidate.tagFormat &&
+        'string' !== typeof candidate.tagFormat) {
+        throw new ValidationError(`wp-release config ${configFile}.tagFormat must be a string.`);
+    }
+    if (undefined !== candidate.readmeChangelog &&
+        'boolean' !== typeof candidate.readmeChangelog) {
+        throw new ValidationError(`wp-release config ${configFile}.readmeChangelog must be a boolean.`);
+    }
+    if (undefined !== candidate.nextVersion &&
+        'function' !== typeof candidate.nextVersion) {
+        throw new ValidationError(`wp-release config ${configFile}.nextVersion must be a function.`);
+    }
+    candidate.packages.forEach((group, index) => {
+        if ('object' !== typeof group ||
+            null === group ||
+            'object' !== typeof group.version ||
+            null === group.version ||
+            'object' !== typeof group.version.from ||
+            !Array.isArray(group.version.to)) {
+            throw new ValidationError(`wp-release config ${configFile} has an invalid packages[${index}] entry.`);
+        }
+        if (undefined !== group.idFrom &&
+            !['path', 'package.json#name', 'composer.json#name'].includes(group.idFrom)) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].idFrom is not supported.`);
+        }
+        if ('string' !== typeof group.glob || !group.glob.trim()) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].glob must be a non-empty string.`);
+        }
+        if ('string' !== typeof group.tagType &&
+            undefined !== group.tagType) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].tagType must be a string.`);
+        }
+        if (undefined !== group.exclude &&
+            (!Array.isArray(group.exclude) ||
+                group.exclude.some((item) => 'string' !== typeof item))) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].exclude must be an array of strings.`);
+        }
+        validateVersionDescriptor(group.version.from, `${configFile}.packages[${index}].version.from`, false);
+        group.version.to.forEach((target, targetIndex) => validateVersionDescriptor(target, `${configFile}.packages[${index}].version.to[${targetIndex}]`, true));
+    });
+}
+function validateVersionDescriptor(descriptor, location, isTarget) {
+    if ('object' !== typeof descriptor || null === descriptor) {
+        throw new ValidationError(`wp-release config ${location} must be an object.`);
+    }
+    const candidate = descriptor;
+    const sourceKinds = [
+        'package-json',
+        'composer-json',
+        'wordpress-plugin-header',
+        'wordpress-theme-header',
+        'wordpress-stable-tag',
+        'php-constant',
+        'git-tag',
+    ];
+    const targetKinds = sourceKinds.filter((kind) => 'git-tag' !== kind);
+    const kinds = isTarget ? targetKinds : sourceKinds;
+    if ('string' !== typeof candidate.kind ||
+        !kinds.includes(candidate.kind)) {
+        throw new ValidationError(`wp-release config ${location}.kind is not supported.`);
+    }
+    const needsFile = [
+        'package-json',
+        'composer-json',
+        'php-constant',
+    ].includes(candidate.kind);
+    if (needsFile &&
+        ('string' !== typeof candidate.file || !candidate.file.trim())) {
+        throw new ValidationError(`wp-release config ${location}.file must be a non-empty string.`);
+    }
+    if (['package-json', 'composer-json'].includes(candidate.kind) &&
+        'version' !== candidate.field) {
+        throw new ValidationError(`wp-release config ${location}.field must be "version".`);
+    }
+    if ('php-constant' === candidate.kind &&
+        ('string' !== typeof candidate.constant ||
+            !candidate.constant.trim())) {
+        throw new ValidationError(`wp-release config ${location}.constant must be a non-empty string.`);
+    }
+    if ('git-tag' === candidate.kind &&
+        undefined !== candidate.pattern &&
+        'string' !== typeof candidate.pattern) {
+        throw new ValidationError(`wp-release config ${location}.pattern must be a string.`);
+    }
+    if (undefined !== candidate.ifPresent &&
+        'boolean' !== typeof candidate.ifPresent) {
+        throw new ValidationError(`wp-release config ${location}.ifPresent must be a boolean.`);
+    }
+}

package/dist/changeset-release.d.ts

@@ -0,0 +1,74 @@
+import type { Changeset, ChangesetReleasePlan, PackageRelease } from './changesets.ts';
+export interface ChangesetRepository {
+    cwd: string;
+    configFile?: string;
+}
+export interface ChangesetVersionInput extends ChangesetRepository {
+    dryRun?: boolean;
+    date?: string;
+}
+export interface ChangesetTagInput extends ChangesetRepository {
+    dryRun?: boolean;
+    push?: boolean;
+    githubRelease?: boolean;
+    since?: string;
+}
+export interface ChangesetTagResult {
+    tags: Array<{
+        package: string;
+        version: string;
+        tag: string;
+        created: boolean;
+        notes: string;
+    }>;
+}
+/**
+ * Discover configured packages, pending changesets, and their proposed versions.
+ *
+ * @param input Repository root and optional explicit config file.
+ * @return A release plan; `undefined` when no config is present.
+ */
+export declare function getChangesetReleasePlan(input: ChangesetRepository): Promise<ChangesetReleasePlan | undefined>;
+/**
+ * Create a Changesets-compatible Markdown file.
+ *
+ * @param input Repository, packages and summary.
+ * @return Created file path.
+ */
+export declare function addChangeset(input: ChangesetRepository & {
+    packages: Record<string, 'patch' | 'minor' | 'major'>;
+    summary: string;
+    name?: string;
+}): Promise<string>;
+/**
+ * Apply pending package versions and changelogs.
+ *
+ * @param input Repository and versioning options.
+ * @return Planned releases and whether files were changed.
+ */
+export declare function versionChangesets(input: ChangesetVersionInput): Promise<ChangesetReleasePlan & {
+    date: string;
+    changed: boolean;
+}>;
+/**
+ * Create missing release tags, optionally pushing them to the configured remote.
+ *
+ * @param input Repository and tag options.
+ * @return Per-package tags and release notes.
+ */
+export declare function tagChangesets(input: ChangesetTagInput): Promise<ChangesetTagResult>;
+/**
+ * Check whether changed files belong to packages without a changeset.
+ *
+ * @param input Repository and base git ref.
+ * @return Changed packages and missing changeset identifiers.
+ */
+export declare function getChangesetStatus(input: ChangesetRepository & {
+    since?: string;
+}): Promise<{
+    changesets: Changeset[];
+    releases: PackageRelease[];
+    changedPackages: string[];
+    changedPackageFiles: Record<string, string[]>;
+    missingChangesets: string[];
+}>;