@wp-typia/project-tools 0.24.7 → 0.24.9

package/dist/runtime/doctor/cli-doctor-wordpress-version.js

@@ -1,24 +1,53 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
-import ts from "typescript";
+import { WORDPRESS_BLOCK_API_COMPATIBILITY } from "@wp-typia/block-types/blocks/compatibility";
 import { createDoctorCheck, resolveWorkspaceBootstrapPath, } from "./cli-doctor-workspace-shared.js";
 import { readJsonFileSync } from "../shared/json-utils.js";
-import { getPropertyNameText } from "../shared/ts-property-names.js";
 import { compareVersionFloors, pickHigherVersionFloor, } from "../shared/version-floor.js";
 import { DEFAULT_SCAFFOLD_WORDPRESS_TARGET_VERSION } from "../templates/scaffold-compatibility.js";
 const WORDPRESS_VERSION_CHECK_CODES = {
     featureMinimum: "wp-typia.workspace.wordpress.feature-minimum",
     testedTarget: "wp-typia.workspace.wordpress.tested-target",
 };
-const BLOCK_METADATA_WORDPRESS_FLOORS = {
-    blockHooks: "6.4",
-    supportsInteractivity: "6.5",
-    supportsSplitting: "6.5",
+// Both entries read the same `variations` field and are distinguished by value type.
+const BLOCK_VARIATION_BLOCK_JSON_KEYS = {
+    registrationBlockJsonMetadata: "variations",
+    registrationMetadataFile: "variations",
 };
 function isEnabledMetadataValue(value) {
     return value !== undefined && value !== false && value !== null;
 }
+function isEnabledBlockVariationMetadataFeature(feature, value) {
+    if (feature === "registrationBlockJsonMetadata") {
+        return Array.isArray(value) && value.length > 0;
+    }
+    if (feature === "registrationMetadataFile") {
+        return typeof value === "string" && value.trim().length > 0;
+    }
+    return isEnabledMetadataValue(value);
+}
+function getNestedMetadataValue(object, key) {
+    if (!object) {
+        return undefined;
+    }
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+        return object[key];
+    }
+    return key
+        .split(".")
+        .reduce((current, segment) => {
+        if (current === null ||
+            typeof current !== "object" ||
+            Array.isArray(current)) {
+            return undefined;
+        }
+        const record = current;
+        return Object.prototype.hasOwnProperty.call(record, segment)
+            ? record[segment]
+            : undefined;
+    }, object);
+}
 function getBootstrapHeaderValue(source, headerName) {
     const escapedHeaderName = headerName.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
     const pattern = new RegExp(`^\\s*\\*\\s*${escapedHeaderName}:\\s*([^\\r\\n]*)`, "mu");
@@ -42,6 +71,15 @@ function pushRequirement(requirements, label, version) {
         version,
     });
 }
+function pushBlockApiRequirement(requirements, labelPrefix, entry) {
+    pushRequirement(requirements, `${labelPrefix} ${entry.label}`, entry.since);
+}
+function readExistingTextFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+    return fs.readFileSync(filePath, "utf8");
+}
 function collectBlockMetadataRequirements(workspace, inventory) {
     const issues = [];
     const requirements = [];
@@ -61,14 +99,31 @@ function collectBlockMetadataRequirements(workspace, inventory) {
             issues.push(`${blockJsonRelativePath}: ${error instanceof Error ? error.message : String(error)}`);
             continue;
         }
-        if (isEnabledMetadataValue(blockJson.supports?.interactivity)) {
-            pushRequirement(requirements, `Block ${block.slug} supports.interactivity`, BLOCK_METADATA_WORDPRESS_FLOORS.supportsInteractivity);
+        for (const [feature, entry] of Object.entries(WORDPRESS_BLOCK_API_COMPATIBILITY.blockSupports)) {
+            if (isEnabledMetadataValue(getNestedMetadataValue(blockJson.supports, feature))) {
+                pushBlockApiRequirement(requirements, `Block ${block.slug}`, entry);
+            }
+        }
+        for (const [feature, entry] of Object.entries(WORDPRESS_BLOCK_API_COMPATIBILITY.blockMetadata)) {
+            if (isEnabledMetadataValue(getNestedMetadataValue(blockJson, feature))) {
+                pushBlockApiRequirement(requirements, `Block ${block.slug}`, entry);
+            }
         }
-        if (isEnabledMetadataValue(blockJson.supports?.splitting)) {
-            pushRequirement(requirements, `Block ${block.slug} supports.splitting`, BLOCK_METADATA_WORDPRESS_FLOORS.supportsSplitting);
+        for (const [feature, entry] of Object.entries(WORDPRESS_BLOCK_API_COMPATIBILITY.blockBindings)) {
+            if (entry.runtime.includes("block-json") &&
+                isEnabledMetadataValue(getNestedMetadataValue(blockJson, feature))) {
+                pushBlockApiRequirement(requirements, `Block ${block.slug}`, entry);
+            }
         }
-        if (blockJson.blockHooks !== undefined) {
-            pushRequirement(requirements, `Block ${block.slug} blockHooks`, BLOCK_METADATA_WORDPRESS_FLOORS.blockHooks);
+        for (const [feature, entry] of Object.entries(WORDPRESS_BLOCK_API_COMPATIBILITY.blockVariations)) {
+            if (!entry.runtime.includes("block-json")) {
+                continue;
+            }
+            const blockJsonFeature = feature;
+            const blockJsonKey = BLOCK_VARIATION_BLOCK_JSON_KEYS[blockJsonFeature];
+            if (isEnabledBlockVariationMetadataFeature(blockJsonFeature, getNestedMetadataValue(blockJson, blockJsonKey))) {
+                pushBlockApiRequirement(requirements, `Block ${block.slug}`, entry);
+            }
         }
     }
     return {
@@ -76,89 +131,100 @@ function collectBlockMetadataRequirements(workspace, inventory) {
         requirements,
     };
 }
-function findExportedArrayLiteral(sourceFile, exportName) {
-    for (const statement of sourceFile.statements) {
-        if (!ts.isVariableStatement(statement) ||
-            !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-            continue;
-        }
-        for (const declaration of statement.declarationList.declarations) {
-            if (ts.isIdentifier(declaration.name) &&
-                declaration.name.text === exportName &&
-                declaration.initializer &&
-                ts.isArrayLiteralExpression(declaration.initializer)) {
-                return declaration.initializer;
-            }
-        }
+function hasGeneratedCoreVariationModule(directoryPath, isRootDirectory = true) {
+    if (!fs.existsSync(directoryPath)) {
+        return false;
     }
-    return null;
-}
-function getObjectProperty(objectLiteral, key) {
-    for (const property of objectLiteral.properties) {
-        if (!ts.isPropertyAssignment(property)) {
-            continue;
+    for (const entry of fs.readdirSync(directoryPath, { withFileTypes: true })) {
+        const entryPath = path.join(directoryPath, entry.name);
+        if (entry.isDirectory() && hasGeneratedCoreVariationModule(entryPath, false)) {
+            return true;
         }
-        if (getPropertyNameText(property.name) === key) {
-            return property.initializer;
+        if (!isRootDirectory &&
+            entry.isFile() &&
+            entry.name.endsWith(".ts") &&
+            entry.name !== "index.ts") {
+            return true;
         }
     }
-    return undefined;
-}
-function getObjectLiteralProperty(objectLiteral, key) {
-    const property = objectLiteral ? getObjectProperty(objectLiteral, key) : undefined;
-    return property && ts.isObjectLiteralExpression(property) ? property : undefined;
+    return false;
 }
-function getStringLiteralProperty(objectLiteral, key) {
-    const property = getObjectProperty(objectLiteral, key);
-    return property && ts.isStringLiteralLike(property) ? property.text : undefined;
+function collectVariationRequirements(workspace, inventory) {
+    const requirements = [];
+    const variationEntries = WORDPRESS_BLOCK_API_COMPATIBILITY.blockVariations;
+    for (const variation of inventory.variations) {
+        pushBlockApiRequirement(requirements, `Variation ${variation.block}/${variation.slug}`, variationEntries.editorRegistration);
+    }
+    const coreVariationsDir = path.join(workspace.projectDir, "src", "editor-plugins", "core-variations");
+    if (hasGeneratedCoreVariationModule(coreVariationsDir)) {
+        pushBlockApiRequirement(requirements, "Core variations editor plugin", variationEntries.editorRegistration);
+    }
+    return {
+        issues: [],
+        requirements,
+    };
 }
 function collectInventoryCompatibilityRequirements(inventory) {
-    const issues = [];
     const requirements = [];
-    const sourceFile = ts.createSourceFile("scripts/block-config.ts", inventory.source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    for (const section of [
-        { exportName: "ABILITIES", label: "Ability" },
-        { exportName: "AI_FEATURES", label: "AI feature" },
-    ]) {
-        const arrayLiteral = findExportedArrayLiteral(sourceFile, section.exportName);
-        if (!arrayLiteral) {
-            continue;
+    for (const ability of inventory.abilities) {
+        const wordpressMinimum = ability.compatibility?.hardMinimums.wordpress;
+        if (wordpressMinimum) {
+            requirements.push({
+                label: `Ability ${ability.slug} compatibility metadata`,
+                version: wordpressMinimum,
+            });
         }
-        arrayLiteral.elements.forEach((element, elementIndex) => {
-            if (!ts.isObjectLiteralExpression(element)) {
-                return;
-            }
-            const slug = getStringLiteralProperty(element, "slug") ?? `entry ${elementIndex + 1}`;
-            const compatibility = getObjectLiteralProperty(element, "compatibility");
-            const hardMinimums = getObjectLiteralProperty(compatibility, "hardMinimums");
-            const wordpressMinimum = hardMinimums
-                ? getObjectProperty(hardMinimums, "wordpress")
-                : undefined;
-            if (wordpressMinimum === undefined) {
-                return;
-            }
-            if (!ts.isStringLiteralLike(wordpressMinimum)) {
-                issues.push(`${section.exportName}[${elementIndex}].compatibility.hardMinimums.wordpress must be a string literal.`);
-                return;
-            }
+    }
+    for (const aiFeature of inventory.aiFeatures) {
+        const wordpressMinimum = aiFeature.compatibility?.hardMinimums.wordpress;
+        if (wordpressMinimum) {
             requirements.push({
-                label: `${section.label} ${slug} compatibility metadata`,
-                version: wordpressMinimum.text,
+                label: `AI feature ${aiFeature.slug} compatibility metadata`,
+                version: wordpressMinimum,
             });
-        });
+        }
     }
     return {
-        issues,
+        issues: [],
+        requirements,
+    };
+}
+function collectBindingSourceRequirements(workspace, inventory) {
+    const requirements = [];
+    const bindingEntries = WORDPRESS_BLOCK_API_COMPATIBILITY.blockBindings;
+    for (const bindingSource of inventory.bindingSources) {
+        pushBlockApiRequirement(requirements, `Binding source ${bindingSource.slug}`, bindingEntries.serverRegistration);
+        pushBlockApiRequirement(requirements, `Binding source ${bindingSource.slug}`, bindingEntries.editorRegistration);
+        const editorFilePath = path.join(workspace.projectDir, bindingSource.editorFile);
+        if (readExistingTextFile(editorFilePath)?.includes("getFieldsList")) {
+            pushBlockApiRequirement(requirements, `Binding source ${bindingSource.slug}`, bindingEntries.editorFieldsList);
+        }
+        const serverFilePath = path.join(workspace.projectDir, bindingSource.serverFile);
+        if (readExistingTextFile(serverFilePath)?.includes("block_bindings_supported_attributes_")) {
+            pushBlockApiRequirement(requirements, `Binding source ${bindingSource.slug}`, bindingEntries.supportedAttributesFilter);
+        }
+    }
+    return {
+        issues: [],
         requirements,
     };
 }
 function collectWordPressVersionRequirements(workspace, inventory) {
     const blockRequirements = collectBlockMetadataRequirements(workspace, inventory);
+    const variationRequirements = collectVariationRequirements(workspace, inventory);
+    const bindingRequirements = collectBindingSourceRequirements(workspace, inventory);
     const inventoryRequirements = collectInventoryCompatibilityRequirements(inventory);
     return {
-        issues: [...blockRequirements.issues, ...inventoryRequirements.issues],
+        issues: [
+            ...blockRequirements.issues,
+            ...variationRequirements.issues,
+            ...bindingRequirements.issues,
+            ...inventoryRequirements.issues,
+        ],
         requirements: [
             ...blockRequirements.requirements,
+            ...variationRequirements.requirements,
+            ...bindingRequirements.requirements,
             ...inventoryRequirements.requirements,
         ],
     };

package/dist/runtime/workspace/workspace-inventory-parser-entries.js

@@ -1,5 +1,6 @@
 import ts from "typescript";
 import { getPropertyNameText } from "../shared/ts-property-names.js";
+import { parseVersionFloorParts } from "../shared/version-floor.js";
 import { assertParsedInventoryEntry, } from "./workspace-inventory-parser-validation.js";
 function findExportedArrayLiteral(sourceFile, exportName) {
     for (const statement of sourceFile.statements) {
@@ -129,6 +130,19 @@ function getOptionalNestedStringProperty(objectLiteral, key, context) {
     }
     return expression.text;
 }
+function getOptionalVersionFloorProperty(objectLiteral, key, context) {
+    const value = getOptionalNestedStringProperty(objectLiteral, key, context);
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        parseVersionFloorParts(value);
+    }
+    catch {
+        throw new Error(`${context}.${key} must be a dotted numeric version such as "6.7" or "8.1.2" in scripts/block-config.ts.`);
+    }
+    return value;
+}
 function getRequiredStringArrayProperty(objectLiteral, key, context) {
     const expression = findObjectPropertyExpression(objectLiteral, key);
     if (!expression) {
@@ -150,8 +164,8 @@ function parseCompatibilityConfigLiteral(objectLiteral, context) {
     if (mode !== "baseline" && mode !== "optional" && mode !== "required") {
         throw new Error(`${context}.mode must be baseline, optional, or required in scripts/block-config.ts.`);
     }
-    const php = getOptionalNestedStringProperty(hardMinimumsObject, "php", `${context}.hardMinimums`);
-    const wordpress = getOptionalNestedStringProperty(hardMinimumsObject, "wordpress", `${context}.hardMinimums`);
+    const php = getOptionalVersionFloorProperty(hardMinimumsObject, "php", `${context}.hardMinimums`);
+    const wordpress = getOptionalVersionFloorProperty(hardMinimumsObject, "wordpress", `${context}.hardMinimums`);
     return {
         hardMinimums: {
             ...(php ? { php } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.24.7",
+  "version": "0.24.9",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -121,7 +121,7 @@
     "package.json"
   ],
   "scripts": {
-    "build": "bun run --filter @wp-typia/api-client build && bun run --filter @wp-typia/block-runtime build && rm -rf dist && tsc -p tsconfig.runtime.json",
+    "build": "bun run --filter @wp-typia/block-types build && bun run --filter @wp-typia/api-client build && bun run --filter @wp-typia/block-runtime build && rm -rf dist && tsc -p tsconfig.runtime.json",
     "prepack": "bun run build && node ./scripts/publish-manifest.mjs prepare",
     "postpack": "node ./scripts/publish-manifest.mjs restore",
     "test": "bun run build && bun test tests/*.test.ts",
@@ -168,7 +168,7 @@
     "@wp-typia/api-client": "^0.4.6",
     "@wp-typia/block-runtime": "^0.7.1",
     "@wp-typia/rest": "^0.3.14",
-    "@wp-typia/block-types": "^0.3.4",
+    "@wp-typia/block-types": "^0.3.5",
     "mustache": "^4.2.0",
     "npm-package-arg": "^13.0.0",
     "semver": "^7.7.3",