@wp-typia/project-tools 0.16.11 → 0.16.13

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

@@ -1,389 +1,2 @@
-import { getPackageVersions } from "./package-versions.js";
-import { BUILTIN_BLOCK_METADATA_VERSION, COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS, getBuiltInTemplateMetadataDefaults, } from "./template-defaults.js";
-import { getTemplateById, } from "./template-registry.js";
-import { resolveBuiltInTemplateSource } from "./template-builtins.js";
-import { toPascalCase, toSnakeCase, } from "./string-case.js";
-import { applyBuiltInScaffoldProjectFiles, buildGitignore, buildReadme, } from "./scaffold-apply-utils.js";
-import { buildBlockCssClassName, buildFrontendCssClassName, resolveScaffoldIdentifiers, } from "./scaffold-identifiers.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, resolveBuiltInTemplateSourceFromLayerDirs, } from "./template-builtins.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;
-}
-function getBuiltInPersistenceSpec({ templateId, dataStorageMode, persistencePolicy, }) {
-    if (templateId === "persistence") {
-        return {
-            dataStorageMode: dataStorageMode ?? "custom-table",
-            enabled: true,
-            persistencePolicy: persistencePolicy ?? "authenticated",
-            scope: "single",
-        };
-    }
-    if (templateId === "compound" && (dataStorageMode || persistencePolicy)) {
-        return {
-            dataStorageMode: dataStorageMode ?? "custom-table",
-            enabled: true,
-            persistencePolicy: persistencePolicy ?? "authenticated",
-            scope: "compound-parent",
-        };
-    }
-    return {
-        enabled: false,
-    };
-}
-export function createBuiltInBlockSpec({ answers, dataStorageMode, persistencePolicy, templateId, withMigrationUi = false, withTestPreset = false, withWpEnv = false, }) {
-    const template = getTemplateById(templateId);
-    const metadataDefaults = getBuiltInTemplateMetadataDefaults(templateId);
-    const identifiers = resolveScaffoldIdentifiers({
-        namespace: answers.namespace,
-        phpPrefix: answers.phpPrefix,
-        slug: answers.slug,
-        textDomain: answers.textDomain,
-    });
-    const resolvedDataStorageMode = dataStorageMode ?? answers.dataStorageMode;
-    const resolvedPersistencePolicy = persistencePolicy ?? answers.persistencePolicy;
-    return {
-        block: identifiers,
-        metadata: {
-            category: metadataDefaults.category,
-            description: answers.description.trim(),
-            icon: metadataDefaults.icon,
-            keyword: identifiers.slug.replace(/-/g, " "),
-            title: answers.title.trim(),
-        },
-        persistence: getBuiltInPersistenceSpec({
-            dataStorageMode: resolvedDataStorageMode,
-            persistencePolicy: resolvedPersistencePolicy,
-            templateId,
-        }),
-        project: {
-            author: answers.author.trim(),
-        },
-        runtime: {
-            withMigrationUi,
-            withTestPreset,
-            withWpEnv,
-        },
-        template: {
-            description: template.description,
-            family: templateId,
-            features: [...template.features],
-        },
-    };
-}
-export function buildTemplateVariablesFromBlockSpec(spec) {
-    const { apiClientPackageVersion, blockRuntimePackageVersion, blockTypesPackageVersion, projectToolsPackageVersion, restPackageVersion, } = getPackageVersions();
-    const slug = spec.block.slug;
-    const slugSnakeCase = toSnakeCase(slug);
-    const pascalCase = toPascalCase(slug);
-    const title = spec.metadata.title;
-    const namespace = spec.block.namespace;
-    const textDomain = spec.block.textDomain;
-    const phpPrefix = spec.block.phpPrefix;
-    const phpPrefixUpper = phpPrefix.toUpperCase();
-    const compoundChildTitle = `${title} Item`;
-    const cssClassName = buildBlockCssClassName(namespace, slug);
-    const compoundChildCssClassName = buildBlockCssClassName(namespace, `${slug}-item`);
-    const persistenceEnabled = spec.persistence.enabled;
-    const dataStorageMode = persistenceEnabled ? spec.persistence.dataStorageMode : "custom-table";
-    const persistencePolicy = persistenceEnabled
-        ? spec.persistence.persistencePolicy
-        : "authenticated";
-    return {
-        apiClientPackageVersion,
-        author: spec.project.author,
-        blockRuntimePackageVersion,
-        blockMetadataVersion: BUILTIN_BLOCK_METADATA_VERSION,
-        blockTypesPackageVersion,
-        category: spec.metadata.category,
-        icon: spec.metadata.icon,
-        compoundChildTitle,
-        compoundChildCategory: COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS.category,
-        compoundChildCssClassName,
-        compoundChildIcon: COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS.icon,
-        compoundChildTitleJson: JSON.stringify(compoundChildTitle),
-        compoundPersistenceEnabled: spec.template.family === "compound" && persistenceEnabled ? "true" : "false",
-        projectToolsPackageVersion,
-        cssClassName,
-        dashCase: slug,
-        dataStorageMode,
-        description: spec.metadata.description,
-        frontendCssClassName: buildFrontendCssClassName(cssClassName),
-        isAuthenticatedPersistencePolicy: persistencePolicy === "authenticated" ? "true" : "false",
-        isPublicPersistencePolicy: persistencePolicy === "public" ? "true" : "false",
-        bootstrapCredentialDeclarations: persistencePolicy === "public"
-            ? "publicWriteExpiresAt?: number & tags.Type< 'uint32' >;\n\tpublicWriteToken?: string & tags.MinLength< 1 > & tags.MaxLength< 512 >;"
-            : "restNonce?: string & tags.MinLength< 1 > & tags.MaxLength< 128 >;",
-        persistencePolicyDescriptionJson: JSON.stringify(persistencePolicy === "authenticated"
-            ? "Writes require a logged-in user and a valid REST nonce."
-            : "Anonymous writes use signed short-lived public tokens, per-request ids, and coarse rate limiting."),
-        keyword: spec.metadata.keyword,
-        namespace,
-        needsMigration: "{{needsMigration}}",
-        pascalCase,
-        phpPrefix,
-        phpPrefixUpper,
-        restPackageVersion,
-        publicWriteRequestIdDeclaration: persistencePolicy === "public"
-            ? "publicWriteRequestId: string & tags.MinLength< 1 > & tags.MaxLength< 128 >;"
-            : "publicWriteRequestId?: string & tags.MinLength< 1 > & tags.MaxLength< 128 >;",
-        restWriteAuthIntent: persistencePolicy === "public"
-            ? "public-write-protected"
-            : "authenticated",
-        restWriteAuthMechanism: persistencePolicy === "public" ? "public-signed-token" : "rest-nonce",
-        restWriteAuthMode: persistencePolicy === "public" ? "public-signed-token" : "authenticated-rest-nonce",
-        slug,
-        slugCamelCase: pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1),
-        slugKebabCase: slug,
-        slugSnakeCase,
-        textDomain,
-        textdomain: textDomain,
-        title,
-        titleJson: JSON.stringify(title),
-        titleCase: pascalCase,
-        persistencePolicy,
-    };
-}
-export class BlockGeneratorService {
-    async plan({ allowExistingDir = false, 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({
-                answers,
-                dataStorageMode,
-                persistencePolicy,
-                templateId,
-                withMigrationUi,
-                withTestPreset,
-                withWpEnv,
-            }),
-            target: {
-                allowExistingDir,
-                cwd,
-                externalLayerId,
-                externalLayerSource,
-                externalLayerSourceLabel,
-                noInstall,
-                packageManager,
-                projectDir,
-                repositoryReference,
-                variant,
-            },
-        };
-    }
-    async validate({ plan }) {
-        if (plan.target.externalLayerId && !plan.target.externalLayerSource) {
-            throw new Error("externalLayerId requires externalLayerSource when composing built-in template layers.");
-        }
-        if (plan.target.variant) {
-            throw new Error(`--variant is only supported for official external template configs. Received variant "${plan.target.variant}" for built-in template "${plan.spec.template.family}".`);
-        }
-        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;
-            try {
-                layerSeed = await resolveTemplateSeed(parseTemplateLocator(validated.target.externalLayerSource), validated.target.cwd);
-                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,
-                });
-                await templateSource.cleanup?.();
-                templateSource = await resolveBuiltInTemplateSourceFromLayerDirs(validated.spec.template.family, buildCombinedTemplateLayerDirs({
-                    baseLayerDirs,
-                    externalEntries: resolvedLayers.entries,
-                    templateId: validated.spec.template.family,
-                }));
-                const layerSourceCleanup = layerSeed.cleanup;
-                const templateCleanup = templateSource.cleanup;
-                templateSource.cleanup = async () => {
-                    const cleanupErrors = [];
-                    try {
-                        await templateCleanup?.();
-                    }
-                    catch (error) {
-                        cleanupErrors.push(error instanceof Error ? error : new Error(String(error)));
-                    }
-                    try {
-                        await layerSourceCleanup?.();
-                    }
-                    catch (error) {
-                        cleanupErrors.push(error instanceof Error ? error : new Error(String(error)));
-                    }
-                    if (cleanupErrors.length > 0) {
-                        throw new Error([
-                            "Failed to cleanup composed template sources.",
-                            ...cleanupErrors.map((error) => `- ${error.message}`),
-                        ].join("\n"));
-                    }
-                };
-                warnings.push(`Applied external layer "${resolvedLayers.selectedLayerId}" from "${validated.target.externalLayerSourceLabel ?? validated.target.externalLayerSource}".`);
-            }
-            catch (error) {
-                await templateSource.cleanup?.();
-                await layerSeed?.cleanup?.();
-                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, }) {
-        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,
-                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 "./block-generator-service-spec.js";
+export * from "./block-generator-service-core.js";

package/dist/runtime/built-in-block-artifact-documents.d.ts

@@ -0,0 +1,3 @@
+export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
+export type { AttributeDescription, EmittedAttributeDefinition, } from "./built-in-block-attribute-emitters.js";
+export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";

package/dist/runtime/built-in-block-artifact-documents.js

@@ -0,0 +1,2 @@
+export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
+export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";

package/dist/runtime/built-in-block-artifact-types.d.ts

@@ -0,0 +1,51 @@
+import type { ScaffoldTemplateVariables } from "./scaffold.js";
+interface AttributeDescription {
+    lines: string[];
+}
+interface EmittedAttributeDefinition {
+    description?: AttributeDescription;
+    name: string;
+    optional: boolean;
+    typeExpression: string;
+}
+/**
+ * Builds the generated attributes and validation type source for a basic block scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the basic block attribute and validation types.
+ */
+export declare function buildBasicTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes, context, and validation type source for an interactivity scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the interactivity block attribute, context, and validation types.
+ */
+export declare function buildInteractivityTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes, context, state, client, and validation type source for a persistence scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the persistence block runtime types.
+ */
+export declare function buildPersistenceTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes and optional persistence runtime type source for a compound parent scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the compound parent runtime types.
+ */
+export declare function buildCompoundTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+/**
+ * Builds the generated attributes and validation type source for a compound child scaffold.
+ *
+ * @param variables Resolved scaffold template variables used to name emitted types.
+ * @param attributes Emitted built-in attribute definitions that drive the interface members.
+ * @returns TypeScript source for the compound child attribute and validation types.
+ */
+export declare function buildCompoundChildTypesSource(variables: ScaffoldTemplateVariables, attributes: readonly EmittedAttributeDefinition[]): string;
+export {};