@wp-typia/project-tools 0.17.0 → 0.18.0

package/dist/runtime/template-source-normalization.js

@@ -4,8 +4,9 @@ import path from 'node:path';
 import { loadExternalTemplateLayerManifest } from './template-layers.js';
 import { getPackageVersions } from './package-versions.js';
 import { getExternalTemplateEntry } from './template-source-external.js';
+import { getTemplateProjectType } from './template-source-remote.js';
 export { renderCreateBlockExternalTemplate } from './template-source-external.js';
-export { getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
+export { getTemplateProjectType, getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
 export function getTemplateVariableContext(variables) {
     const { apiClientPackageVersion, blockRuntimePackageVersion, blockTypesPackageVersion, projectToolsPackageVersion, restPackageVersion, } = getPackageVersions();
     return {
@@ -35,6 +36,9 @@ export async function detectTemplateSourceFormat(sourceDir) {
     if (getExternalTemplateEntry(sourceDir)) {
         return 'create-block-external';
     }
+    if (getTemplateProjectType(sourceDir) !== null) {
+        return 'wp-typia';
+    }
     const sourceRoot = fs.existsSync(path.join(sourceDir, 'src'))
         ? path.join(sourceDir, 'src')
         : sourceDir;

package/dist/runtime/template-source-remote.d.ts

@@ -6,6 +6,11 @@ import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from
  * @returns The declared block category, or "widgets" when detection fails.
  */
 export declare function getDefaultCategory(sourceDir: string): string;
+/**
+ * Read `wpTypia.projectType` from a rendered or source template package
+ * manifest and return it when present.
+ */
+export declare function getTemplateProjectType(sourceDir: string): string | null;
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *

package/dist/runtime/template-source-remote.js

@@ -39,6 +39,33 @@ export function getDefaultCategory(sourceDir) {
         return 'widgets';
     }
 }
+function readTemplatePackageJson(sourceDir) {
+    for (const candidate of [
+        path.join(sourceDir, 'package.json.mustache'),
+        path.join(sourceDir, 'package.json'),
+    ]) {
+        if (!fs.existsSync(candidate)) {
+            continue;
+        }
+        try {
+            return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Read `wpTypia.projectType` from a rendered or source template package
+ * manifest and return it when present.
+ */
+export function getTemplateProjectType(sourceDir) {
+    const packageJson = readTemplatePackageJson(sourceDir);
+    return typeof packageJson?.wpTypia?.projectType === 'string'
+        ? packageJson.wpTypia.projectType
+        : null;
+}
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *
@@ -57,6 +84,12 @@ export async function normalizeWpTypiaTemplateSeed(seed) {
                     fs.existsSync(mustacheVariantPath));
             },
         });
+        if (seed.assetsDir && fs.existsSync(seed.assetsDir)) {
+            await fsp.cp(seed.assetsDir, path.join(normalizedDir, 'assets'), {
+                recursive: true,
+                force: true,
+            });
+        }
     }
     catch (error) {
         await fsp.rm(tempRoot, { force: true, recursive: true });

package/dist/runtime/template-source.js

@@ -1,7 +1,7 @@
 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, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
+import { detectTemplateSourceFormat, getTemplateProjectType, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
 import { isOfficialWorkspaceTemplateSeed, resolveTemplateSeed, } from './template-source-seeds.js';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
 export { resolveTemplateSeed } from './template-source-seeds.js';
@@ -28,6 +28,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
             }
             normalizedSeed = await normalizeWpTypiaTemplateSeed(seed);
+            const supportsMigrationUi = getTemplateProjectType(seed.blockDir) === 'workspace';
             return {
                 id: templateId,
                 defaultCategory: getDefaultCategory(seed.blockDir),
@@ -35,6 +36,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 features: ['Remote source', 'wp-typia format'],
                 format,
                 isOfficialWorkspaceTemplate,
+                supportsMigrationUi,
                 templateDir: normalizedSeed.blockDir,
                 cleanup: normalizedSeed.cleanup,
             };
@@ -48,6 +50,33 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                     })()
                     : seed;
         if (format === 'create-block-external') {
+            const renderedFormat = normalizedSeed.formatHint ??
+                (await detectTemplateSourceFormat(normalizedSeed.blockDir));
+            if (renderedFormat === 'wp-typia') {
+                const normalized = await normalizeWpTypiaTemplateSeed(normalizedSeed);
+                const supportsMigrationUi = getTemplateProjectType(normalizedSeed.blockDir) === 'workspace';
+                return {
+                    cleanup: async () => {
+                        await normalized.cleanup?.();
+                        await seed.cleanup?.();
+                    },
+                    defaultCategory: getDefaultCategory(normalizedSeed.blockDir),
+                    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 ?? [],
+                };
+            }
             const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
             return {
                 ...normalized,

package/dist/runtime/workspace-inventory.d.ts

@@ -19,14 +19,49 @@ export interface WorkspaceBindingSourceInventoryEntry {
     serverFile: string;
     slug: string;
 }
+/**
+ * REST-resource entry parsed from `scripts/block-config.ts`.
+ *
+ * Each file path is stored relative to the workspace root so doctor checks and
+ * workspace mutation helpers can resolve the generated TypeScript, OpenAPI, and
+ * PHP route artifacts without guessing their locations.
+ */
+export interface WorkspaceRestResourceInventoryEntry {
+    apiFile: string;
+    clientFile: string;
+    dataFile: string;
+    methods: string[];
+    namespace: string;
+    openApiFile: string;
+    phpFile: string;
+    slug: string;
+    typesFile: string;
+    validatorsFile: string;
+}
+/**
+ * Editor-plugin entry parsed from `scripts/block-config.ts`.
+ *
+ * @property file Relative path to the generated editor plugin entry file.
+ * @property slug Normalized editor plugin slug.
+ * @property slot Canonical editor shell slot for the plugin scaffold.
+ */
+export interface WorkspaceEditorPluginInventoryEntry {
+    file: string;
+    slug: string;
+    slot: string;
+}
 export interface WorkspaceInventory {
     bindingSources: WorkspaceBindingSourceInventoryEntry[];
     blockConfigPath: string;
     blocks: WorkspaceBlockInventoryEntry[];
     hasBindingSourcesSection: boolean;
+    hasEditorPluginsSection: boolean;
     hasPatternsSection: boolean;
+    hasRestResourcesSection: boolean;
     hasVariationsSection: boolean;
+    editorPlugins: WorkspaceEditorPluginInventoryEntry[];
     patterns: WorkspacePatternInventoryEntry[];
+    restResources: WorkspaceRestResourceInventoryEntry[];
     source: string;
     variations: WorkspaceVariationInventoryEntry[];
 }
@@ -34,6 +69,11 @@ export declare const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entrie
 export declare const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 export declare const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
 export declare const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
+export declare const REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
+/**
+ * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
+ */
+export declare const EDITOR_PLUGIN_CONFIG_ENTRY_MARKER = "\t// wp-typia add editor-plugin entries";
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *
@@ -75,10 +115,12 @@ export declare function getWorkspaceBlockSelectOptions(projectDir: string): Arra
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export declare function updateWorkspaceInventorySource(source: string, { blockEntries, bindingSourceEntries, patternEntries, variationEntries, transformSource, }?: {
+export declare function updateWorkspaceInventorySource(source: string, { blockEntries, bindingSourceEntries, editorPluginEntries, patternEntries, restResourceEntries, variationEntries, transformSource, }?: {
     blockEntries?: string[];
     bindingSourceEntries?: string[];
+    editorPluginEntries?: string[];
     patternEntries?: string[];
+    restResourceEntries?: string[];
     transformSource?: (source: string) => string;
     variationEntries?: string[];
 }): string;

package/dist/runtime/workspace-inventory.js

@@ -2,10 +2,16 @@ import fs from "node:fs";
 import path from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
 import ts from "typescript";
+import { REST_RESOURCE_METHOD_IDS } from "./cli-add-shared.js";
 export const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 export const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 export const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
 export const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
+export const REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
+/**
+ * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
+ */
+export const EDITOR_PLUGIN_CONFIG_ENTRY_MARKER = "\t// wp-typia add editor-plugin entries";
 const VARIATIONS_INTERFACE_SECTION = `
 
 export interface WorkspaceVariationConfig {
@@ -47,6 +53,44 @@ export const BINDING_SOURCES: WorkspaceBindingSourceConfig[] = [
 \t// wp-typia add binding-source entries
 ];
 `;
+const REST_RESOURCES_INTERFACE_SECTION = `
+
+export interface WorkspaceRestResourceConfig {
+\tapiFile: string;
+\tclientFile: string;
+\tdataFile: string;
+\tmethods: Array< 'list' | 'read' | 'create' | 'update' | 'delete' >;
+\tnamespace: string;
+\topenApiFile: string;
+\tphpFile: string;
+\trestManifest?: ReturnType<
+\t\ttypeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
+\t>;
+\tslug: string;
+\ttypesFile: string;
+\tvalidatorsFile: string;
+}
+`;
+const REST_RESOURCES_CONST_SECTION = `
+
+export const REST_RESOURCES: WorkspaceRestResourceConfig[] = [
+\t// wp-typia add rest-resource entries
+];
+`;
+const EDITOR_PLUGINS_INTERFACE_SECTION = `
+
+export interface WorkspaceEditorPluginConfig {
+\tfile: string;
+\tslug: string;
+\tslot: string;
+}
+`;
+const EDITOR_PLUGINS_CONST_SECTION = `
+
+export const EDITOR_PLUGINS: WorkspaceEditorPluginConfig[] = [
+\t// wp-typia add editor-plugin entries
+];
+`;
 function getPropertyNameText(name) {
     if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
         return name.text;
@@ -105,6 +149,27 @@ function getRequiredStringProperty(entryName, elementIndex, objectLiteral, key)
     }
     return value;
 }
+function getRequiredStringArrayProperty(entryName, elementIndex, objectLiteral, key) {
+    for (const property of objectLiteral.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            continue;
+        }
+        const propertyName = getPropertyNameText(property.name);
+        if (propertyName !== key) {
+            continue;
+        }
+        if (!ts.isArrayLiteralExpression(property.initializer)) {
+            throw new Error(`${entryName}[${elementIndex}] must use an array literal for "${key}" in scripts/block-config.ts.`);
+        }
+        return property.initializer.elements.map((element, itemIndex) => {
+            if (!ts.isStringLiteralLike(element)) {
+                throw new Error(`${entryName}[${elementIndex}].${key}[${itemIndex}] must use a string literal in scripts/block-config.ts.`);
+            }
+            return element.text;
+        });
+    }
+    throw new Error(`${entryName}[${elementIndex}] is missing required "${key}" in scripts/block-config.ts.`);
+}
 function parseBlockEntries(arrayLiteral) {
     return arrayLiteral.elements.map((element, elementIndex) => {
         if (!ts.isObjectLiteralExpression(element)) {
@@ -154,6 +219,42 @@ function parseBindingSourceEntries(arrayLiteral) {
         };
     });
 }
+function parseRestResourceEntries(arrayLiteral) {
+    return arrayLiteral.elements.map((element, elementIndex) => {
+        if (!ts.isObjectLiteralExpression(element)) {
+            throw new Error(`REST_RESOURCES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        }
+        const methods = getRequiredStringArrayProperty("REST_RESOURCES", elementIndex, element, "methods");
+        const invalidMethods = methods.filter((method) => !REST_RESOURCE_METHOD_IDS.includes(method));
+        if (invalidMethods.length > 0) {
+            throw new Error(`REST_RESOURCES[${elementIndex}].methods includes unsupported values: ${invalidMethods.join(", ")}.`);
+        }
+        return {
+            apiFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "apiFile"),
+            clientFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "clientFile"),
+            dataFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "dataFile"),
+            methods,
+            namespace: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "namespace"),
+            openApiFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "openApiFile"),
+            phpFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "phpFile"),
+            slug: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "slug"),
+            typesFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "typesFile"),
+            validatorsFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "validatorsFile"),
+        };
+    });
+}
+function parseEditorPluginEntries(arrayLiteral) {
+    return arrayLiteral.elements.map((element, elementIndex) => {
+        if (!ts.isObjectLiteralExpression(element)) {
+            throw new Error(`EDITOR_PLUGINS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        }
+        return {
+            file: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "file"),
+            slug: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slug"),
+            slot: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slot"),
+        };
+    });
+}
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *
@@ -170,6 +271,8 @@ export function parseWorkspaceInventorySource(source) {
     const variationArray = findExportedArrayLiteral(sourceFile, "VARIATIONS");
     const patternArray = findExportedArrayLiteral(sourceFile, "PATTERNS");
     const bindingSourceArray = findExportedArrayLiteral(sourceFile, "BINDING_SOURCES");
+    const restResourceArray = findExportedArrayLiteral(sourceFile, "REST_RESOURCES");
+    const editorPluginArray = findExportedArrayLiteral(sourceFile, "EDITOR_PLUGINS");
     if (variationArray.found && !variationArray.array) {
         throw new Error("scripts/block-config.ts must export VARIATIONS as an array literal.");
     }
@@ -179,15 +282,29 @@ export function parseWorkspaceInventorySource(source) {
     if (bindingSourceArray.found && !bindingSourceArray.array) {
         throw new Error("scripts/block-config.ts must export BINDING_SOURCES as an array literal.");
     }
+    if (restResourceArray.found && !restResourceArray.array) {
+        throw new Error("scripts/block-config.ts must export REST_RESOURCES as an array literal.");
+    }
+    if (editorPluginArray.found && !editorPluginArray.array) {
+        throw new Error("scripts/block-config.ts must export EDITOR_PLUGINS as an array literal.");
+    }
     return {
         bindingSources: bindingSourceArray.array
             ? parseBindingSourceEntries(bindingSourceArray.array)
             : [],
         blocks: parseBlockEntries(blockArray.array),
         hasBindingSourcesSection: bindingSourceArray.found,
+        hasEditorPluginsSection: editorPluginArray.found,
         hasPatternsSection: patternArray.found,
+        hasRestResourcesSection: restResourceArray.found,
         hasVariationsSection: variationArray.found,
+        editorPlugins: editorPluginArray.array
+            ? parseEditorPluginEntries(editorPluginArray.array)
+            : [],
         patterns: patternArray.array ? parsePatternEntries(patternArray.array) : [],
+        restResources: restResourceArray.array
+            ? parseRestResourceEntries(restResourceArray.array)
+            : [],
         source,
         variations: variationArray.array ? parseVariationEntries(variationArray.array) : [],
     };
@@ -255,6 +372,18 @@ function ensureWorkspaceInventorySections(source) {
     if (!/export\s+const\s+BINDING_SOURCES\b/u.test(nextSource)) {
         nextSource += BINDING_SOURCES_CONST_SECTION;
     }
+    if (!/export\s+interface\s+WorkspaceRestResourceConfig\b/u.test(nextSource)) {
+        nextSource += REST_RESOURCES_INTERFACE_SECTION;
+    }
+    if (!/export\s+const\s+REST_RESOURCES\b/u.test(nextSource)) {
+        nextSource += REST_RESOURCES_CONST_SECTION;
+    }
+    if (!/export\s+interface\s+WorkspaceEditorPluginConfig\b/u.test(nextSource)) {
+        nextSource += EDITOR_PLUGINS_INTERFACE_SECTION;
+    }
+    if (!/export\s+const\s+EDITOR_PLUGINS\b/u.test(nextSource)) {
+        nextSource += EDITOR_PLUGINS_CONST_SECTION;
+    }
     return `${nextSource}\n`;
 }
 function appendEntriesAtMarker(source, marker, entries) {
@@ -277,7 +406,7 @@ function appendEntriesAtMarker(source, marker, entries) {
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export function updateWorkspaceInventorySource(source, { blockEntries = [], bindingSourceEntries = [], patternEntries = [], variationEntries = [], transformSource, } = {}) {
+export function updateWorkspaceInventorySource(source, { blockEntries = [], bindingSourceEntries = [], editorPluginEntries = [], patternEntries = [], restResourceEntries = [], variationEntries = [], transformSource, } = {}) {
     let nextSource = ensureWorkspaceInventorySections(source);
     if (transformSource) {
         nextSource = transformSource(nextSource);
@@ -286,6 +415,8 @@ export function updateWorkspaceInventorySource(source, { blockEntries = [], bind
     nextSource = appendEntriesAtMarker(nextSource, VARIATION_CONFIG_ENTRY_MARKER, variationEntries);
     nextSource = appendEntriesAtMarker(nextSource, PATTERN_CONFIG_ENTRY_MARKER, patternEntries);
     nextSource = appendEntriesAtMarker(nextSource, BINDING_SOURCE_CONFIG_ENTRY_MARKER, bindingSourceEntries);
+    nextSource = appendEntriesAtMarker(nextSource, REST_RESOURCE_CONFIG_ENTRY_MARKER, restResourceEntries);
+    nextSource = appendEntriesAtMarker(nextSource, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, editorPluginEntries);
     return nextSource;
 }
 /**

package/dist/runtime/workspace-project.d.ts

@@ -43,7 +43,7 @@ export declare function getInvalidWorkspaceProjectReason(startDir: string): stri
  * Parse a package-manager identifier from a `packageManager` field.
  *
  * @param packageManagerField Raw package-manager field such as `bun@1.3.11`.
- * @returns A normalized `PackageManagerId`, defaulting to `"bun"` when the
+ * @returns A normalized `PackageManagerId`, defaulting to `"npm"` when the
  * field is missing or unsupported.
  */
 export declare function parseWorkspacePackageManagerId(packageManagerField: string | undefined): PackageManagerId;

package/dist/runtime/workspace-project.js

@@ -77,7 +77,7 @@ export function getInvalidWorkspaceProjectReason(startDir) {
  * Parse a package-manager identifier from a `packageManager` field.
  *
  * @param packageManagerField Raw package-manager field such as `bun@1.3.11`.
- * @returns A normalized `PackageManagerId`, defaulting to `"bun"` when the
+ * @returns A normalized `PackageManagerId`, defaulting to `"npm"` when the
  * field is missing or unsupported.
  */
 export function parseWorkspacePackageManagerId(packageManagerField) {
@@ -89,7 +89,7 @@ export function parseWorkspacePackageManagerId(packageManagerField) {
         case "yarn":
             return packageManagerId;
         default:
-            return "bun";
+            return "npm";
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -120,8 +120,8 @@
   },
   "dependencies": {
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/block-runtime": "^0.4.10",
-    "@wp-typia/rest": "^0.3.10",
+    "@wp-typia/block-runtime": "^0.5.0",
+    "@wp-typia/rest": "^0.3.11",
     "@wp-typia/block-types": "^0.2.4",
     "mustache": "^4.2.0",
     "npm-package-arg": "^13.0.0",