@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/ai-feature-capability.d.ts

@@ -1,114 +1 @@
-/** Declares whether a generated feature is optional or required at runtime. */
-export type AiFeatureCapabilityMode = 'optional' | 'required';
-/** Describes the minimum compatible platform versions for a feature. */
-export interface AiFeatureCompatibilityFloor {
-    /** Minimum supported PHP version, when a feature depends on PHP behavior. */
-    php?: string;
-    /** Minimum supported WordPress version, when a feature depends on core APIs. */
-    wordpress?: string;
-}
-/** Identifies a concrete runtime signal that a feature depends on. */
-export interface AiFeatureRuntimeGate {
-    /** The kind of runtime dependency or capability being checked. */
-    kind: 'adapter' | 'php-function' | 'script-package' | 'wordpress-core-feature';
-    /** The concrete symbol, package, or adapter name required at runtime. */
-    value: string;
-}
-/** Defines a single AI-related feature that scaffold compatibility can target. */
-export interface AiFeatureDefinition {
-    /** Human-readable summary for docs, onboarding, and generated notices. */
-    description: string;
-    /** Stable machine-readable identifier used in capability selections. */
-    id: string;
-    /** Display label presented to maintainers and downstream tooling. */
-    label: string;
-    /** Optional minimum platform versions required by the feature. */
-    minimumVersions?: AiFeatureCompatibilityFloor;
-    /** Optional runtime gates that explain what the feature depends on. */
-    runtimeGates?: readonly AiFeatureRuntimeGate[];
-}
-/** Selects a feature and whether it is required or merely optional. */
-export interface AiFeatureCapabilitySelection {
-    /** Feature identifier that must exist in the active registry. */
-    featureId: string;
-    /** Required selections take precedence over optional duplicates. */
-    mode: AiFeatureCapabilityMode;
-}
-/** Feature definition resolved together with its selected mode. */
-export interface ResolvedAiFeatureCapability extends AiFeatureDefinition {
-    /** Final selected mode after duplicate feature ids are normalized. */
-    mode: AiFeatureCapabilityMode;
-}
-/** Groups the normalized feature plan used by scaffold compatibility logic. */
-export interface ResolvedAiFeatureCapabilityPlan {
-    /** Highest required PHP and WordPress version floors across required features. */
-    hardMinimums: AiFeatureCompatibilityFloor;
-    /** Optional features that do not raise the minimum platform floor. */
-    optionalFeatures: ResolvedAiFeatureCapability[];
-    /** Required features that downstream projects must treat as mandatory. */
-    requiredFeatures: ResolvedAiFeatureCapability[];
-}
-/** Canonical registry of AI-related features supported by wp-typia today. */
-export declare const AI_FEATURE_DEFINITIONS: {
-    readonly wordpressAiClient: {
-        readonly description: "WordPress 7.0 AI Client surface used by AI-capable feature endpoints.";
-        readonly id: "wordpress-ai-client";
-        readonly label: "WordPress AI Client";
-        readonly minimumVersions: {
-            readonly wordpress: "7.0";
-        };
-        readonly runtimeGates: readonly [{
-            readonly kind: "wordpress-core-feature";
-            readonly value: "WordPress AI Client";
-        }];
-    };
-    readonly wordpressCoreAbilities: {
-        readonly description: "Client-side ability discovery surface for editor and admin flows.";
-        readonly id: "wordpress-core-abilities";
-        readonly label: "@wordpress/core-abilities";
-        readonly minimumVersions: {
-            readonly wordpress: "7.0";
-        };
-        readonly runtimeGates: readonly [{
-            readonly kind: "script-package";
-            readonly value: "@wordpress/core-abilities";
-        }];
-    };
-    readonly wordpressMcpPublicMetadata: {
-        readonly description: "Optional MCP exposure metadata consumed by a separate adapter path rather than core alone.";
-        readonly id: "wordpress-mcp-public-metadata";
-        readonly label: "MCP public metadata";
-        readonly runtimeGates: readonly [{
-            readonly kind: "adapter";
-            readonly value: "MCP adapter";
-        }];
-    };
-    readonly wordpressServerAbilities: {
-        readonly description: "Server-side ability registration and execution surface for WordPress-native abilities.";
-        readonly id: "wordpress-server-abilities";
-        readonly label: "WordPress Abilities API";
-        readonly minimumVersions: {
-            readonly wordpress: "6.9";
-        };
-        readonly runtimeGates: readonly [{
-            readonly kind: "php-function";
-            readonly value: "wp_register_ability";
-        }, {
-            readonly kind: "php-function";
-            readonly value: "wp_register_ability_category";
-        }];
-    };
-};
-/**
- * Resolves a normalized AI feature capability plan from a list of selections.
- *
- * Required selections win when the same feature id appears multiple times, and
- * the resulting hard minimum platform floor is computed from required features
- * only.
- *
- * @param selections Desired feature selections for a scaffold or projection.
- * @param registry Feature registry to resolve against. Defaults to the built-in registry.
- * @returns The normalized capability plan plus required version floors.
- * @throws When a selection references an unknown feature id.
- */
-export declare function resolveAiFeatureCapabilityPlan(selections: readonly AiFeatureCapabilitySelection[], registry?: Readonly<Record<string, AiFeatureDefinition>>): ResolvedAiFeatureCapabilityPlan;
+export * from "./add/ai-feature-capability.js";

package/dist/runtime/ai-feature-capability.js

@@ -1,139 +1 @@
-/** Declares whether a generated feature is optional or required at runtime. */
-import { pickHigherVersionFloor } from './version-floor.js';
-/** Canonical registry of AI-related features supported by wp-typia today. */
-export const AI_FEATURE_DEFINITIONS = {
-    wordpressAiClient: {
-        description: 'WordPress 7.0 AI Client surface used by AI-capable feature endpoints.',
-        id: 'wordpress-ai-client',
-        label: 'WordPress AI Client',
-        minimumVersions: {
-            wordpress: '7.0',
-        },
-        runtimeGates: [
-            {
-                kind: 'wordpress-core-feature',
-                value: 'WordPress AI Client',
-            },
-        ],
-    },
-    wordpressCoreAbilities: {
-        description: 'Client-side ability discovery surface for editor and admin flows.',
-        id: 'wordpress-core-abilities',
-        label: '@wordpress/core-abilities',
-        minimumVersions: {
-            wordpress: '7.0',
-        },
-        runtimeGates: [
-            {
-                kind: 'script-package',
-                value: '@wordpress/core-abilities',
-            },
-        ],
-    },
-    wordpressMcpPublicMetadata: {
-        description: 'Optional MCP exposure metadata consumed by a separate adapter path rather than core alone.',
-        id: 'wordpress-mcp-public-metadata',
-        label: 'MCP public metadata',
-        runtimeGates: [
-            {
-                kind: 'adapter',
-                value: 'MCP adapter',
-            },
-        ],
-    },
-    wordpressServerAbilities: {
-        description: 'Server-side ability registration and execution surface for WordPress-native abilities.',
-        id: 'wordpress-server-abilities',
-        label: 'WordPress Abilities API',
-        minimumVersions: {
-            wordpress: '6.9',
-        },
-        runtimeGates: [
-            {
-                kind: 'php-function',
-                value: 'wp_register_ability',
-            },
-            {
-                kind: 'php-function',
-                value: 'wp_register_ability_category',
-            },
-        ],
-    },
-};
-const DEFAULT_AI_FEATURE_REGISTRY = Object.values(AI_FEATURE_DEFINITIONS).reduce((accumulator, definition) => {
-    accumulator[definition.id] = definition;
-    return accumulator;
-}, {});
-function normalizeSelections(selections) {
-    const normalized = new Map();
-    for (const selection of selections) {
-        const current = normalized.get(selection.featureId);
-        if (!current || selection.mode === 'required') {
-            normalized.set(selection.featureId, selection);
-        }
-    }
-    return [...normalized.values()];
-}
-function validateFeatureMinimumVersions(definition) {
-    for (const [platform, value] of [
-        ['wordpress', definition.minimumVersions?.wordpress],
-        ['php', definition.minimumVersions?.php],
-    ]) {
-        if (value === undefined) {
-            continue;
-        }
-        try {
-            pickHigherVersionFloor(value, undefined);
-        }
-        catch (error) {
-            throw new Error([
-                `Invalid ${platform} minimum version floor for AI feature "${definition.id}": "${value}".`,
-                'Expected dotted numeric segments such as "6.7" or "8.1.2".',
-            ].join(' '), { cause: error });
-        }
-    }
-}
-/**
- * Resolves a normalized AI feature capability plan from a list of selections.
- *
- * Required selections win when the same feature id appears multiple times, and
- * the resulting hard minimum platform floor is computed from required features
- * only.
- *
- * @param selections Desired feature selections for a scaffold or projection.
- * @param registry Feature registry to resolve against. Defaults to the built-in registry.
- * @returns The normalized capability plan plus required version floors.
- * @throws When a selection references an unknown feature id.
- */
-export function resolveAiFeatureCapabilityPlan(selections, registry = DEFAULT_AI_FEATURE_REGISTRY) {
-    const requiredFeatures = [];
-    const optionalFeatures = [];
-    let wordpress;
-    let php;
-    for (const selection of normalizeSelections(selections)) {
-        const definition = registry[selection.featureId];
-        if (!definition) {
-            throw new Error(`Unknown AI feature capability "${selection.featureId}".`);
-        }
-        validateFeatureMinimumVersions(definition);
-        const resolvedDefinition = {
-            ...definition,
-            mode: selection.mode,
-        };
-        if (selection.mode === 'required') {
-            requiredFeatures.push(resolvedDefinition);
-            wordpress = pickHigherVersionFloor(wordpress, definition.minimumVersions?.wordpress);
-            php = pickHigherVersionFloor(php, definition.minimumVersions?.php);
-            continue;
-        }
-        optionalFeatures.push(resolvedDefinition);
-    }
-    return {
-        hardMinimums: {
-            ...(php ? { php } : {}),
-            ...(wordpress ? { wordpress } : {}),
-        },
-        optionalFeatures,
-        requiredFeatures,
-    };
-}
+export * from "./add/ai-feature-capability.js";

package/dist/runtime/alternate-render-targets.d.ts

@@ -1,5 +1 @@
-export declare const ALTERNATE_RENDER_TARGET_IDS: readonly ["email", "mjml", "plain-text"];
-export type AlternateRenderTargetId = (typeof ALTERNATE_RENDER_TARGET_IDS)[number];
-export declare function isAlternateRenderTargetId(value: string): value is AlternateRenderTargetId;
-export declare function parseAlternateRenderTargets(value?: string): AlternateRenderTargetId[];
-export declare function formatAlternateRenderTargets(targets: readonly AlternateRenderTargetId[]): string;
+export * from "./add/alternate-render-targets.js";

package/dist/runtime/alternate-render-targets.js

@@ -1,29 +1 @@
-export const ALTERNATE_RENDER_TARGET_IDS = [
-    "email",
-    "mjml",
-    "plain-text",
-];
-export function isAlternateRenderTargetId(value) {
-    return ALTERNATE_RENDER_TARGET_IDS.includes(value);
-}
-export function parseAlternateRenderTargets(value) {
-    if (typeof value !== "string") {
-        return [];
-    }
-    const normalized = value
-        .split(",")
-        .map((entry) => entry.trim().toLowerCase())
-        .filter(Boolean);
-    if (normalized.length === 0) {
-        return [];
-    }
-    const deduped = Array.from(new Set(normalized));
-    const invalid = deduped.filter((entry) => !isAlternateRenderTargetId(entry));
-    if (invalid.length > 0) {
-        throw new Error(`Unsupported alternate render target${invalid.length > 1 ? "s" : ""} "${invalid.join(", ")}". Expected one of: ${ALTERNATE_RENDER_TARGET_IDS.join(", ")}.`);
-    }
-    return deduped;
-}
-export function formatAlternateRenderTargets(targets) {
-    return targets.join(", ");
-}
+export * from "./add/alternate-render-targets.js";

package/dist/runtime/block-generator-service-core.d.ts

@@ -1,8 +1 @@
-import { type ApplyBlockInput, type PlanBlockInput, type PlanBlockResult, type RenderBlockInput, type RenderBlockResult, type ValidateBlockInput, type ValidateBlockResult } from "./block-generator-service-spec.js";
-import type { ScaffoldProjectResult } from "./scaffold.js";
-export declare class BlockGeneratorService {
-    plan({ allowExistingDir, alternateRenderTargets, answers, cwd, dataStorageMode, externalLayerId, externalLayerSource, externalLayerSourceLabel, noInstall, packageManager, persistencePolicy, projectDir, repositoryReference, templateId, variant, withMigrationUi, withTestPreset, withWpEnv, }: PlanBlockInput): Promise<PlanBlockResult>;
-    validate({ plan }: ValidateBlockInput): Promise<ValidateBlockResult>;
-    render({ validated }: RenderBlockInput): Promise<RenderBlockResult>;
-    apply({ rendered, installDependencies, onProgress, }: ApplyBlockInput): Promise<ScaffoldProjectResult>;
-}
+export * from "./templates/block-generator-service-core.js";

package/dist/runtime/block-generator-service-core.js

@@ -1,279 +1 @@
-import { applyBuiltInScaffoldProjectFiles, buildGitignore, buildReadme, } from "./scaffold-apply-utils.js";
-import { buildBuiltInBlockArtifacts, } from "./built-in-block-artifacts.js";
-import { buildBuiltInCodeArtifacts, } from "./built-in-block-code-artifacts.js";
-import { stableJsonStringify } from "./object-utils.js";
-import { getStarterManifestFiles } from "./starter-manifests.js";
-import { resolveTemplateSeed, parseTemplateLocator } from "./template-source.js";
-import { assertExternalTemplateLayersDoNotWriteProtectedOutputs, resolveExternalTemplateLayers, } from "./template-layers.js";
-import { getBuiltInTemplateOverlayDir, getBuiltInTemplateSharedLayerDirs, resolveBuiltInTemplateSource, resolveBuiltInTemplateSourceFromLayerDirs, } from "./template-builtins.js";
-import { buildTemplateVariablesFromBlockSpec, createBuiltInBlockSpec, } from "./block-generator-service-spec.js";
-import { assertBuiltInTemplateVariantAllowed, assertExternalLayerCompositionOptions, } from "./cli-validation.js";
-const renderedArtifactCache = new WeakMap();
-function createVariablesFingerprint(variables) {
-    return stableJsonStringify(variables);
-}
-function buildProtectedTemplateOutputPaths({ codeArtifacts, spec, variables, artifacts, }) {
-    const protectedOutputs = new Set([
-        ".gitignore",
-        "package.json",
-        "scripts/add-compound-child.ts",
-        "scripts/block-config.ts",
-        "scripts/sync-project.ts",
-        "scripts/sync-rest-contracts.ts",
-        "scripts/sync-types-to-block-json.ts",
-        "tsconfig.json",
-        "webpack.config.js",
-        `${variables.slugKebabCase}.php`,
-    ]);
-    for (const artifact of codeArtifacts) {
-        protectedOutputs.add(artifact.relativePath);
-    }
-    for (const artifact of artifacts) {
-        protectedOutputs.add(`${artifact.relativeDir}/block.json`);
-        protectedOutputs.add(`${artifact.relativeDir}/types.ts`);
-    }
-    for (const manifest of getStarterManifestFiles(spec.template.family, variables)) {
-        protectedOutputs.add(manifest.relativePath);
-    }
-    return protectedOutputs;
-}
-function buildCombinedTemplateLayerDirs({ baseLayerDirs, externalEntries, templateId, }) {
-    const orderedLayerDirs = [];
-    const seenLayerDirs = new Set();
-    for (const layerDir of baseLayerDirs) {
-        if (seenLayerDirs.has(layerDir)) {
-            continue;
-        }
-        orderedLayerDirs.push(layerDir);
-        seenLayerDirs.add(layerDir);
-    }
-    for (const entry of externalEntries) {
-        if (seenLayerDirs.has(entry.dir)) {
-            continue;
-        }
-        orderedLayerDirs.push(entry.dir);
-        seenLayerDirs.add(entry.dir);
-    }
-    const overlayDir = getBuiltInTemplateOverlayDir(templateId);
-    if (!seenLayerDirs.has(overlayDir)) {
-        orderedLayerDirs.push(overlayDir);
-    }
-    return orderedLayerDirs;
-}
-async function runCleanupGroup(label, cleanups) {
-    const cleanupErrors = [];
-    const seen = new Set();
-    for (const cleanup of cleanups) {
-        if (!cleanup || seen.has(cleanup)) {
-            continue;
-        }
-        seen.add(cleanup);
-        try {
-            await cleanup();
-        }
-        catch (error) {
-            cleanupErrors.push(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    if (cleanupErrors.length > 0) {
-        throw new Error([
-            label,
-            ...cleanupErrors.map((error) => `- ${error.message}`),
-        ].join("\n"));
-    }
-}
-export class BlockGeneratorService {
-    async plan({ allowExistingDir = false, alternateRenderTargets, answers, cwd = process.cwd(), dataStorageMode, externalLayerId, externalLayerSource, externalLayerSourceLabel, noInstall = false, packageManager, persistencePolicy, projectDir, repositoryReference, templateId, variant, withMigrationUi = false, withTestPreset = false, withWpEnv = false, }) {
-        return {
-            spec: createBuiltInBlockSpec({
-                alternateRenderTargets,
-                answers,
-                dataStorageMode,
-                persistencePolicy,
-                templateId,
-                withMigrationUi,
-                withTestPreset,
-                withWpEnv,
-            }),
-            target: {
-                allowExistingDir,
-                cwd,
-                externalLayerId,
-                externalLayerSource,
-                externalLayerSourceLabel,
-                noInstall,
-                packageManager,
-                projectDir,
-                repositoryReference,
-                variant,
-            },
-        };
-    }
-    async validate({ plan }) {
-        assertExternalLayerCompositionOptions({
-            externalLayerId: plan.target.externalLayerId,
-            externalLayerSource: plan.target.externalLayerSource,
-        });
-        assertBuiltInTemplateVariantAllowed({
-            templateId: plan.spec.template.family,
-            variant: plan.target.variant,
-        });
-        return plan;
-    }
-    async render({ validated }) {
-        const variables = buildTemplateVariablesFromBlockSpec(validated.spec);
-        const persistenceEnabled = validated.spec.persistence.enabled;
-        const artifacts = buildBuiltInBlockArtifacts({
-            templateId: validated.spec.template.family,
-            variables,
-        });
-        const codeArtifacts = buildBuiltInCodeArtifacts({
-            templateId: validated.spec.template.family,
-            variables,
-        });
-        const templateVariantOptions = {
-            persistenceEnabled,
-            persistencePolicy: validated.spec.persistence.enabled &&
-                validated.spec.persistence.persistencePolicy === "public"
-                ? "public"
-                : "authenticated",
-        };
-        let templateSource = await resolveBuiltInTemplateSource(validated.spec.template.family, templateVariantOptions);
-        const warnings = [...(templateSource.warnings ?? [])];
-        if (validated.target.externalLayerSource) {
-            let layerSeed;
-            let pendingLayerCleanup;
-            let pendingTemplateCleanup;
-            let composedCleanup;
-            try {
-                layerSeed = await resolveTemplateSeed(parseTemplateLocator(validated.target.externalLayerSource), validated.target.cwd);
-                pendingLayerCleanup = layerSeed.cleanup;
-                const resolvedLayers = await resolveExternalTemplateLayers({
-                    externalLayerId: validated.target.externalLayerId,
-                    sourceRoot: layerSeed.rootDir,
-                });
-                const baseLayerDirs = getBuiltInTemplateSharedLayerDirs(validated.spec.template.family, templateVariantOptions);
-                await assertExternalTemplateLayersDoNotWriteProtectedOutputs({
-                    externalEntries: resolvedLayers.entries,
-                    protectedOutputPaths: buildProtectedTemplateOutputPaths({
-                        artifacts,
-                        codeArtifacts,
-                        spec: validated.spec,
-                        variables,
-                    }),
-                    view: variables,
-                });
-                const previousTemplateCleanup = templateSource.cleanup;
-                const nextTemplateSource = await resolveBuiltInTemplateSourceFromLayerDirs(validated.spec.template.family, buildCombinedTemplateLayerDirs({
-                    baseLayerDirs,
-                    externalEntries: resolvedLayers.entries,
-                    templateId: validated.spec.template.family,
-                }));
-                pendingTemplateCleanup = nextTemplateSource.cleanup;
-                await previousTemplateCleanup?.();
-                templateSource = nextTemplateSource;
-                composedCleanup = async () => runCleanupGroup("Failed to cleanup composed template sources.", [
-                    pendingTemplateCleanup,
-                    pendingLayerCleanup,
-                ]);
-                templateSource.cleanup = composedCleanup;
-                warnings.push(`Applied external layer "${resolvedLayers.selectedLayerId}" from "${validated.target.externalLayerSourceLabel ?? validated.target.externalLayerSource}".`);
-            }
-            catch (error) {
-                try {
-                    if (composedCleanup) {
-                        await composedCleanup();
-                    }
-                    else {
-                        await runCleanupGroup("Failed to cleanup partially composed template sources.", [
-                            templateSource.cleanup,
-                            pendingTemplateCleanup,
-                            pendingLayerCleanup,
-                        ]);
-                    }
-                }
-                catch {
-                    // Preserve the original compose failure instead of masking it with cleanup errors.
-                }
-                throw error;
-            }
-        }
-        const rendered = {
-            ...validated,
-            cleanup: templateSource.cleanup,
-            gitignoreContent: buildGitignore(),
-            postRender: {
-                applyLocalDevPresets: true,
-                applyMigrationUiCapability: validated.spec.runtime.withMigrationUi,
-                seedPersistenceArtifacts: validated.spec.template.family === "persistence" ||
-                    (validated.spec.template.family === "compound" && persistenceEnabled),
-                seedStarterManifestFiles: true,
-            },
-            readmeContent: buildReadme(validated.spec.template.family, variables, validated.target.packageManager, {
-                withMigrationUi: validated.spec.runtime.withMigrationUi,
-                withTestPreset: validated.spec.runtime.withTestPreset,
-                withWpEnv: validated.spec.runtime.withWpEnv,
-            }),
-            selectedVariant: null,
-            templateDir: templateSource.templateDir,
-            variables,
-            warnings,
-        };
-        renderedArtifactCache.set(rendered, {
-            artifacts,
-            codeArtifacts,
-            variablesFingerprint: createVariablesFingerprint(variables),
-        });
-        return rendered;
-    }
-    async apply({ rendered, installDependencies, onProgress, }) {
-        const cachedArtifacts = renderedArtifactCache.get(rendered);
-        const currentVariablesFingerprint = createVariablesFingerprint(rendered.variables);
-        const artifacts = cachedArtifacts &&
-            cachedArtifacts.variablesFingerprint === currentVariablesFingerprint
-            ? cachedArtifacts.artifacts
-            : buildBuiltInBlockArtifacts({
-                templateId: rendered.spec.template.family,
-                variables: rendered.variables,
-            });
-        const codeArtifacts = cachedArtifacts &&
-            cachedArtifacts.variablesFingerprint === currentVariablesFingerprint
-            ? cachedArtifacts.codeArtifacts
-            : buildBuiltInCodeArtifacts({
-                templateId: rendered.spec.template.family,
-                variables: rendered.variables,
-            });
-        try {
-            await applyBuiltInScaffoldProjectFiles({
-                allowExistingDir: rendered.target.allowExistingDir,
-                artifacts,
-                codeArtifacts,
-                installDependencies,
-                noInstall: rendered.target.noInstall,
-                onProgress,
-                packageManager: rendered.target.packageManager,
-                projectDir: rendered.target.projectDir,
-                repositoryReference: rendered.target.repositoryReference,
-                gitignoreContent: rendered.gitignoreContent,
-                readmeContent: rendered.readmeContent,
-                templateDir: rendered.templateDir,
-                templateId: rendered.spec.template.family,
-                variables: rendered.variables,
-                withMigrationUi: rendered.spec.runtime.withMigrationUi,
-                withTestPreset: rendered.spec.runtime.withTestPreset,
-                withWpEnv: rendered.spec.runtime.withWpEnv,
-            });
-        }
-        finally {
-            await rendered.cleanup?.();
-        }
-        return {
-            packageManager: rendered.target.packageManager,
-            projectDir: rendered.target.projectDir,
-            selectedVariant: rendered.selectedVariant,
-            templateId: rendered.spec.template.family,
-            variables: rendered.variables,
-            warnings: rendered.warnings,
-        };
-    }
-}
+export * from "./templates/block-generator-service-core.js";