@wp-typia/project-tools 0.22.3 → 0.22.5

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,6 +205,281 @@ 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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+    {
+        interface: {
+            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,
+        },
+    },
+];
 function getPropertyNameText(name) {
     if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
         return name.text;
@@ -281,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(", ")}.`);
-        }
-        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 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.`);
+        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 {
-            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"),
-        };
+        return entry;
     });
 }
-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.`);
-        }
+function parseInventorySection(sourceFile, descriptor) {
+    if (!descriptor.parse) {
         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"),
+            entries: [],
+            found: false,
         };
-    });
-}
-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`.
@@ -454,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.
@@ -576,68 +705,23 @@ export function getWorkspaceBlockSelectOptions(projectDir) {
 }
 function ensureWorkspaceInventorySections(source) {
     let nextSource = source.trimEnd();
-    if (!/export\s+interface\s+WorkspaceVariationConfig\b/u.test(nextSource)) {
-        nextSource += VARIATIONS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+VARIATIONS\b/u.test(nextSource)) {
-        nextSource += VARIATIONS_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceBlockStyleConfig\b/u.test(nextSource)) {
-        nextSource += BLOCK_STYLES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+BLOCK_STYLES\b/u.test(nextSource)) {
-        nextSource += BLOCK_STYLES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceBlockTransformConfig\b/u.test(nextSource)) {
-        nextSource += BLOCK_TRANSFORMS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+BLOCK_TRANSFORMS\b/u.test(nextSource)) {
-        nextSource += BLOCK_TRANSFORMS_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspacePatternConfig\b/u.test(nextSource)) {
-        nextSource += PATTERNS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+PATTERNS\b/u.test(nextSource)) {
-        nextSource += PATTERNS_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceBindingSourceConfig\b/u.test(nextSource)) {
-        nextSource += BINDING_SOURCES_INTERFACE_SECTION;
-    }
-    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+WorkspaceAbilityConfig\b/u.test(nextSource)) {
-        nextSource += ABILITIES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+ABILITIES\b/u.test(nextSource)) {
-        nextSource += ABILITIES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceAiFeatureConfig\b/u.test(nextSource)) {
-        nextSource += AI_FEATURES_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+AI_FEATURES\b/u.test(nextSource)) {
-        nextSource += AI_FEATURES_CONST_SECTION;
-    }
-    if (!/export\s+interface\s+WorkspaceAdminViewConfig\b/u.test(nextSource)) {
-        nextSource += ADMIN_VIEWS_INTERFACE_SECTION;
-    }
-    if (!/export\s+const\s+ADMIN_VIEWS\b/u.test(nextSource)) {
-        nextSource += ADMIN_VIEWS_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;
+    for (const section of INVENTORY_SECTIONS) {
+        if (section.interface &&
+            !hasExportedInterface(nextSource, section.interface.name)) {
+            nextSource += section.interface.section;
+        }
+        if (section.value && !hasExportedConst(nextSource, section.value.name)) {
+            nextSource += section.value.section;
+        }
     }
     return `${nextSource}\n`;
 }
+function hasExportedInterface(source, interfaceName) {
+    return new RegExp(`export\\s+interface\\s+${escapeRegex(interfaceName)}\\b`, "u").test(source);
+}
+function hasExportedConst(source, constName) {
+    return new RegExp(`export\\s+const\\s+${escapeRegex(constName)}\\b`, "u").test(source);
+}
 function appendEntriesAtMarker(source, marker, entries) {
     if (entries.length === 0) {
         return source;