@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/template-source.js

@@ -1,133 +1 @@
-import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from './template-registry.js';
-import { resolveBuiltInTemplateSource } from './template-builtins.js';
-import { parseTemplateLocator, } from './template-source-locators.js';
-import { detectTemplateSourceFormat, getTemplateProjectTypeAsync, getDefaultCategoryAsync, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
-import { isOfficialWorkspaceTemplateSeedAsync, resolveTemplateSeed, } from './template-source-seeds.js';
-import { assertBuiltInTemplateVariantAllowed, } from './cli-validation.js';
-import { getScaffoldTemplateVariableGroups } from './scaffold-template-variable-groups.js';
-export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
-export { resolveTemplateSeed } from './template-source-seeds.js';
-export async function resolveTemplateSource(templateId, cwd, variables, variant) {
-    if (isBuiltInTemplateId(templateId)) {
-        const variableGroups = getScaffoldTemplateVariableGroups(variables);
-        assertBuiltInTemplateVariantAllowed({
-            templateId,
-            variant,
-        });
-        return resolveBuiltInTemplateSource(templateId, {
-            persistenceEnabled: variableGroups.compound.enabled &&
-                variableGroups.compound.persistenceEnabled,
-            persistencePolicy: variableGroups.persistence.enabled &&
-                variableGroups.persistence.policy === 'public'
-                ? 'public'
-                : 'authenticated',
-        });
-    }
-    const locator = parseTemplateLocator(templateId);
-    const context = getTemplateVariableContext(variables);
-    const seed = await resolveTemplateSeed(locator, cwd);
-    const isOfficialWorkspaceTemplate = templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE ||
-        (await isOfficialWorkspaceTemplateSeedAsync(seed));
-    let normalizedSeed = null;
-    try {
-        const format = await detectTemplateSourceFormat(seed.blockDir);
-        if (format === 'wp-typia') {
-            if (variant) {
-                throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
-            }
-            normalizedSeed = await normalizeWpTypiaTemplateSeed(seed);
-            const supportsMigrationUi = (await getTemplateProjectTypeAsync(seed.blockDir)) === 'workspace';
-            return {
-                id: templateId,
-                defaultCategory: await getDefaultCategoryAsync(seed.blockDir),
-                description: 'A remote wp-typia template source',
-                features: ['Remote source', 'wp-typia format'],
-                format,
-                isOfficialWorkspaceTemplate,
-                supportsMigrationUi,
-                templateDir: normalizedSeed.blockDir,
-                cleanup: normalizedSeed.cleanup,
-            };
-        }
-        normalizedSeed =
-            format === 'create-block-external'
-                ? await renderCreateBlockExternalTemplate(seed.blockDir, context, variant)
-                : variant
-                    ? (() => {
-                        throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
-                    })()
-                    : seed;
-        if (format === 'create-block-external') {
-            const renderedFormat = normalizedSeed.formatHint ??
-                (await detectTemplateSourceFormat(normalizedSeed.blockDir));
-            if (renderedFormat === 'wp-typia') {
-                const normalized = await normalizeWpTypiaTemplateSeed(normalizedSeed);
-                try {
-                    const [projectType, defaultCategory] = await Promise.all([
-                        getTemplateProjectTypeAsync(normalizedSeed.blockDir),
-                        getDefaultCategoryAsync(normalizedSeed.blockDir),
-                    ]);
-                    const supportsMigrationUi = projectType === 'workspace';
-                    return {
-                        cleanup: async () => {
-                            await normalized.cleanup?.();
-                            await seed.cleanup?.();
-                        },
-                        defaultCategory,
-                        description: 'A wp-typia scaffold normalized from an official external template config',
-                        features: [
-                            'Remote source',
-                            'official external template',
-                            'wp-typia format',
-                            ...(supportsMigrationUi ? ['workspace-capable scaffold'] : []),
-                        ],
-                        format,
-                        id: 'remote:create-block-external',
-                        isOfficialWorkspaceTemplate,
-                        selectedVariant: normalizedSeed.selectedVariant ?? null,
-                        supportsMigrationUi,
-                        templateDir: normalized.blockDir,
-                        warnings: normalizedSeed.warnings ?? [],
-                    };
-                }
-                catch (error) {
-                    await normalized.cleanup?.();
-                    throw error;
-                }
-            }
-            const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
-            return {
-                ...normalized,
-                cleanup: async () => {
-                    await normalized.cleanup?.();
-                    await seed.cleanup?.();
-                },
-                description: 'A wp-typia scaffold normalized from an official create-block external template',
-                features: [
-                    'Remote source',
-                    'official external template',
-                    'Typia metadata pipeline',
-                ],
-                format,
-                id: 'remote:create-block-external',
-                isOfficialWorkspaceTemplate,
-                selectedVariant: normalizedSeed.selectedVariant ?? null,
-                warnings: normalizedSeed.warnings ?? [],
-            };
-        }
-        const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
-        return {
-            ...normalized,
-            isOfficialWorkspaceTemplate,
-        };
-    }
-    catch (error) {
-        if (normalizedSeed?.cleanup && normalizedSeed !== seed) {
-            await normalizedSeed.cleanup();
-        }
-        if (seed.cleanup) {
-            await seed.cleanup();
-        }
-        throw error;
-    }
-}
+export * from "./templates/template-source.js";

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

@@ -0,0 +1,8 @@
+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>;
+}

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

@@ -0,0 +1,279 @@
+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 "../shared/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/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,
+        };
+    }
+}

package/dist/runtime/templates/block-generator-service-spec.d.ts

@@ -0,0 +1,118 @@
+import type { PackageManagerId } from "../shared/package-managers.js";
+import { type AlternateRenderTargetId } from "../add/alternate-render-targets.js";
+import { type CompoundInnerBlocksPresetId } from "../add/compound-inner-blocks.js";
+import { type BuiltInTemplateId } from "./template-registry.js";
+import type { InstallDependenciesOptions } from "./scaffold-apply-utils.js";
+import type { DataStorageMode, PersistencePolicy, ScaffoldAnswers, ScaffoldProgressEvent, ScaffoldTemplateVariables } from "./scaffold.js";
+export interface BlockSpec {
+    alternateRenderTargets: readonly AlternateRenderTargetId[];
+    block: {
+        namespace: string;
+        phpPrefix: string;
+        slug: string;
+        textDomain: string;
+    };
+    compound: {
+        innerBlocksPreset: CompoundInnerBlocksPresetId;
+    };
+    metadata: {
+        category: string;
+        description: string;
+        icon: string;
+        keyword: string;
+        title: string;
+    };
+    persistence: {
+        enabled: false;
+    } | {
+        dataStorageMode: DataStorageMode;
+        enabled: true;
+        persistencePolicy: PersistencePolicy;
+        scope: "compound-parent" | "single";
+    };
+    project: {
+        author: string;
+    };
+    queryLoop: {
+        allowedControls: readonly string[];
+        enabled: boolean;
+        postType: string;
+    };
+    runtime: {
+        withMigrationUi: boolean;
+        withTestPreset: boolean;
+        withWpEnv: boolean;
+    };
+    template: {
+        description: string;
+        family: BuiltInTemplateId;
+        features: string[];
+    };
+}
+export interface BlockGenerationTarget {
+    allowExistingDir: boolean;
+    cwd: string;
+    externalLayerId?: string;
+    externalLayerSource?: string;
+    externalLayerSourceLabel?: string;
+    noInstall: boolean;
+    packageManager: PackageManagerId;
+    projectDir: string;
+    repositoryReference?: string;
+    variant?: string;
+}
+export interface PlanBlockInput {
+    allowExistingDir?: boolean;
+    alternateRenderTargets?: string;
+    answers: ScaffoldAnswers;
+    cwd?: string;
+    dataStorageMode?: DataStorageMode;
+    externalLayerId?: string;
+    externalLayerSource?: string;
+    externalLayerSourceLabel?: string;
+    noInstall?: boolean;
+    packageManager: PackageManagerId;
+    persistencePolicy?: PersistencePolicy;
+    projectDir: string;
+    repositoryReference?: string;
+    templateId: BuiltInTemplateId;
+    variant?: string;
+    withMigrationUi?: boolean;
+    queryPostType?: string;
+    withTestPreset?: boolean;
+    withWpEnv?: boolean;
+}
+export interface PlanBlockResult {
+    spec: BlockSpec;
+    target: BlockGenerationTarget;
+}
+export interface ValidateBlockInput {
+    plan: PlanBlockResult;
+}
+export interface ValidateBlockResult extends PlanBlockResult {
+}
+export interface RenderBlockInput {
+    validated: ValidateBlockResult;
+}
+export interface RenderBlockResult extends ValidateBlockResult {
+    cleanup?: () => Promise<void>;
+    gitignoreContent: string;
+    postRender: {
+        applyLocalDevPresets: boolean;
+        applyMigrationUiCapability: boolean;
+        seedPersistenceArtifacts: boolean;
+        seedStarterManifestFiles: boolean;
+    };
+    readmeContent: string;
+    selectedVariant: null;
+    templateDir: string;
+    variables: ScaffoldTemplateVariables;
+    warnings: string[];
+}
+export interface ApplyBlockInput {
+    rendered: RenderBlockResult;
+    installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
+    onProgress?: ((event: ScaffoldProgressEvent) => void | Promise<void>) | undefined;
+}
+export declare function createBuiltInBlockSpec({ alternateRenderTargets, answers, dataStorageMode, persistencePolicy, templateId, withMigrationUi, withTestPreset, withWpEnv, }: Omit<PlanBlockInput, "allowExistingDir" | "cwd" | "noInstall" | "packageManager" | "projectDir" | "variant">): BlockSpec;
+export declare function buildTemplateVariablesFromBlockSpec(spec: BlockSpec): ScaffoldTemplateVariables;