@wp-typia/project-tools 0.24.4 → 0.24.5

package/dist/runtime/package-managers.js

@@ -1,236 +1 @@
-import fs from "node:fs";
-import path from "node:path";
-import { readJsonFileSync } from "./json-utils.js";
-const PACKAGE_MANAGER_DATA = [
-    {
-        id: "bun",
-        label: "Bun",
-        packageManagerField: "bun@1.3.11",
-        installCommand: "bun install",
-        frozenInstallCommand: "bun install --frozen-lockfile",
-    },
-    {
-        id: "npm",
-        label: "npm",
-        packageManagerField: "npm@11.6.1",
-        installCommand: "npm install --no-audit",
-        frozenInstallCommand: "npm ci",
-    },
-    {
-        id: "pnpm",
-        label: "pnpm",
-        packageManagerField: "pnpm@8.3.1",
-        installCommand: "pnpm install",
-        frozenInstallCommand: "pnpm install --frozen-lockfile",
-    },
-    {
-        id: "yarn",
-        label: "Yarn",
-        packageManagerField: "yarn@3.2.4",
-        installCommand: "yarn install",
-        frozenInstallCommand: "yarn install --frozen-lockfile",
-    },
-];
-const PACKAGE_MANAGER_LOCKFILE_SIGNALS = [
-    { id: "bun", filenames: ["bun.lock", "bun.lockb"] },
-    { id: "pnpm", filenames: ["pnpm-lock.yaml"] },
-    {
-        id: "yarn",
-        filenames: ["yarn.lock", ".pnp.cjs", ".pnp.loader.mjs", ".yarnrc.yml"],
-    },
-    { id: "npm", filenames: ["package-lock.json", "npm-shrinkwrap.json"] },
-];
-export const PACKAGE_MANAGER_IDS = PACKAGE_MANAGER_DATA.map((manager) => manager.id);
-export const PACKAGE_MANAGERS = Object.freeze(Object.fromEntries(PACKAGE_MANAGER_DATA.map((manager) => [manager.id, manager])));
-const DEV_INSTALL_FLAGS = {
-    bun: "add -d",
-    npm: "install --save-dev",
-    pnpm: "add -D",
-    yarn: "add -D",
-};
-const STOP_CHARS = new Set(["\n", "\r", "`", "\"", "'", ")", "]", "}", "!", ",", "."]);
-export function getPackageManager(id) {
-    const manager = PACKAGE_MANAGERS[id];
-    if (!manager) {
-        throw new Error(`Unknown package manager "${id}". Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}`);
-    }
-    return manager;
-}
-/**
- * Parse a normalized package-manager id from a package.json `packageManager` field.
- *
- * @param packageManagerField Raw field value such as `pnpm@8.3.1`.
- * @returns A supported package manager id, or null when the field is missing or unsupported.
- */
-export function parsePackageManagerField(packageManagerField) {
-    const packageManagerId = packageManagerField?.split("@", 1)[0];
-    return PACKAGE_MANAGER_IDS.includes(packageManagerId)
-        ? packageManagerId
-        : null;
-}
-function readPackageManagerField(projectDir) {
-    try {
-        const packageJsonPath = path.join(projectDir, "package.json");
-        if (!fs.existsSync(packageJsonPath)) {
-            return undefined;
-        }
-        const manifest = readJsonFileSync(packageJsonPath, {
-            context: "package manager manifest",
-        });
-        return typeof manifest.packageManager === "string"
-            ? manifest.packageManager
-            : undefined;
-    }
-    catch {
-        // Package manager inference intentionally falls back to lockfile signals
-        // when package.json is absent or malformed.
-        return undefined;
-    }
-}
-/**
- * Infer the package manager used by a project from package.json and lockfile signals.
- *
- * `packageManager` fields take precedence over lockfiles, then lockfile and PnP
- * markers are checked in Bun, pnpm, Yarn, npm order. npm remains the fallback so
- * generated projects without explicit metadata keep the historical CLI default.
- *
- * @param projectDir Project root to inspect.
- * @param packageManagerField Optional already-read package.json field.
- * @returns The inferred package manager id.
- */
-export function inferPackageManagerId(projectDir, packageManagerField) {
-    const fieldPackageManager = parsePackageManagerField(packageManagerField) ??
-        parsePackageManagerField(readPackageManagerField(projectDir));
-    if (fieldPackageManager) {
-        return fieldPackageManager;
-    }
-    for (const signal of PACKAGE_MANAGER_LOCKFILE_SIGNALS) {
-        if (signal.filenames.some((filename) => fs.existsSync(path.join(projectDir, filename)))) {
-            return signal.id;
-        }
-    }
-    return "npm";
-}
-export function getPackageManagerSelectOptions() {
-    return PACKAGE_MANAGER_DATA.map((manager) => ({
-        label: manager.label,
-        value: manager.id,
-        hint: manager.installCommand,
-    }));
-}
-export function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
-    const args = extraArgs.trim();
-    if (packageManagerId === "bun") {
-        return args ? `bun run ${scriptName} ${args}` : `bun run ${scriptName}`;
-    }
-    if (packageManagerId === "npm") {
-        return args ? `npm run ${scriptName} -- ${args}` : `npm run ${scriptName}`;
-    }
-    if (packageManagerId === "pnpm") {
-        return args ? `pnpm run ${scriptName} ${args}` : `pnpm run ${scriptName}`;
-    }
-    return args ? `yarn run ${scriptName} ${args}` : `yarn run ${scriptName}`;
-}
-export function formatInstallCommand(packageManagerId) {
-    return getPackageManager(packageManagerId).installCommand;
-}
-/**
- * Format a package-manager-specific devDependency install command.
- *
- * @param packageManagerId Package manager identifier.
- * @param packages Package specifiers to add as devDependencies.
- * @returns Command string suitable for shell execution.
- */
-export function formatAddDevDependenciesCommand(packageManagerId, packages) {
-    if (packages.length === 0) {
-        return formatInstallCommand(packageManagerId);
-    }
-    return `${packageManagerId} ${DEV_INSTALL_FLAGS[packageManagerId]} ${packages.join(" ")}`;
-}
-/**
- * Format a package-manager-specific one-off package execution command.
- *
- * @param packageManagerId Package manager identifier.
- * @param packageName Executable package name.
- * @param extraArgs Optional extra CLI arguments appended after the package name.
- * @returns Command string suitable for shell execution.
- */
-export function formatPackageExecCommand(packageManagerId, packageName, extraArgs = "") {
-    const args = extraArgs.trim();
-    if (packageManagerId === "bun") {
-        return args ? `bunx ${packageName} ${args}` : `bunx ${packageName}`;
-    }
-    if (packageManagerId === "npm") {
-        return args ? `npx --yes ${packageName} ${args}` : `npx --yes ${packageName}`;
-    }
-    if (packageManagerId === "pnpm") {
-        return args ? `pnpm dlx ${packageName} ${args}` : `pnpm dlx ${packageName}`;
-    }
-    return args ? `yarn dlx ${packageName} ${args}` : `yarn dlx ${packageName}`;
-}
-function consumeCommandArguments(content, startIndex) {
-    let cursor = startIndex;
-    let args = "";
-    while (cursor < content.length) {
-        const current = content[cursor];
-        if (STOP_CHARS.has(current) ||
-            content.startsWith("&&", cursor) ||
-            content.startsWith("||", cursor) ||
-            current === ";") {
-            break;
-        }
-        args += current;
-        cursor += 1;
-    }
-    return {
-        args: args.trim(),
-        cursor,
-    };
-}
-function replaceBunRunCommands(content, packageManagerId) {
-    const marker = "bun run ";
-    let result = "";
-    let cursor = 0;
-    while (cursor < content.length) {
-        const index = content.indexOf(marker, cursor);
-        if (index === -1) {
-            result += content.slice(cursor);
-            break;
-        }
-        if (index > 0 && /[A-Za-z0-9_-]/.test(content[index - 1])) {
-            result += content.slice(cursor, index + marker.length);
-            cursor = index + marker.length;
-            continue;
-        }
-        result += content.slice(cursor, index);
-        const scriptNameStart = index + marker.length;
-        const scriptNameMatch = /^[A-Za-z0-9:_-]+/.exec(content.slice(scriptNameStart));
-        if (!scriptNameMatch) {
-            result += marker;
-            cursor = scriptNameStart;
-            continue;
-        }
-        const scriptName = scriptNameMatch[0];
-        const argsStart = scriptNameStart + scriptName.length;
-        const { args, cursor: nextCursor } = consumeCommandArguments(content, argsStart);
-        result += formatRunScript(packageManagerId, scriptName, args);
-        cursor = nextCursor;
-    }
-    return result;
-}
-function replaceDevDependencyInstalls(content, packageManagerId) {
-    return content.replace(/\bbun add -d ([^\s&|;`"'()]+)\b/g, (_, packageName) => {
-        if (packageManagerId === "bun") {
-            return `bun add -d ${packageName}`;
-        }
-        return `${packageManagerId} ${DEV_INSTALL_FLAGS[packageManagerId]} ${packageName}`;
-    });
-}
-export function transformPackageManagerText(content, packageManagerId) {
-    const manager = getPackageManager(packageManagerId);
-    return replaceDevDependencyInstalls(replaceBunRunCommands(content
-        .replace(/\bbun install --frozen-lockfile\b/g, manager.frozenInstallCommand)
-        .replace(/\bbun install\b/g, manager.installCommand), packageManagerId), packageManagerId)
-        .replace(/\s*&&\s*/g, " && ")
-        .replace(/\s*\|\|\s*/g, " || ");
-}
+export * from "./shared/package-managers.js";

package/dist/runtime/package-versions.d.ts

@@ -1,63 +1 @@
-export interface PackageVersions {
-    apiClientPackageVersion: string;
-    blockRuntimePackageVersion: string;
-    blockTypesPackageVersion: string;
-    projectToolsPackageVersion: string;
-    restPackageVersion: string;
-    tsxPackageVersion: string;
-    typiaPackageVersion: string;
-    typiaUnpluginPackageVersion: string;
-    typescriptPackageVersion: string;
-    wpTypiaPackageExactVersion: string;
-    wpTypiaPackageVersion: string;
-}
-/**
- * Explicit fallback ranges for managed WordPress-facing workspace dependencies.
- *
- * These remain centralized here even when individual scaffold flows resolve a
- * fresher local or installed manifest version first, so add-command defaults do
- * not drift across runtime modules.
- */
-export declare const DEFAULT_WORDPRESS_ABILITIES_VERSION = "^0.10.0";
-export declare const DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = "^0.9.0";
-export declare const DEFAULT_WORDPRESS_CORE_DATA_VERSION = "^7.44.0";
-export declare const DEFAULT_WORDPRESS_DATA_VERSION = "^9.28.0";
-export declare const DEFAULT_WORDPRESS_DATAVIEWS_VERSION = "^14.1.0";
-export declare const DEFAULT_WORDPRESS_ENV_VERSION = "^11.2.0";
-export declare const DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = "^0.1.1";
-/**
- * Resolve a managed package version range from linked workspace packages first,
- * then installed package manifests, while preserving the shared normalization
- * and manifest fingerprinting rules used by `getPackageVersions()`.
- *
- * @param packageName npm package whose manifest version should be consulted.
- * @param fallback Canonical range to use when no usable manifest version exists.
- * @param workspacePackageDirName Optional sibling monorepo package directory name.
- * @returns A normalized semver range suitable for generated dependency entries.
- */
-export declare function resolveManagedPackageVersionRange(options: {
-    fallback: string;
-    packageName: string;
-    workspacePackageDirName?: string;
-}): string;
-/**
- * Clears the in-memory cache used by `getPackageVersions()`.
- *
- * Long-lived processes can call this after regenerating or updating package
- * manifests when they want the next lookup to recompute version metadata
- * synchronously from disk.
- */
-export declare function clearPackageVersionsCache(): void;
-/**
- * Backwards-compatible alias for integrations that adopted the original
- * internal invalidation name before the public cache policy was documented.
- */
-export declare function invalidatePackageVersionsCache(): void;
-/**
- * Resolve package versions used in generated manifests and onboarding text.
- *
- * The lookup keeps a process-local cached result while recomputing manifest
- * fingerprints on each call. When the relevant package metadata changes on
- * disk, the cache key changes and the returned version object is refreshed.
- */
-export declare function getPackageVersions(): PackageVersions;
+export * from "./shared/package-versions.js";

package/dist/runtime/package-versions.js

@@ -1,259 +1 @@
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { getOptionalNodeErrorCode } from './fs-async.js';
-import { safeJsonParse } from './json-utils.js';
-import { PROJECT_TOOLS_PACKAGE_ROOT } from './template-registry.js';
-const require = createRequire(import.meta.url);
-const DEFAULT_VERSION_RANGE = '^0.0.0';
-const DEFAULT_EXACT_VERSION = '0.0.0';
-const DEFAULT_TSX_PACKAGE_VERSION = '^4.20.5';
-const DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = '^12.0.1';
-/**
- * Explicit fallback ranges for managed WordPress-facing workspace dependencies.
- *
- * These remain centralized here even when individual scaffold flows resolve a
- * fresher local or installed manifest version first, so add-command defaults do
- * not drift across runtime modules.
- */
-export const DEFAULT_WORDPRESS_ABILITIES_VERSION = '^0.10.0';
-export const DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = '^0.9.0';
-export const DEFAULT_WORDPRESS_CORE_DATA_VERSION = '^7.44.0';
-export const DEFAULT_WORDPRESS_DATA_VERSION = '^9.28.0';
-export const DEFAULT_WORDPRESS_DATAVIEWS_VERSION = '^14.1.0';
-export const DEFAULT_WORDPRESS_ENV_VERSION = '^11.2.0';
-export const DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = '^0.1.1';
-let cachedPackageVersions = null;
-function normalizeVersionRange(value) {
-    const trimmed = value?.trim();
-    if (!trimmed) {
-        return DEFAULT_VERSION_RANGE;
-    }
-    if (trimmed.startsWith('workspace:')) {
-        return DEFAULT_VERSION_RANGE;
-    }
-    return /^[~^<>=]/.test(trimmed) ? trimmed : `^${trimmed}`;
-}
-function normalizeExactVersion(value) {
-    const trimmed = value?.trim();
-    if (!trimmed) {
-        return DEFAULT_EXACT_VERSION;
-    }
-    if (trimmed.startsWith('workspace:')) {
-        return DEFAULT_EXACT_VERSION;
-    }
-    return trimmed.replace(/^[~^<>=]+/, '');
-}
-function normalizeVersionRangeWithFallback(value, fallback) {
-    const normalized = normalizeVersionRange(value);
-    return normalized === DEFAULT_VERSION_RANGE ? fallback : normalized;
-}
-function createContentFingerprint(source) {
-    let hash = 2166136261;
-    for (let index = 0; index < source.length; index += 1) {
-        hash ^= source.charCodeAt(index);
-        hash = Math.imul(hash, 16777619);
-    }
-    return (hash >>> 0).toString(16);
-}
-function readPackageManifestFile(packageJsonPath) {
-    const fileDescriptor = fs.openSync(packageJsonPath, 'r');
-    try {
-        // Keep cache metadata and manifest contents tied to one opened file, so a
-        // concurrent path replacement cannot mix stats from one manifest with
-        // contents from another. The content fingerprint remains the final guard.
-        const stats = fs.fstatSync(fileDescriptor);
-        const source = fs.readFileSync(fileDescriptor, 'utf8');
-        return { source, stats };
-    }
-    finally {
-        fs.closeSync(fileDescriptor);
-    }
-}
-function resolvePackageManifestLocation(packageJsonPath) {
-    try {
-        const { source, stats } = readPackageManifestFile(packageJsonPath);
-        return {
-            cacheKey: `file:${packageJsonPath}:${stats.ino}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.size}:${createContentFingerprint(source)}`,
-            packageJsonPath,
-            source,
-        };
-    }
-    catch (error) {
-        if (getOptionalNodeErrorCode(error) === 'ENOENT') {
-            return {
-                cacheKey: `missing-file:${packageJsonPath}`,
-                packageJsonPath: null,
-                source: null,
-            };
-        }
-        throw error;
-    }
-}
-function readPackageManifest(location) {
-    if (!location.packageJsonPath || location.source === null) {
-        return null;
-    }
-    return safeJsonParse(location.source, {
-        context: 'package version manifest',
-        filePath: location.packageJsonPath,
-    });
-}
-function tryReadPackageManifest(location) {
-    if (!location) {
-        return null;
-    }
-    try {
-        return readPackageManifest(location);
-    }
-    catch {
-        return null;
-    }
-}
-function resolveInstalledPackageManifestLocation(packageName) {
-    try {
-        return resolvePackageManifestLocation(require.resolve(`${packageName}/package.json`));
-    }
-    catch (error) {
-        if (getOptionalNodeErrorCode(error) === 'MODULE_NOT_FOUND') {
-            return {
-                cacheKey: `missing-module:${packageName}`,
-                packageJsonPath: null,
-                source: null,
-            };
-        }
-        throw error;
-    }
-}
-function composePackageVersionsCacheKey(locations) {
-    return locations.map((location) => location.cacheKey).join('|');
-}
-/**
- * Resolve a managed package version range from linked workspace packages first,
- * then installed package manifests, while preserving the shared normalization
- * and manifest fingerprinting rules used by `getPackageVersions()`.
- *
- * @param packageName npm package whose manifest version should be consulted.
- * @param fallback Canonical range to use when no usable manifest version exists.
- * @param workspacePackageDirName Optional sibling monorepo package directory name.
- * @returns A normalized semver range suitable for generated dependency entries.
- */
-export function resolveManagedPackageVersionRange(options) {
-    const workspaceManifestLocation = options.workspacePackageDirName
-        ? resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', options.workspacePackageDirName, 'package.json'))
-        : null;
-    const installedManifestLocation = resolveInstalledPackageManifestLocation(options.packageName);
-    const workspaceManifest = tryReadPackageManifest(workspaceManifestLocation);
-    const installedManifest = tryReadPackageManifest(installedManifestLocation);
-    return normalizeVersionRangeWithFallback(workspaceManifest?.version ?? installedManifest?.version, options.fallback);
-}
-/**
- * Clears the in-memory cache used by `getPackageVersions()`.
- *
- * Long-lived processes can call this after regenerating or updating package
- * manifests when they want the next lookup to recompute version metadata
- * synchronously from disk.
- */
-export function clearPackageVersionsCache() {
-    cachedPackageVersions = null;
-}
-/**
- * Backwards-compatible alias for integrations that adopted the original
- * internal invalidation name before the public cache policy was documented.
- */
-export function invalidatePackageVersionsCache() {
-    clearPackageVersionsCache();
-}
-/**
- * Resolve package versions used in generated manifests and onboarding text.
- *
- * The lookup keeps a process-local cached result while recomputing manifest
- * fingerprints on each call. When the relevant package metadata changes on
- * disk, the cache key changes and the returned version object is refreshed.
- */
-export function getPackageVersions() {
-    const createManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, 'package.json'));
-    const monorepoManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', '..', 'package.json'));
-    const blockRuntimeManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', 'wp-typia-block-runtime', 'package.json'));
-    const blockTypesManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', 'wp-typia-block-types', 'package.json'));
-    const wpTypiaManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', 'wp-typia', 'package.json'));
-    const installedProjectToolsManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/project-tools');
-    const installedApiClientManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/api-client');
-    const installedBlockRuntimeManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/block-runtime');
-    const installedBlockTypesManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/block-types');
-    const installedRestManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/rest');
-    const installedTsxManifestLocation = resolveInstalledPackageManifestLocation('tsx');
-    const installedTypiaManifestLocation = resolveInstalledPackageManifestLocation('typia');
-    const installedTypiaUnpluginManifestLocation = resolveInstalledPackageManifestLocation('@typia/unplugin');
-    const installedTypescriptManifestLocation = resolveInstalledPackageManifestLocation('typescript');
-    const installedWpTypiaManifestLocation = resolveInstalledPackageManifestLocation('wp-typia');
-    const cacheKey = composePackageVersionsCacheKey([
-        createManifestLocation,
-        monorepoManifestLocation,
-        blockRuntimeManifestLocation,
-        blockTypesManifestLocation,
-        wpTypiaManifestLocation,
-        installedProjectToolsManifestLocation,
-        installedApiClientManifestLocation,
-        installedBlockRuntimeManifestLocation,
-        installedBlockTypesManifestLocation,
-        installedRestManifestLocation,
-        installedTsxManifestLocation,
-        installedTypiaManifestLocation,
-        installedTypiaUnpluginManifestLocation,
-        installedTypescriptManifestLocation,
-        installedWpTypiaManifestLocation,
-    ]);
-    if (cachedPackageVersions?.cacheKey === cacheKey) {
-        return cachedPackageVersions.versions;
-    }
-    const createManifest = readPackageManifest(createManifestLocation) ??
-        readPackageManifest(installedProjectToolsManifestLocation) ??
-        {};
-    const monorepoManifest = readPackageManifest(monorepoManifestLocation) ?? {};
-    const blockRuntimeManifest = readPackageManifest(blockRuntimeManifestLocation) ??
-        readPackageManifest(installedBlockRuntimeManifestLocation) ??
-        {};
-    const blockTypesManifest = readPackageManifest(blockTypesManifestLocation) ??
-        readPackageManifest(installedBlockTypesManifestLocation) ??
-        {};
-    const wpTypiaManifest = readPackageManifest(wpTypiaManifestLocation) ??
-        readPackageManifest(installedWpTypiaManifestLocation) ??
-        {};
-    const blockRuntimeDependencyVersion = normalizeVersionRange(createManifest.dependencies?.['@wp-typia/block-runtime']);
-    const blockTypesDependencyVersion = normalizeVersionRange(createManifest.dependencies?.['@wp-typia/block-types']);
-    const versions = {
-        apiClientPackageVersion: normalizeVersionRange(createManifest.dependencies?.['@wp-typia/api-client'] ??
-            readPackageManifest(installedApiClientManifestLocation)?.version),
-        blockRuntimePackageVersion: blockRuntimeDependencyVersion !== DEFAULT_VERSION_RANGE
-            ? blockRuntimeDependencyVersion
-            : normalizeVersionRange(blockRuntimeManifest.version),
-        blockTypesPackageVersion: blockTypesDependencyVersion !== DEFAULT_VERSION_RANGE
-            ? blockTypesDependencyVersion
-            : normalizeVersionRange(blockTypesManifest.version),
-        projectToolsPackageVersion: normalizeVersionRange(createManifest.version),
-        restPackageVersion: normalizeVersionRange(createManifest.dependencies?.['@wp-typia/rest'] ??
-            readPackageManifest(installedRestManifestLocation)?.version),
-        tsxPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.tsx ??
-            monorepoManifest.devDependencies?.tsx ??
-            readPackageManifest(installedTsxManifestLocation)?.version, DEFAULT_TSX_PACKAGE_VERSION),
-        typiaPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.typia ??
-            monorepoManifest.devDependencies?.typia ??
-            createManifest.dependencies?.typia ??
-            readPackageManifest(installedTypiaManifestLocation)?.version, DEFAULT_VERSION_RANGE),
-        typiaUnpluginPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.['@typia/unplugin'] ??
-            monorepoManifest.devDependencies?.['@typia/unplugin'] ??
-            readPackageManifest(installedTypiaUnpluginManifestLocation)?.version, DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION),
-        typescriptPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.typescript ??
-            monorepoManifest.devDependencies?.typescript ??
-            createManifest.dependencies?.typescript ??
-            readPackageManifest(installedTypescriptManifestLocation)?.version, DEFAULT_VERSION_RANGE),
-        wpTypiaPackageExactVersion: normalizeExactVersion(wpTypiaManifest.version),
-        wpTypiaPackageVersion: normalizeVersionRange(wpTypiaManifest.version),
-    };
-    cachedPackageVersions = {
-        cacheKey,
-        versions,
-    };
-    return versions;
-}
+export * from "./shared/package-versions.js";

package/dist/runtime/pattern-catalog-section-roles.d.ts

@@ -1,101 +1 @@
-import { type ParsedBlockPatternBlock } from "@wp-typia/block-runtime/metadata-core";
-import type { PatternCatalogDiagnostic, PatternCatalogEntry } from "./pattern-catalog.js";
-/**
- * Validates section role slugs used by pattern manifests and content markers.
- */
-export declare const PATTERN_SECTION_ROLE_PATTERN: RegExp;
-/**
- * Convention used to discover section role markers in serialized pattern
- * content. Defaults target `core/group` wrappers with a `section` base class,
- * `section--{role}` role class tokens, and `metadata.sectionRole` attributes.
- */
-export type PatternCatalogSectionRoleConvention = {
-    /**
-     * Serialized block name used as the section wrapper. Defaults to
-     * `core/group`.
-     */
-    wrapperBlockName?: string;
-    /**
-     * Optional class that marks a wrapper block as section-like even when the
-     * role marker is missing. Defaults to `section`.
-     */
-    baseClassName?: string;
-    /**
-     * Class token pattern where exactly one `{role}` placeholder is replaced by
-     * the section role slug. Defaults to `section--{role}`.
-     */
-    roleClassNamePattern?: string;
-    /**
-     * Dot-separated block attribute paths that can carry role slugs. Defaults to
-     * `metadata.sectionRole`.
-     */
-    roleAttributePaths?: readonly string[];
-    /**
-     * Warn when a full pattern repeats the same section role marker. Defaults to
-     * `false`.
-     */
-    requireUniqueFullPatternRoles?: boolean;
-};
-/**
- * Section wrapper match extracted from a parsed WordPress block tree.
- */
-export type PatternCatalogSectionRoleMatch = {
-    blockName: string;
-    blockPath: string;
-    roles: readonly string[];
-};
-/**
- * Fully resolved section-role marker convention with its compiled class matcher.
- */
-export type NormalizedPatternCatalogSectionRoleConvention = Required<PatternCatalogSectionRoleConvention> & {
-    /**
-     * Compiled matcher for role class tokens produced from `roleClassNamePattern`.
-     */
-    roleClassNamePatternRegExp: RegExp;
-};
-/**
- * Resolve a section-role convention and compile its class-token matcher.
- *
- * @param convention Optional marker convention override.
- * @returns A fully populated convention ready for repeated block traversal.
- * @throws When `roleClassNamePattern` does not contain exactly one `{role}` placeholder.
- */
-export declare function normalizePatternCatalogSectionRoleConvention(convention?: PatternCatalogSectionRoleConvention): NormalizedPatternCatalogSectionRoleConvention;
-/**
- * Extract section role slugs from serialized block attributes using the
- * configured class and metadata marker convention.
- *
- * @param attributes Parsed block attributes from serialized pattern content.
- * @param convention Optional marker convention override.
- * @returns Unique role marker values in discovery order.
- */
-export declare function extractPatternSectionRolesFromAttributes(attributes: Record<string, unknown>, convention?: PatternCatalogSectionRoleConvention): string[];
-/**
- * Find section wrapper blocks and their role markers in parsed pattern content.
- *
- * @param blocks Parsed block tree returned by `validateBlockPatternContentNesting`.
- * @param convention Optional marker convention override.
- * @returns Section wrapper matches with serialized block paths.
- */
-export declare function extractPatternSectionRoleMatches(blocks: readonly ParsedBlockPatternBlock[], convention?: PatternCatalogSectionRoleConvention): PatternCatalogSectionRoleMatch[];
-/**
- * Build the known valid section-role set from pattern catalog entries.
- *
- * @param patterns Catalog entries that may declare a `sectionRole`.
- * @returns Valid section role slugs declared by the catalog.
- */
-export declare function collectKnownPatternSectionRoles(patterns: readonly Pick<PatternCatalogEntry, "sectionRole">[]): ReadonlySet<string>;
-/**
- * Validate serialized pattern content against the catalog section-role rules.
- *
- * @param options Pattern content, marker convention, known roles, and diagnostic context.
- * @returns Diagnostics for invalid, missing, mismatched, unknown, or duplicate section-role markers.
- */
-export declare function validatePatternContentSectionRoles({ content, contentFile, convention, knownSectionRoles, label, pattern, }: {
-    content: string;
-    contentFile: string;
-    convention: NormalizedPatternCatalogSectionRoleConvention;
-    knownSectionRoles: ReadonlySet<string>;
-    label: string;
-    pattern: PatternCatalogEntry;
-}): PatternCatalogDiagnostic[];
+export * from "./add/pattern-catalog-section-roles.js";