@wp-typia/project-tools 0.22.4 → 0.22.5

package/dist/runtime/cli-add-workspace-ai-anchors.js

@@ -2,6 +2,7 @@ import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { getPackageVersions } from "./package-versions.js";
 import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
+import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
 import { hasPhpFunctionDefinition } from "./php-utils.js";
 const AI_FEATURE_SERVER_GLOB = "/inc/ai-features/*.php";
 /**
@@ -21,30 +22,8 @@ function ${registerFunctionName}() {
 \t}
 }
 `;
-        const insertionAnchors = [
-            /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-            /\?>\s*$/u,
-        ];
-        const insertPhpSnippet = (snippet) => {
-            for (const anchor of insertionAnchors) {
-                const candidate = nextSource.replace(anchor, (match) => `${snippet}\n${match}`);
-                if (candidate !== nextSource) {
-                    nextSource = candidate;
-                    return;
-                }
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
-        const appendPhpSnippet = (snippet) => {
-            const closingTagPattern = /\?>\s*$/u;
-            if (closingTagPattern.test(nextSource)) {
-                nextSource = nextSource.replace(closingTagPattern, `${snippet}\n?>`);
-                return;
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
         if (!hasPhpFunctionDefinition(nextSource, registerFunctionName)) {
-            insertPhpSnippet(registerFunction);
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, registerFunction);
         }
         else if (!nextSource.includes(AI_FEATURE_SERVER_GLOB)) {
             throw new Error([
@@ -54,7 +33,7 @@ function ${registerFunctionName}() {
             ].join(" "));
         }
         if (!nextSource.includes(registerHook)) {
-            appendPhpSnippet(registerHook);
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, registerHook);
         }
         return nextSource;
     });

package/dist/runtime/cli-add-workspace-assets.js

@@ -8,6 +8,7 @@ import { readWorkspaceInventory, appendWorkspaceInventoryEntries, } from "./work
 import { toPascalCase, toTitleCase } from "./string-case.js";
 import { findPhpFunctionRange, hasPhpFunctionDefinition, quotePhpString, replacePhpFunctionDefinition, } from "./php-utils.js";
 import { assertBindingSourceDoesNotExist, assertEditorPluginDoesNotExist, assertPatternDoesNotExist, assertValidEditorPluginSlot, assertValidGeneratedSlug, getWorkspaceBootstrapPath, normalizeBlockSlug, patchFile, quoteTsString, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
 import { normalizeOptionalCliString } from "./cli-validation.js";
 const PATTERN_BOOTSTRAP_CATEGORY = "register_block_pattern_category";
 const BINDING_SOURCE_SERVER_GLOB = "/src/bindings/*/server.php";
@@ -597,39 +598,17 @@ function ${bindingEditorEnqueueFunctionName}() {
 \t);
 }
 `;
-        const insertionAnchors = [
-            /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-            /\?>\s*$/u,
-        ];
-        const insertPhpSnippet = (snippet) => {
-            for (const anchor of insertionAnchors) {
-                const candidate = nextSource.replace(anchor, (match) => `${snippet}\n${match}`);
-                if (candidate !== nextSource) {
-                    nextSource = candidate;
-                    return;
-                }
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
-        const appendPhpSnippet = (snippet) => {
-            const closingTagPattern = /\?>\s*$/u;
-            if (closingTagPattern.test(nextSource)) {
-                nextSource = nextSource.replace(closingTagPattern, `${snippet}\n?>`);
-                return;
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
         if (!hasPhpFunctionDefinition(nextSource, bindingRegistrationFunctionName)) {
-            insertPhpSnippet(bindingRegistrationFunction);
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, bindingRegistrationFunction);
         }
         if (!hasPhpFunctionDefinition(nextSource, bindingEditorEnqueueFunctionName)) {
-            insertPhpSnippet(bindingEditorEnqueueFunction);
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, bindingEditorEnqueueFunction);
         }
         if (!nextSource.includes(bindingRegistrationHook)) {
-            appendPhpSnippet(bindingRegistrationHook);
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, bindingRegistrationHook);
         }
         if (!nextSource.includes(bindingEditorEnqueueHook)) {
-            appendPhpSnippet(bindingEditorEnqueueHook);
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, bindingEditorEnqueueHook);
         }
         return nextSource;
     });
@@ -679,30 +658,8 @@ function ${enqueueFunctionName}() {
 \t}
 }
 `;
-        const insertionAnchors = [
-            /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-            /\?>\s*$/u,
-        ];
-        const insertPhpSnippet = (snippet) => {
-            for (const anchor of insertionAnchors) {
-                const candidate = nextSource.replace(anchor, (match) => `${snippet}\n${match}`);
-                if (candidate !== nextSource) {
-                    nextSource = candidate;
-                    return;
-                }
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
-        const appendPhpSnippet = (snippet) => {
-            const closingTagPattern = /\?>\s*$/u;
-            if (closingTagPattern.test(nextSource)) {
-                nextSource = nextSource.replace(closingTagPattern, `${snippet}\n?>`);
-                return;
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
         if (!hasPhpFunctionDefinition(nextSource, enqueueFunctionName)) {
-            insertPhpSnippet(enqueueFunction);
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, enqueueFunction);
         }
         else {
             const requiredReferences = [
@@ -726,7 +683,7 @@ function ${enqueueFunctionName}() {
             }
         }
         if (!nextSource.includes(enqueueHook)) {
-            appendPhpSnippet(enqueueHook);
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, enqueueHook);
         }
         return nextSource;
     });

package/dist/runtime/cli-add-workspace-rest-anchors.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
+import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
 import { hasPhpFunctionDefinition } from "./php-utils.js";
 const REST_RESOURCE_SERVER_GLOB = "/inc/rest/*.php";
 export async function ensureRestResourceBootstrapAnchors(workspace) {
@@ -16,30 +17,8 @@ function ${registerFunctionName}() {
 \t}
 }
 `;
-        const insertionAnchors = [
-            /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-            /\?>\s*$/u,
-        ];
-        const insertPhpSnippet = (snippet) => {
-            for (const anchor of insertionAnchors) {
-                const candidate = nextSource.replace(anchor, (match) => `${snippet}\n${match}`);
-                if (candidate !== nextSource) {
-                    nextSource = candidate;
-                    return;
-                }
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
-        const appendPhpSnippet = (snippet) => {
-            const closingTagPattern = /\?>\s*$/u;
-            if (closingTagPattern.test(nextSource)) {
-                nextSource = nextSource.replace(closingTagPattern, `${snippet}\n?>`);
-                return;
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
         if (!hasPhpFunctionDefinition(nextSource, registerFunctionName)) {
-            insertPhpSnippet(registerFunction);
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, registerFunction);
         }
         else if (!nextSource.includes(REST_RESOURCE_SERVER_GLOB)) {
             throw new Error([
@@ -49,7 +28,7 @@ function ${registerFunctionName}() {
             ].join(" "));
         }
         if (!nextSource.includes(registerHook)) {
-            appendPhpSnippet(registerHook);
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, registerHook);
         }
         return nextSource;
     });

package/dist/runtime/workspace-inventory.js

@@ -4,6 +4,9 @@ import { readFile, writeFile } from "node:fs/promises";
 import ts from "typescript";
 import { REST_RESOURCE_METHOD_IDS } from "./cli-add-shared.js";
 import { escapeRegex } from "./php-utils.js";
+function defineInventoryEntryParser(descriptor) {
+    return descriptor;
+}
 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 BLOCK_STYLE_CONFIG_ENTRY_MARKER = "\t// wp-typia add style entries";
@@ -202,12 +205,41 @@ export const EDITOR_PLUGINS: WorkspaceEditorPluginConfig[] = [
 \t// wp-typia add editor-plugin entries
 ];
 `;
+const BLOCK_INVENTORY_SECTION = {
+    parse: {
+        entriesKey: "blocks",
+        entry: defineInventoryEntryParser({
+            entryName: "BLOCKS",
+            fields: [
+                { key: "apiTypesFile" },
+                { key: "attributeTypeName" },
+                { key: "openApiFile" },
+                { key: "slug", required: true },
+                { key: "typesFile", required: true },
+            ],
+        }),
+        exportName: "BLOCKS",
+        required: true,
+    },
+};
 const INVENTORY_SECTIONS = [
     {
         interface: {
             name: "WorkspaceVariationConfig",
             section: VARIATIONS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "variations",
+            entry: defineInventoryEntryParser({
+                entryName: "VARIATIONS",
+                fields: [
+                    { key: "block", required: true },
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasVariationsSection",
+        },
         value: {
             name: "VARIATIONS",
             section: VARIATIONS_CONST_SECTION,
@@ -218,6 +250,18 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceBlockStyleConfig",
             section: BLOCK_STYLES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "blockStyles",
+            entry: defineInventoryEntryParser({
+                entryName: "BLOCK_STYLES",
+                fields: [
+                    { key: "block", required: true },
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasBlockStylesSection",
+        },
         value: {
             name: "BLOCK_STYLES",
             section: BLOCK_STYLES_CONST_SECTION,
@@ -228,6 +272,20 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceBlockTransformConfig",
             section: BLOCK_TRANSFORMS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "blockTransforms",
+            entry: defineInventoryEntryParser({
+                entryName: "BLOCK_TRANSFORMS",
+                fields: [
+                    { key: "block", required: true },
+                    { key: "file", required: true },
+                    { key: "from", required: true },
+                    { key: "slug", required: true },
+                    { key: "to", required: true },
+                ],
+            }),
+            hasSectionKey: "hasBlockTransformsSection",
+        },
         value: {
             name: "BLOCK_TRANSFORMS",
             section: BLOCK_TRANSFORMS_CONST_SECTION,
@@ -238,6 +296,17 @@ const INVENTORY_SECTIONS = [
             name: "WorkspacePatternConfig",
             section: PATTERNS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "patterns",
+            entry: defineInventoryEntryParser({
+                entryName: "PATTERNS",
+                fields: [
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasPatternsSection",
+        },
         value: {
             name: "PATTERNS",
             section: PATTERNS_CONST_SECTION,
@@ -248,6 +317,20 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceBindingSourceConfig",
             section: BINDING_SOURCES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "bindingSources",
+            entry: defineInventoryEntryParser({
+                entryName: "BINDING_SOURCES",
+                fields: [
+                    { key: "attribute" },
+                    { key: "block" },
+                    { key: "editorFile", required: true },
+                    { key: "serverFile", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasBindingSourcesSection",
+        },
         value: {
             name: "BINDING_SOURCES",
             section: BINDING_SOURCES_CONST_SECTION,
@@ -258,6 +341,36 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceRestResourceConfig",
             section: REST_RESOURCES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "restResources",
+            entry: defineInventoryEntryParser({
+                entryName: "REST_RESOURCES",
+                fields: [
+                    { key: "apiFile", required: true },
+                    { key: "clientFile", required: true },
+                    { key: "dataFile", required: true },
+                    {
+                        key: "methods",
+                        kind: "stringArray",
+                        required: true,
+                        validate: (value, context) => {
+                            const methods = Array.isArray(value) ? value : [];
+                            const invalidMethods = methods.filter((method) => !REST_RESOURCE_METHOD_IDS.includes(method));
+                            if (invalidMethods.length > 0) {
+                                throw new Error(`${context.entryName}[${context.elementIndex}].${context.key} includes unsupported values: ${invalidMethods.join(", ")}.`);
+                            }
+                        },
+                    },
+                    { key: "namespace", required: true },
+                    { key: "openApiFile", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "typesFile", required: true },
+                    { key: "validatorsFile", required: true },
+                ],
+            }),
+            hasSectionKey: "hasRestResourcesSection",
+        },
         value: {
             name: "REST_RESOURCES",
             section: REST_RESOURCES_CONST_SECTION,
@@ -268,6 +381,25 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceAbilityConfig",
             section: ABILITIES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "abilities",
+            entry: defineInventoryEntryParser({
+                entryName: "ABILITIES",
+                fields: [
+                    { key: "clientFile", required: true },
+                    { key: "configFile", required: true },
+                    { key: "dataFile", required: true },
+                    { key: "inputSchemaFile", required: true },
+                    { key: "inputTypeName", required: true },
+                    { key: "outputSchemaFile", required: true },
+                    { key: "outputTypeName", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "typesFile", required: true },
+                ],
+            }),
+            hasSectionKey: "hasAbilitiesSection",
+        },
         value: {
             name: "ABILITIES",
             section: ABILITIES_CONST_SECTION,
@@ -278,6 +410,25 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceAiFeatureConfig",
             section: AI_FEATURES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "aiFeatures",
+            entry: defineInventoryEntryParser({
+                entryName: "AI_FEATURES",
+                fields: [
+                    { key: "aiSchemaFile", required: true },
+                    { key: "apiFile", required: true },
+                    { key: "clientFile", required: true },
+                    { key: "dataFile", required: true },
+                    { key: "namespace", required: true },
+                    { key: "openApiFile", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "typesFile", required: true },
+                    { key: "validatorsFile", required: true },
+                ],
+            }),
+            hasSectionKey: "hasAiFeaturesSection",
+        },
         value: {
             name: "AI_FEATURES",
             section: AI_FEATURES_CONST_SECTION,
@@ -288,6 +439,19 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceAdminViewConfig",
             section: ADMIN_VIEWS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "adminViews",
+            entry: defineInventoryEntryParser({
+                entryName: "ADMIN_VIEWS",
+                fields: [
+                    { key: "file", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "source" },
+                ],
+            }),
+            hasSectionKey: "hasAdminViewsSection",
+        },
         value: {
             name: "ADMIN_VIEWS",
             section: ADMIN_VIEWS_CONST_SECTION,
@@ -298,6 +462,18 @@ const INVENTORY_SECTIONS = [
             name: "WorkspaceEditorPluginConfig",
             section: EDITOR_PLUGINS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "editorPlugins",
+            entry: defineInventoryEntryParser({
+                entryName: "EDITOR_PLUGINS",
+                fields: [
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                    { key: "slot", required: true },
+                ],
+            }),
+            hasSectionKey: "hasEditorPluginsSection",
+        },
         value: {
             name: "EDITOR_PLUGINS",
             section: EDITOR_PLUGINS_CONST_SECTION,
@@ -383,169 +559,60 @@ function getRequiredStringArrayProperty(entryName, elementIndex, objectLiteral,
     }
     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)) {
-            throw new Error(`BLOCKS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            apiTypesFile: getOptionalStringProperty("BLOCKS", elementIndex, element, "apiTypesFile"),
-            attributeTypeName: getOptionalStringProperty("BLOCKS", elementIndex, element, "attributeTypeName"),
-            openApiFile: getOptionalStringProperty("BLOCKS", elementIndex, element, "openApiFile"),
-            slug: getRequiredStringProperty("BLOCKS", elementIndex, element, "slug"),
-            typesFile: getRequiredStringProperty("BLOCKS", elementIndex, element, "typesFile"),
-        };
-    });
-}
-function parseVariationEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`VARIATIONS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            block: getRequiredStringProperty("VARIATIONS", elementIndex, element, "block"),
-            file: getRequiredStringProperty("VARIATIONS", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("VARIATIONS", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseBlockStyleEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`BLOCK_STYLES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            block: getRequiredStringProperty("BLOCK_STYLES", elementIndex, element, "block"),
-            file: getRequiredStringProperty("BLOCK_STYLES", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("BLOCK_STYLES", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseBlockTransformEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`BLOCK_TRANSFORMS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            block: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "block"),
-            file: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "file"),
-            from: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "from"),
-            slug: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "slug"),
-            to: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "to"),
-        };
-    });
-}
-function parsePatternEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`PATTERNS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            file: getRequiredStringProperty("PATTERNS", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("PATTERNS", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseBindingSourceEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`BINDING_SOURCES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            attribute: getOptionalStringProperty("BINDING_SOURCES", elementIndex, element, "attribute"),
-            block: getOptionalStringProperty("BINDING_SOURCES", elementIndex, element, "block"),
-            editorFile: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "editorFile"),
-            serverFile: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "serverFile"),
-            slug: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseRestResourceEntries(arrayLiteral) {
+function parseInventoryEntries(arrayLiteral, descriptor) {
     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.`);
+            throw new Error(`${descriptor.entryName}[${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(", ")}.`);
+        const entry = {};
+        for (const field of descriptor.fields) {
+            const kind = field.kind ?? "string";
+            const value = kind === "stringArray"
+                ? getRequiredStringArrayProperty(descriptor.entryName, elementIndex, element, field.key)
+                : field.required
+                    ? getRequiredStringProperty(descriptor.entryName, elementIndex, element, field.key)
+                    : getOptionalStringProperty(descriptor.entryName, elementIndex, element, field.key);
+            field.validate?.(value, {
+                elementIndex,
+                entryName: descriptor.entryName,
+                key: field.key,
+            });
+            entry[field.key] = value;
         }
-        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"),
-        };
+        return entry;
     });
 }
-function parseAiFeatureEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`AI_FEATURES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
+function parseInventorySection(sourceFile, descriptor) {
+    if (!descriptor.parse) {
         return {
-            aiSchemaFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "aiSchemaFile"),
-            apiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "apiFile"),
-            clientFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "clientFile"),
-            dataFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "dataFile"),
-            namespace: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "namespace"),
-            openApiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "openApiFile"),
-            phpFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "phpFile"),
-            slug: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "slug"),
-            typesFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "typesFile"),
-            validatorsFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "validatorsFile"),
+            entries: [],
+            found: false,
         };
-    });
-}
-function parseAbilityEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`ABILITIES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            clientFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "clientFile"),
-            configFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "configFile"),
-            dataFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "dataFile"),
-            inputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputSchemaFile"),
-            inputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputTypeName"),
-            outputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputSchemaFile"),
-            outputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputTypeName"),
-            phpFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "phpFile"),
-            slug: getRequiredStringProperty("ABILITIES", elementIndex, element, "slug"),
-            typesFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "typesFile"),
-        };
-    });
-}
-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.`);
+    }
+    const exportName = descriptor.parse.exportName ?? descriptor.value?.name;
+    if (!exportName) {
+        throw new Error("Inventory parser descriptor is missing an export name.");
+    }
+    const exportedArray = findExportedArrayLiteral(sourceFile, exportName);
+    if (!exportedArray.found) {
+        if (descriptor.parse.required) {
+            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
         }
         return {
-            file: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slug"),
-            slot: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slot"),
+            entries: [],
+            found: false,
         };
-    });
-}
-function parseAdminViewEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`ADMIN_VIEWS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+    }
+    if (!exportedArray.array) {
+        if (descriptor.parse.required) {
+            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
         }
-        return {
-            file: getRequiredStringProperty("ADMIN_VIEWS", elementIndex, element, "file"),
-            phpFile: getRequiredStringProperty("ADMIN_VIEWS", elementIndex, element, "phpFile"),
-            slug: getRequiredStringProperty("ADMIN_VIEWS", elementIndex, element, "slug"),
-            source: getOptionalStringProperty("ADMIN_VIEWS", elementIndex, element, "source"),
-        };
-    });
+        throw new Error(`scripts/block-config.ts must export ${exportName} as an array literal.`);
+    }
+    return {
+        entries: parseInventoryEntries(exportedArray.array, descriptor.parse.entry),
+        found: true,
+    };
 }
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
@@ -556,82 +623,42 @@ function parseAdminViewEntries(arrayLiteral) {
  */
 export function parseWorkspaceInventorySource(source) {
     const sourceFile = ts.createSourceFile("block-config.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const blockArray = findExportedArrayLiteral(sourceFile, "BLOCKS");
-    if (!blockArray.found || !blockArray.array) {
-        throw new Error("scripts/block-config.ts must export a BLOCKS array.");
-    }
-    const variationArray = findExportedArrayLiteral(sourceFile, "VARIATIONS");
-    const blockStyleArray = findExportedArrayLiteral(sourceFile, "BLOCK_STYLES");
-    const blockTransformArray = findExportedArrayLiteral(sourceFile, "BLOCK_TRANSFORMS");
-    const patternArray = findExportedArrayLiteral(sourceFile, "PATTERNS");
-    const bindingSourceArray = findExportedArrayLiteral(sourceFile, "BINDING_SOURCES");
-    const restResourceArray = findExportedArrayLiteral(sourceFile, "REST_RESOURCES");
-    const abilityArray = findExportedArrayLiteral(sourceFile, "ABILITIES");
-    const aiFeatureArray = findExportedArrayLiteral(sourceFile, "AI_FEATURES");
-    const adminViewArray = findExportedArrayLiteral(sourceFile, "ADMIN_VIEWS");
-    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.");
-    }
-    if (blockStyleArray.found && !blockStyleArray.array) {
-        throw new Error("scripts/block-config.ts must export BLOCK_STYLES as an array literal.");
-    }
-    if (blockTransformArray.found && !blockTransformArray.array) {
-        throw new Error("scripts/block-config.ts must export BLOCK_TRANSFORMS as an array literal.");
-    }
-    if (patternArray.found && !patternArray.array) {
-        throw new Error("scripts/block-config.ts must export PATTERNS as an array literal.");
-    }
-    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 (abilityArray.found && !abilityArray.array) {
-        throw new Error("scripts/block-config.ts must export ABILITIES as an array literal.");
-    }
-    if (aiFeatureArray.found && !aiFeatureArray.array) {
-        throw new Error("scripts/block-config.ts must export AI_FEATURES as an array literal.");
-    }
-    if (adminViewArray.found && !adminViewArray.array) {
-        throw new Error("scripts/block-config.ts must export ADMIN_VIEWS 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 {
-        abilities: abilityArray.array ? parseAbilityEntries(abilityArray.array) : [],
-        adminViews: adminViewArray.array ? parseAdminViewEntries(adminViewArray.array) : [],
-        aiFeatures: aiFeatureArray.array ? parseAiFeatureEntries(aiFeatureArray.array) : [],
-        bindingSources: bindingSourceArray.array
-            ? parseBindingSourceEntries(bindingSourceArray.array)
-            : [],
-        blockStyles: blockStyleArray.array ? parseBlockStyleEntries(blockStyleArray.array) : [],
-        blockTransforms: blockTransformArray.array
-            ? parseBlockTransformEntries(blockTransformArray.array)
-            : [],
-        blocks: parseBlockEntries(blockArray.array),
-        hasAbilitiesSection: abilityArray.found,
-        hasAdminViewsSection: adminViewArray.found,
-        hasAiFeaturesSection: aiFeatureArray.found,
-        hasBindingSourcesSection: bindingSourceArray.found,
-        hasBlockStylesSection: blockStyleArray.found,
-        hasBlockTransformsSection: blockTransformArray.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)
-            : [],
+    const parsedInventory = {
+        abilities: [],
+        adminViews: [],
+        aiFeatures: [],
+        bindingSources: [],
+        blockStyles: [],
+        blockTransforms: [],
+        blocks: parseInventorySection(sourceFile, BLOCK_INVENTORY_SECTION).entries,
+        editorPlugins: [],
+        hasAbilitiesSection: false,
+        hasAdminViewsSection: false,
+        hasAiFeaturesSection: false,
+        hasBindingSourcesSection: false,
+        hasBlockStylesSection: false,
+        hasBlockTransformsSection: false,
+        hasEditorPluginsSection: false,
+        hasPatternsSection: false,
+        hasRestResourcesSection: false,
+        hasVariationsSection: false,
+        patterns: [],
+        restResources: [],
         source,
-        variations: variationArray.array ? parseVariationEntries(variationArray.array) : [],
+        variations: [],
     };
+    const mutableInventory = parsedInventory;
+    for (const section of INVENTORY_SECTIONS) {
+        if (!section.parse) {
+            continue;
+        }
+        const parsedSection = parseInventorySection(sourceFile, section);
+        mutableInventory[section.parse.entriesKey] = parsedSection.entries;
+        if (section.parse.hasSectionKey) {
+            mutableInventory[section.parse.hasSectionKey] = parsedSection.found;
+        }
+    }
+    return parsedInventory;
 }
 /**
  * Read and parse the canonical workspace inventory file.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.22.4",
+  "version": "0.22.5",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",