@artemsemkin/wp-headers 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artem Semkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @artemsemkin/wp-headers
+
+Generate and patch WordPress file headers from `package.json` data.
+
+## Install
+
+```bash
+npm install @artemsemkin/wp-headers
+```
+
+## Usage
+
+```ts
+import { processMapping } from '@artemsemkin/wp-headers'
+
+processMapping({
+  type: 'plugin',
+  slug: 'my-plugin',
+  entityDir: '/path/to/plugin',
+  tgmBasePath: '/path/to/theme/src/php',
+})
+```
+
+This reads `package.json` from `entityDir`, generates the appropriate WordPress headers, and writes them to the target files (`style.css`, plugin PHP, `readme.txt`).
+
+Header field data comes from `pkg.wp.theme` or `pkg.wp.plugin` in your `package.json`.

package/dist/core.d.ts

@@ -0,0 +1,8 @@
+/** Serialize fields into a `/* ... *​/` block comment */
+export declare function buildComment(fields: Record<string, string>): string;
+/** Serialize a titled readme header block: `=== Title ===\n\nKey: Value\n\n` */
+export declare function buildReadmeBlock(title: string, fields: Record<string, string>): string;
+/** Replace the first `/* ... *​/` block comment in content. Returns `null` if not found. */
+export declare function replaceComment(content: string, newComment: string): string | null;
+/** Replace the `=== ... ===` header block in content. Returns `null` if not found. */
+export declare function replaceReadmeBlock(content: string, newBlock: string): string | null;

package/dist/core.js

@@ -0,0 +1,55 @@
+/** Serialize fields into a `/* ... *​/` block comment */
+export function buildComment(fields) {
+    const lines = ['/*'];
+    for (const [key, value] of Object.entries(fields)) {
+        lines.push(`${key}: ${value}`);
+    }
+    lines.push('*/');
+    return lines.join('\n') + '\n';
+}
+/** Serialize a titled readme header block: `=== Title ===\n\nKey: Value\n\n` */
+export function buildReadmeBlock(title, fields) {
+    const lines = [`=== ${title} ===`, ''];
+    for (const [key, value] of Object.entries(fields)) {
+        lines.push(`${key}: ${value}`);
+    }
+    lines.push('');
+    return lines.join('\n') + '\n';
+}
+/** Replace the first `/* ... *​/` block comment in content. Returns `null` if not found. */
+export function replaceComment(content, newComment) {
+    const startIdx = content.indexOf('/*');
+    if (startIdx === -1) {
+        return null;
+    }
+    const endIdx = content.indexOf('*/', startIdx);
+    if (endIdx === -1) {
+        return null;
+    }
+    const after = content.slice(endIdx + 2).replace(/^\n*/, '');
+    return content.slice(0, startIdx) + newComment + '\n' + after;
+}
+/** Replace the `=== ... ===` header block in content. Returns `null` if not found. */
+export function replaceReadmeBlock(content, newBlock) {
+    content = content.replace(/\r\n/g, '\n');
+    const lines = content.split('\n');
+    const titleIdx = lines.findIndex((l) => /^===\s+.+\s+===$/.test(l));
+    if (titleIdx === -1) {
+        return null;
+    }
+    let endIdx = titleIdx + 1;
+    while (endIdx < lines.length) {
+        const line = lines[endIdx];
+        if (line.trim() === '') {
+            endIdx++;
+            continue;
+        }
+        if (/^[A-Za-z][A-Za-z ]*:/.test(line)) {
+            endIdx++;
+            continue;
+        }
+        break;
+    }
+    const afterHeader = lines.slice(endIdx).join('\n');
+    return newBlock + afterHeader;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { buildComment, buildReadmeBlock, replaceComment, replaceReadmeBlock } from './core.js';
+export type { ThemeStyleConfig, ThemeReadmeConfig } from './wp-theme.js';
+export { wpThemeStyle, wpThemeReadme, themeStyleFromPkg, themeReadmeFromPkg } from './wp-theme.js';
+export type { PluginHeaderConfig, PluginReadmeConfig } from './wp-plugin.js';
+export { wpPluginHeader, wpPluginReadme, pluginHeaderFromPkg, pluginReadmeFromPkg } from './wp-plugin.js';
+export { titleCase, deriveName } from './wp-helpers.js';
+export { patchTgmVersion } from './patch-tgm.js';
+export type { HeaderMapping } from './process.js';
+export { readText, processMapping } from './process.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+// Core
+export { buildComment, buildReadmeBlock, replaceComment, replaceReadmeBlock } from './core.js';
+export { wpThemeStyle, wpThemeReadme, themeStyleFromPkg, themeReadmeFromPkg } from './wp-theme.js';
+export { wpPluginHeader, wpPluginReadme, pluginHeaderFromPkg, pluginReadmeFromPkg } from './wp-plugin.js';
+// Helpers
+export { titleCase, deriveName } from './wp-helpers.js';
+// TGM
+export { patchTgmVersion } from './patch-tgm.js';
+export { readText, processMapping } from './process.js';

package/dist/patch-tgm.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Patch the `version` field for a specific plugin slug inside a TGM-style PHP array.
+ *
+ * Handles both `array()` and `[]` syntax, aligned `=>` whitespace,
+ * mixed quote styles, nested function calls, and arbitrary field order.
+ *
+ * Returns the patched content, or the original content unchanged if:
+ * - The slug is not found
+ * - No version field exists in the slug's array block
+ * - The version already matches
+ */
+export declare function patchTgmVersion(content: string, slug: string, version: string): string;

package/dist/patch-tgm.js

@@ -0,0 +1,99 @@
+/**
+ * Patch the `version` field for a specific plugin slug inside a TGM-style PHP array.
+ *
+ * Handles both `array()` and `[]` syntax, aligned `=>` whitespace,
+ * mixed quote styles, nested function calls, and arbitrary field order.
+ *
+ * Returns the patched content, or the original content unchanged if:
+ * - The slug is not found
+ * - No version field exists in the slug's array block
+ * - The version already matches
+ */
+export function patchTgmVersion(content, slug, version) {
+    // A. Find slug via regex — handles mixed quotes + flexible whitespace
+    const escapedSlug = slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const slugPattern = new RegExp(`['"]slug['"]\\s*=>\\s*['"]${escapedSlug}['"]`);
+    const slugMatch = slugPattern.exec(content);
+    if (!slugMatch) {
+        return content;
+    }
+    const slugPos = slugMatch.index;
+    // B. Walk backwards with dual depth tracking to find enclosing array opener
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let arrayStart = -1;
+    for (let i = slugPos - 1; i >= 0; i--) {
+        const ch = content[i];
+        if (ch === ')') {
+            parenDepth++;
+        }
+        else if (ch === '(') {
+            if (parenDepth === 0) {
+                // Check if preceded by "array"
+                const before = content.slice(Math.max(0, i - 5), i);
+                if (before === 'array') {
+                    arrayStart = i - 5;
+                }
+                else {
+                    arrayStart = i;
+                }
+                break;
+            }
+            parenDepth--;
+        }
+        else if (ch === ']') {
+            bracketDepth++;
+        }
+        else if (ch === '[') {
+            if (bracketDepth === 0) {
+                arrayStart = i;
+                break;
+            }
+            bracketDepth--;
+        }
+    }
+    if (arrayStart === -1) {
+        return content;
+    }
+    // C. Walk forwards with depth tracking to find matching closer
+    // Determine what kind of opener we have
+    const openerChar = content[arrayStart] === '[' ? '[' : '(';
+    const closerChar = openerChar === '[' ? ']' : ')';
+    // Find the actual opening bracket/paren position
+    let openPos = arrayStart;
+    if (openerChar === '(') {
+        openPos = content.indexOf('(', arrayStart);
+        /* v8 ignore next 3 */
+        if (openPos === -1) {
+            return content;
+        }
+    }
+    let depth = 0;
+    let arrayEnd = -1;
+    for (let i = openPos; i < content.length; i++) {
+        const ch = content[i];
+        if (ch === openerChar) {
+            depth++;
+        }
+        else if (ch === closerChar) {
+            depth--;
+            if (depth === 0) {
+                arrayEnd = i;
+                break;
+            }
+        }
+    }
+    if (arrayEnd === -1) {
+        return content;
+    }
+    // D. Replace version within the block
+    const block = content.slice(arrayStart, arrayEnd + 1);
+    const versionPattern = /(['"])version\1(\s*=>\s*)(['"])[^'"]*\3/;
+    const newBlock = block.replace(versionPattern, (_, q1, arrow, q3) => {
+        return `${q1}version${q1}${arrow}${q3}${version}${q3}`;
+    });
+    if (newBlock === block) {
+        return content;
+    }
+    return content.slice(0, arrayStart) + newBlock + content.slice(arrayEnd + 1);
+}

package/dist/process.d.ts

@@ -0,0 +1,12 @@
+/** Read a UTF-8 file, stripping BOM if present */
+export declare function readText(filePath: string): string;
+export interface HeaderMapping {
+    type: 'theme' | 'plugin';
+    slug: string;
+    entityDir: string;
+    /** Base path to resolve TGM file from (usually the theme's PHP source dir) */
+    tgmBasePath: string;
+    /** Subdirectory within entityDir containing PHP source files */
+    phpSrc?: string;
+}
+export declare function processMapping(mapping: HeaderMapping): void;

package/dist/process.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { buildComment, buildReadmeBlock, replaceComment, replaceReadmeBlock } from './core.js';
+import { patchTgmVersion } from './patch-tgm.js';
+import { themeStyleFromPkg, themeReadmeFromPkg, wpThemeStyle, wpThemeReadme } from './wp-theme.js';
+import { pluginHeaderFromPkg, pluginReadmeFromPkg, wpPluginHeader, wpPluginReadme } from './wp-plugin.js';
+/** Read a UTF-8 file, stripping BOM if present */
+export function readText(filePath) {
+    return readFileSync(filePath, 'utf-8').replace(/^\uFEFF/, '');
+}
+export function processMapping(mapping) {
+    const phpSrc = mapping.phpSrc ?? 'src/php';
+    const pkgPath = resolve(mapping.entityDir, 'package.json');
+    if (!existsSync(pkgPath)) {
+        return;
+    }
+    const pkg = JSON.parse(readText(pkgPath));
+    const wp = pkg['wp'] ?? {};
+    if (mapping.type === 'theme') {
+        if (!wp['theme']) {
+            return;
+        }
+        // style.css
+        const styleConfig = themeStyleFromPkg(pkg, mapping.slug);
+        writeFileSync(resolve(mapping.entityDir, phpSrc, 'style.css'), buildComment(wpThemeStyle(styleConfig)));
+        // readme.txt
+        const themeReadmePath = resolve(mapping.entityDir, phpSrc, 'readme.txt');
+        if (existsSync(themeReadmePath)) {
+            const readmeContent = readText(themeReadmePath);
+            const readmeConfig = themeReadmeFromPkg(pkg, mapping.slug);
+            const block = buildReadmeBlock(readmeConfig.name, wpThemeReadme(readmeConfig));
+            writeFileSync(themeReadmePath, replaceReadmeBlock(readmeContent, block) ?? block + readmeContent);
+        }
+    }
+    else {
+        if (!wp['plugin']) {
+            return;
+        }
+        const version = pkg['version'] ?? '1.0.0';
+        // Plugin PHP header
+        const pluginPhpPath = resolve(mapping.entityDir, phpSrc, `${mapping.slug}.php`);
+        if (existsSync(pluginPhpPath)) {
+            const content = readText(pluginPhpPath);
+            const headerConfig = pluginHeaderFromPkg(pkg, mapping.slug);
+            const comment = buildComment(wpPluginHeader(headerConfig));
+            const replaced = replaceComment(content, comment);
+            if (replaced !== null) {
+                const normalized = replaced.replace(/^\s*<\?(?:php|PHP)?\s*/, '');
+                writeFileSync(pluginPhpPath, `<?php\n${normalized.trimStart()}`);
+            }
+            else {
+                const stripped = content.replace(/^\s*<\?(?:php|PHP)?\s*/, '');
+                writeFileSync(pluginPhpPath, `<?php\n${comment}\n${stripped.trimStart()}`);
+            }
+        }
+        // readme.txt
+        const pluginReadmePath = resolve(mapping.entityDir, phpSrc, 'readme.txt');
+        if (existsSync(pluginReadmePath)) {
+            const readmeContent = readText(pluginReadmePath);
+            const readmeConfig = pluginReadmeFromPkg(pkg, mapping.slug);
+            const block = buildReadmeBlock(readmeConfig.name, wpPluginReadme(readmeConfig));
+            writeFileSync(pluginReadmePath, replaceReadmeBlock(readmeContent, block) ?? block + readmeContent);
+        }
+        // TGM version patching
+        const pluginWp = wp['plugin'];
+        const loadPluginsFile = pluginWp['loadPluginsFile'];
+        if (loadPluginsFile && mapping.tgmBasePath) {
+            const tgmFilePath = resolve(mapping.tgmBasePath, loadPluginsFile);
+            if (existsSync(tgmFilePath)) {
+                const tgmContent = readText(tgmFilePath);
+                const patched = patchTgmVersion(tgmContent, mapping.slug, version);
+                if (patched !== tgmContent) {
+                    writeFileSync(tgmFilePath, patched);
+                }
+            }
+        }
+    }
+}

package/dist/wp-helpers.d.ts

@@ -0,0 +1,7 @@
+/** Convert a hyphenated string to Title Case */
+export declare function titleCase(str: string): string;
+/**
+ * Derive a display name from pkg.name, stripping `@scope/` prefix and type suffix,
+ * then title-casing. Falls back to `titleCase(slug)`.
+ */
+export declare function deriveName(pkgName: string | undefined, slug: string, suffix: string): string;

package/dist/wp-helpers.js

@@ -0,0 +1,15 @@
+/** Convert a hyphenated string to Title Case */
+export function titleCase(str) {
+    return str
+        .split('-')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+/**
+ * Derive a display name from pkg.name, stripping `@scope/` prefix and type suffix,
+ * then title-casing. Falls back to `titleCase(slug)`.
+ */
+export function deriveName(pkgName, slug, suffix) {
+    const name = pkgName ?? '';
+    return titleCase(name.replace(/^@[\w-]+\//, '').replace(new RegExp(`${suffix}$`), '')) || titleCase(slug);
+}

package/dist/wp-plugin.d.ts

@@ -0,0 +1,64 @@
+export interface PluginHeaderConfig {
+    /** Plugin display name — always emitted */
+    name: string;
+    /** Plugin version — always emitted */
+    version: string;
+    /** Text domain — always emitted */
+    textDomain: string;
+    /** Plugin URI */
+    pluginUri?: string;
+    /** Short description */
+    description?: string;
+    /** Author name */
+    author?: string;
+    /** Author URI */
+    authorUri?: string;
+    /** License name */
+    license?: string;
+    /** License URI */
+    licenseUri?: string;
+    /** Minimum WordPress version */
+    requiresAtLeast?: string;
+    /** Minimum PHP version */
+    requiresPHP?: string;
+    /** Tested up to WordPress version */
+    testedUpTo?: string;
+    /** Update URI */
+    updateUri?: string;
+    /** Domain path for translations */
+    domainPath?: string;
+    /** Whether the plugin can only be activated network-wide (multisite) */
+    network?: string;
+    /** Comma-separated list of required plugin slugs */
+    requiresPlugins?: string;
+}
+export interface PluginReadmeConfig {
+    /** Plugin display name — used in `=== Title ===` line */
+    name: string;
+    /** Stable tag (version) */
+    stableTag: string;
+    /** WordPress.org username(s) */
+    contributors?: string;
+    /** Donate link URL */
+    donateLink?: string;
+    /** Comma-separated tag list */
+    tags?: string;
+    /** Minimum WordPress version */
+    requiresAtLeast?: string;
+    /** Tested up to WordPress version */
+    testedUpTo?: string;
+    /** Minimum PHP version */
+    requiresPHP?: string;
+    /** License name */
+    license?: string;
+    /** License URI */
+    licenseUri?: string;
+}
+/** Convert a PluginHeaderConfig to ordered WP fields */
+export declare function wpPluginHeader(config: PluginHeaderConfig): Record<string, string>;
+/** Convert a PluginReadmeConfig to ordered WP readme fields */
+export declare function wpPluginReadme(config: PluginReadmeConfig): Record<string, string>;
+/** Extract PluginHeaderConfig from a package.json object */
+export declare function pluginHeaderFromPkg(pkg: Record<string, unknown>, slug: string): PluginHeaderConfig;
+/** Extract PluginReadmeConfig from a package.json object */
+export declare function pluginReadmeFromPkg(pkg: Record<string, unknown>, slug: string): PluginReadmeConfig;

package/dist/wp-plugin.js

@@ -0,0 +1,123 @@
+import { titleCase } from './wp-helpers.js';
+/** Convert a PluginHeaderConfig to ordered WP fields */
+export function wpPluginHeader(config) {
+    const fields = {};
+    fields['Plugin Name'] = config.name;
+    if (config.pluginUri) {
+        fields['Plugin URI'] = config.pluginUri;
+    }
+    if (config.description) {
+        fields['Description'] = config.description;
+    }
+    fields['Version'] = config.version;
+    if (config.author) {
+        fields['Author'] = config.author;
+    }
+    if (config.authorUri) {
+        fields['Author URI'] = config.authorUri;
+    }
+    if (config.license) {
+        fields['License'] = config.license;
+    }
+    if (config.licenseUri) {
+        fields['License URI'] = config.licenseUri;
+    }
+    if (config.requiresAtLeast) {
+        fields['Requires at least'] = config.requiresAtLeast;
+    }
+    if (config.requiresPHP) {
+        fields['Requires PHP'] = config.requiresPHP;
+    }
+    if (config.testedUpTo) {
+        fields['Tested up to'] = config.testedUpTo;
+    }
+    if (config.updateUri) {
+        fields['Update URI'] = config.updateUri;
+    }
+    fields['Text Domain'] = config.textDomain;
+    if (config.domainPath) {
+        fields['Domain Path'] = config.domainPath;
+    }
+    if (config.network) {
+        fields['Network'] = config.network;
+    }
+    if (config.requiresPlugins) {
+        fields['Requires Plugins'] = config.requiresPlugins;
+    }
+    return fields;
+}
+/** Convert a PluginReadmeConfig to ordered WP readme fields */
+export function wpPluginReadme(config) {
+    const fields = {};
+    if (config.contributors) {
+        fields['Contributors'] = config.contributors;
+    }
+    if (config.donateLink) {
+        fields['Donate link'] = config.donateLink;
+    }
+    if (config.tags) {
+        fields['Tags'] = config.tags;
+    }
+    if (config.requiresAtLeast) {
+        fields['Requires at least'] = config.requiresAtLeast;
+    }
+    if (config.testedUpTo) {
+        fields['Tested up to'] = config.testedUpTo;
+    }
+    if (config.requiresPHP) {
+        fields['Requires PHP'] = config.requiresPHP;
+    }
+    fields['Stable tag'] = config.stableTag;
+    if (config.license) {
+        fields['License'] = config.license;
+    }
+    if (config.licenseUri) {
+        fields['License URI'] = config.licenseUri;
+    }
+    return fields;
+}
+/** Extract PluginHeaderConfig from a package.json object */
+export function pluginHeaderFromPkg(pkg, slug) {
+    const wp = pkg['wp'] ?? {};
+    const plugin = (wp['plugin'] ?? {});
+    const version = pkg['version'] ?? '1.0.0';
+    const name = plugin['name'] ?? titleCase(slug);
+    return {
+        name,
+        version,
+        textDomain: plugin['textDomain'] ?? slug,
+        pluginUri: plugin['pluginUri'],
+        description: plugin['description'],
+        author: plugin['author'],
+        authorUri: plugin['authorUri'],
+        license: plugin['license'],
+        licenseUri: plugin['licenseUri'],
+        requiresAtLeast: plugin['requiresAtLeast'],
+        requiresPHP: plugin['requiresPHP'],
+        testedUpTo: plugin['testedUpTo'],
+        updateUri: plugin['updateUri'],
+        domainPath: plugin['domainPath'],
+        network: plugin['network'],
+        requiresPlugins: plugin['requiresPlugins'],
+    };
+}
+/** Extract PluginReadmeConfig from a package.json object */
+export function pluginReadmeFromPkg(pkg, slug) {
+    const wp = pkg['wp'] ?? {};
+    const plugin = (wp['plugin'] ?? {});
+    const version = pkg['version'] ?? '1.0.0';
+    const name = plugin['name'] ?? titleCase(slug);
+    const contributors = plugin['contributors'] ?? plugin['author'];
+    return {
+        name,
+        stableTag: version,
+        contributors,
+        donateLink: plugin['donateLink'],
+        tags: plugin['tags'],
+        requiresAtLeast: plugin['requiresAtLeast'],
+        testedUpTo: plugin['testedUpTo'],
+        requiresPHP: plugin['requiresPHP'],
+        license: plugin['license'],
+        licenseUri: plugin['licenseUri'],
+    };
+}

package/dist/wp-theme.d.ts

@@ -0,0 +1,60 @@
+export interface ThemeStyleConfig {
+    /** Theme display name — always emitted */
+    name: string;
+    /** Theme version — always emitted */
+    version: string;
+    /** Text domain — always emitted */
+    textDomain: string;
+    /** Theme URI */
+    uri?: string;
+    /** Short description */
+    description?: string;
+    /** Author name */
+    author?: string;
+    /** Author URI */
+    authorUri?: string;
+    /** License name */
+    license?: string;
+    /** License URI */
+    licenseUri?: string;
+    /** Minimum WordPress version */
+    requiresAtLeast?: string;
+    /** Minimum PHP version */
+    requiresPHP?: string;
+    /** Tested up to WordPress version */
+    testedUpTo?: string;
+    /** Comma-separated tag list */
+    tags?: string;
+    /** Parent theme slug (for child themes) */
+    template?: string;
+    /** Domain path for translations */
+    domainPath?: string;
+    /** Update URI */
+    updateUri?: string;
+}
+export interface ThemeReadmeConfig {
+    /** Theme display name — used in `=== Title ===` line */
+    name: string;
+    /** Stable tag (version) */
+    stableTag: string;
+    /** WordPress.org username(s) */
+    contributors?: string;
+    /** Minimum WordPress version */
+    requiresAtLeast?: string;
+    /** Tested up to WordPress version */
+    testedUpTo?: string;
+    /** Minimum PHP version */
+    requiresPHP?: string;
+    /** License name */
+    license?: string;
+    /** License URI */
+    licenseUri?: string;
+}
+/** Convert a ThemeStyleConfig to ordered WP fields */
+export declare function wpThemeStyle(config: ThemeStyleConfig): Record<string, string>;
+/** Convert a ThemeReadmeConfig to ordered WP readme fields */
+export declare function wpThemeReadme(config: ThemeReadmeConfig): Record<string, string>;
+/** Extract ThemeStyleConfig from a package.json object */
+export declare function themeStyleFromPkg(pkg: Record<string, unknown>, slug: string): ThemeStyleConfig;
+/** Extract ThemeReadmeConfig from a package.json object */
+export declare function themeReadmeFromPkg(pkg: Record<string, unknown>, slug: string): ThemeReadmeConfig;

package/dist/wp-theme.js

@@ -0,0 +1,115 @@
+import { deriveName } from './wp-helpers.js';
+/** Convert a ThemeStyleConfig to ordered WP fields */
+export function wpThemeStyle(config) {
+    const fields = {};
+    fields['Theme Name'] = config.name;
+    if (config.uri) {
+        fields['Theme URI'] = config.uri;
+    }
+    if (config.description) {
+        fields['Description'] = config.description;
+    }
+    fields['Version'] = config.version;
+    if (config.author) {
+        fields['Author'] = config.author;
+    }
+    if (config.authorUri) {
+        fields['Author URI'] = config.authorUri;
+    }
+    if (config.license) {
+        fields['License'] = config.license;
+    }
+    if (config.licenseUri) {
+        fields['License URI'] = config.licenseUri;
+    }
+    if (config.requiresAtLeast) {
+        fields['Requires at least'] = config.requiresAtLeast;
+    }
+    if (config.requiresPHP) {
+        fields['Requires PHP'] = config.requiresPHP;
+    }
+    if (config.testedUpTo) {
+        fields['Tested up to'] = config.testedUpTo;
+    }
+    if (config.tags) {
+        fields['Tags'] = config.tags;
+    }
+    if (config.template) {
+        fields['Template'] = config.template;
+    }
+    fields['Text Domain'] = config.textDomain;
+    if (config.domainPath) {
+        fields['Domain Path'] = config.domainPath;
+    }
+    if (config.updateUri) {
+        fields['Update URI'] = config.updateUri;
+    }
+    return fields;
+}
+/** Convert a ThemeReadmeConfig to ordered WP readme fields */
+export function wpThemeReadme(config) {
+    const fields = {};
+    if (config.contributors) {
+        fields['Contributors'] = config.contributors;
+    }
+    if (config.requiresAtLeast) {
+        fields['Requires at least'] = config.requiresAtLeast;
+    }
+    if (config.testedUpTo) {
+        fields['Tested up to'] = config.testedUpTo;
+    }
+    if (config.requiresPHP) {
+        fields['Requires PHP'] = config.requiresPHP;
+    }
+    fields['Stable tag'] = config.stableTag;
+    if (config.license) {
+        fields['License'] = config.license;
+    }
+    if (config.licenseUri) {
+        fields['License URI'] = config.licenseUri;
+    }
+    return fields;
+}
+/** Extract ThemeStyleConfig from a package.json object */
+export function themeStyleFromPkg(pkg, slug) {
+    const wp = pkg['wp'] ?? {};
+    const theme = (wp['theme'] ?? {});
+    const version = pkg['version'] ?? '1.0.0';
+    const name = deriveName(pkg['name'], slug, '-theme');
+    return {
+        name,
+        version,
+        textDomain: theme['textDomain'] ?? slug,
+        uri: theme['uri'],
+        description: theme['description'],
+        author: theme['author'],
+        authorUri: theme['authorUri'],
+        license: theme['license'],
+        licenseUri: theme['licenseUri'],
+        requiresAtLeast: theme['requiresAtLeast'],
+        requiresPHP: theme['requiresPHP'],
+        testedUpTo: theme['testedUpTo'],
+        tags: theme['tags'],
+        template: theme['template'],
+        domainPath: theme['domainPath'],
+        updateUri: theme['updateUri'],
+    };
+}
+/** Extract ThemeReadmeConfig from a package.json object */
+export function themeReadmeFromPkg(pkg, slug) {
+    const wp = pkg['wp'] ?? {};
+    const theme = (wp['theme'] ?? {});
+    const version = pkg['version'] ?? '1.0.0';
+    const name = deriveName(pkg['name'], slug, '-theme');
+    const contributors = theme['contributors'] ?? theme['author'];
+    return {
+        name,
+        stableTag: version,
+        contributors,
+        requiresAtLeast: theme['requiresAtLeast'],
+        testedUpTo: theme['testedUpTo'],
+        requiresPHP: theme['requiresPHP'],
+        license: theme['license'],
+        licenseUri: theme['licenseUri'],
+    };
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@artemsemkin/wp-headers",
+  "version": "1.1.0",
+  "description": "Generate and patch WordPress file headers (style.css, plugin PHP, readme.txt, TGM)",
+  "license": "MIT",
+  "author": "Artem Semkin",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/artkrsk/wp-headers.git"
+  },
+  "homepage": "https://github.com/artkrsk/wp-headers#readme",
+  "bugs": {
+    "url": "https://github.com/artkrsk/wp-headers/issues"
+  },
+  "keywords": [
+    "wordpress",
+    "headers",
+    "wp-headers",
+    "style-css",
+    "readme-txt",
+    "plugin-header"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "pnpm build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "@vitest/coverage-v8": "3.2.4",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}