@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/cli-doctor-workspace-block-iframe.js

@@ -1,228 +1 @@
-import fs from "node:fs";
-import path from "node:path";
-import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
-import { createDoctorCheck } from "./cli-doctor-workspace-shared.js";
-import { readJsonFileSync } from "./json-utils.js";
-import { hasExecutablePattern, maskTypeScriptCommentsAndLiterals, } from "./ts-source-masking.js";
-const WORKSPACE_BLOCK_IFRAME_COMPATIBILITY_DOC_URL = "https://developer.wordpress.org/block-editor/reference-guides/block-api/block-api-versions/block-migration-for-iframe-editor-compatibility/";
-const WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES = {
-    API_VERSION: "wp-typia.workspace.block.iframe.api-version",
-    BLOCK_PROPS: "wp-typia.workspace.block.iframe.block-props",
-    EDITOR_GLOBALS: "wp-typia.workspace.block.iframe.editor-globals",
-    EDITOR_STYLES: "wp-typia.workspace.block.iframe.editor-styles",
-};
-const WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN = /\.[cm]?[jt]sx?$/u;
-const WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES = new Set([
-    "edit",
-    "editor",
-    "index",
-    "save",
-]);
-const WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES = new Set([
-    "components",
-    "controls",
-    "editor",
-    "inspector",
-]);
-const WORKSPACE_BLOCK_LOCAL_STYLE_FILES = [
-    "editor.css",
-    "editor.scss",
-    "index.css",
-    "style.css",
-    "style.scss",
-];
-const WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN = /\b(?:document|window)\b|\b(?:parent|top)\b(?!\s*:)/gu;
-const WORKSPACE_BLOCK_PROPS_PATTERN = /\buse(?:Block|InnerBlocks)Props(?:\.save)?\s*\(/u;
-function normalizePathSeparators(relativePath) {
-    return relativePath.split(path.sep).join("/");
-}
-function hasRegisteredBlockAsset(value) {
-    if (typeof value === "string") {
-        return value.trim().length > 0;
-    }
-    if (Array.isArray(value)) {
-        return value.some((entry) => hasRegisteredBlockAsset(entry));
-    }
-    return false;
-}
-function readWorkspaceBlockIframeMetadata(projectDir, blockSlug) {
-    const blockJsonRelativePath = path.join("src", "blocks", blockSlug, "block.json");
-    const blockJsonPath = path.join(projectDir, blockJsonRelativePath);
-    if (!fs.existsSync(blockJsonPath)) {
-        return {
-            blockJsonRelativePath,
-            error: `Missing ${blockJsonRelativePath}`,
-        };
-    }
-    try {
-        const document = parseScaffoldBlockMetadata(readJsonFileSync(blockJsonPath, {
-            context: "workspace block metadata",
-        }));
-        return {
-            blockJsonRelativePath,
-            document,
-        };
-    }
-    catch (error) {
-        return {
-            blockJsonRelativePath,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-function isWorkspaceBlockEditorSource(relativePath) {
-    if (!WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN.test(relativePath)) {
-        return false;
-    }
-    const normalizedRelativePath = normalizePathSeparators(relativePath);
-    const normalizedDirName = path.posix.dirname(normalizedRelativePath);
-    const normalizedBaseName = path.posix.basename(normalizedRelativePath, path.posix.extname(normalizedRelativePath));
-    if (WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES.has(normalizedBaseName)) {
-        return true;
-    }
-    const pathSegments = normalizedDirName.split("/");
-    return pathSegments.some((segment) => WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES.has(segment));
-}
-function isWorkspaceBlockSaveSource(relativePath) {
-    const normalizedBaseName = path.basename(relativePath, path.extname(relativePath));
-    return normalizedBaseName === "save";
-}
-function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
-    const blockDir = path.join(projectDir, "src", "blocks", blockSlug);
-    if (!fs.existsSync(blockDir)) {
-        return [];
-    }
-    const collected = [];
-    const queue = [blockDir];
-    while (queue.length > 0) {
-        const currentDir = queue.pop();
-        if (!currentDir) {
-            continue;
-        }
-        for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
-            const absolutePath = path.join(currentDir, entry.name);
-            if (entry.isDirectory()) {
-                queue.push(absolutePath);
-                continue;
-            }
-            if (!entry.isFile()) {
-                continue;
-            }
-            const relativePath = path.relative(projectDir, absolutePath);
-            if (!isWorkspaceBlockEditorSource(relativePath)) {
-                continue;
-            }
-            collected.push({
-                relativePath: normalizePathSeparators(relativePath),
-                source: fs.readFileSync(absolutePath, "utf8"),
-            });
-        }
-    }
-    return collected.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
-}
-function getSourceLineNumber(source, index) {
-    let line = 1;
-    for (let cursor = 0; cursor < index; cursor += 1) {
-        if (source[cursor] === "\n") {
-            line += 1;
-        }
-    }
-    return line;
-}
-function isGlobalDomAccessCandidate(source, index, identifier) {
-    const lineStart = source.lastIndexOf("\n", index - 1) + 1;
-    const lineEndCandidate = source.indexOf("\n", index);
-    const lineEnd = lineEndCandidate === -1 ? source.length : lineEndCandidate;
-    const lineSource = source.slice(lineStart, lineEnd);
-    const trimmedLine = lineSource.trimStart();
-    if (trimmedLine.startsWith("import ")) {
-        return false;
-    }
-    if (trimmedLine.startsWith("const ") ||
-        trimmedLine.startsWith("let ") ||
-        trimmedLine.startsWith("var ")) {
-        return false;
-    }
-    if (trimmedLine.startsWith("function ") || trimmedLine.startsWith("class ")) {
-        return false;
-    }
-    const precedingCharacter = index > 0 ? source[index - 1] : "";
-    if (precedingCharacter === "." || precedingCharacter === "'" || precedingCharacter === '"') {
-        return false;
-    }
-    return (identifier === "document" ||
-        identifier === "window" ||
-        identifier === "parent" ||
-        identifier === "top");
-}
-function findWorkspaceBlockGlobalDomAccesses(editorSources) {
-    return editorSources.flatMap(({ relativePath, source }) => {
-        const maskedSource = maskTypeScriptCommentsAndLiterals(source);
-        const matches = maskedSource.matchAll(WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN);
-        const findings = [];
-        for (const match of matches) {
-            const identifier = match[0];
-            const matchIndex = match.index ?? -1;
-            if (matchIndex < 0) {
-                continue;
-            }
-            if (!isGlobalDomAccessCandidate(source, matchIndex, identifier)) {
-                continue;
-            }
-            findings.push(`${relativePath}:${getSourceLineNumber(source, matchIndex)}`);
-        }
-        return findings;
-    });
-}
-/**
- * Collect iframe/API v3 compatibility checks for one workspace block.
- *
- * @param projectDir Absolute workspace project root.
- * @param blockSlug Block slug from the workspace inventory.
- * @returns Ordered iframe compatibility doctor checks.
- */
-export function getWorkspaceBlockIframeCompatibilityChecks(projectDir, blockSlug) {
-    const metadataResult = readWorkspaceBlockIframeMetadata(projectDir, blockSlug);
-    if (!metadataResult.document) {
-        return [
-            createDoctorCheck(`Block iframe/API v3 ${blockSlug}`, "warn", metadataResult.error ?? `Unable to inspect ${metadataResult.blockJsonRelativePath}`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.API_VERSION),
-        ];
-    }
-    const blockJson = metadataResult.document;
-    const apiVersion = typeof blockJson.apiVersion === "number" && Number.isFinite(blockJson.apiVersion)
-        ? blockJson.apiVersion
-        : null;
-    const blockDir = path.join(projectDir, "src", "blocks", blockSlug);
-    const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs.existsSync(path.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path.join("src", "blocks", blockSlug, fileName)));
-    const hasRegisteredEditorStyles = hasRegisteredBlockAsset(blockJson.style) ||
-        hasRegisteredBlockAsset(blockJson.editorStyle);
-    const editorSources = collectWorkspaceBlockEditorSources(projectDir, blockSlug);
-    const editorWrapperSources = editorSources.filter((source) => !isWorkspaceBlockSaveSource(source.relativePath));
-    const globalDomAccesses = findWorkspaceBlockGlobalDomAccesses(editorSources);
-    const hasBlockPropsUsage = editorSources.some(({ source }) => hasExecutablePattern(source, WORKSPACE_BLOCK_PROPS_PATTERN));
-    const hasEditorBlockPropsUsage = editorWrapperSources.some(({ source }) => hasExecutablePattern(source, WORKSPACE_BLOCK_PROPS_PATTERN));
-    const blockWrapperStatus = editorWrapperSources.length === 0 || hasEditorBlockPropsUsage ? "pass" : "warn";
-    const blockWrapperDetail = editorSources.length === 0
-        ? "No editor-facing block source files found; general file checks will report missing entrypoints"
-        : editorWrapperSources.length === 0
-            ? "No editor wrapper source files found; general file checks will report missing entrypoints"
-            : hasEditorBlockPropsUsage
-                ? "Editor-facing sources use block wrapper props"
-                : hasBlockPropsUsage
-                    ? "Only save-facing useBlockProps.save() usage was detected. Confirm the editor wrapper also receives useBlockProps() or useInnerBlocksProps() before relying on iframe editor rendering."
-                    : "No useBlockProps(), useBlockProps.save(), or useInnerBlocksProps() usage was detected in editor-facing sources. Confirm the block wrapper receives WordPress block editor props before relying on iframe editor rendering.";
-    return [
-        createDoctorCheck(`Block iframe API version ${blockSlug}`, apiVersion !== null && apiVersion >= 3 ? "pass" : "warn", apiVersion !== null && apiVersion >= 3
-            ? "block.json declares apiVersion 3 for iframe editor readiness"
-            : `Set ${metadataResult.blockJsonRelativePath} apiVersion to 3 after testing the block in iframe-enabled Post Editor and Site Editor contexts. WordPress recommends API v3 for iframe editor compatibility. See ${WORKSPACE_BLOCK_IFRAME_COMPATIBILITY_DOC_URL}`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.API_VERSION),
-        createDoctorCheck(`Block iframe styles ${blockSlug}`, localStyleFiles.length === 0 || hasRegisteredEditorStyles ? "pass" : "warn", localStyleFiles.length === 0
-            ? "No local block stylesheet source files found to register"
-            : hasRegisteredEditorStyles
-                ? "block.json registers block styles for iframe editor loading"
-                : `Found stylesheet source files (${localStyleFiles.join(", ")}) but block.json does not declare style or editorStyle. Register block content styles so iframe editors do not depend on parent admin styles.`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.EDITOR_STYLES),
-        createDoctorCheck(`Block iframe globals ${blockSlug}`, globalDomAccesses.length === 0 ? "pass" : "warn", globalDomAccesses.length === 0
-            ? "No direct window/document/parent DOM access detected in editor-facing block sources"
-            : `Direct global DOM access detected at ${globalDomAccesses.join(", ")}. Prefer element.ownerDocument/defaultView via refs or useRefEffect for iframe editor content.`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.EDITOR_GLOBALS),
-        createDoctorCheck(`Block iframe wrapper ${blockSlug}`, blockWrapperStatus, blockWrapperDetail, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.BLOCK_PROPS),
-    ];
-}
+export * from "./doctor/cli-doctor-workspace-block-iframe.js";

package/dist/runtime/cli-doctor-workspace-block-metadata.d.ts

@@ -1,11 +1 @@
-import type { DoctorCheck } from "./cli-doctor.js";
-import type { WorkspaceInventory } from "./workspace-inventory.js";
-import type { WorkspaceProject } from "./workspace-project.js";
-/**
- * Collect base file, metadata, hook, and collection-import checks for one block.
- *
- * @param workspace Resolved workspace metadata and filesystem paths.
- * @param block Inventory row describing the generated block.
- * @returns Ordered block core doctor checks.
- */
-export declare function getWorkspaceBlockCoreDoctorChecks(workspace: WorkspaceProject, block: WorkspaceInventory["blocks"][number]): DoctorCheck[];
+export * from "./doctor/cli-doctor-workspace-block-metadata.js";

package/dist/runtime/cli-doctor-workspace-block-metadata.js

@@ -1,111 +1 @@
-import fs from "node:fs";
-import path from "node:path";
-import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
-import { checkExistingFiles, createDoctorCheck, WORKSPACE_GENERATED_BLOCK_ARTIFACTS, } from "./cli-doctor-workspace-shared.js";
-import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_SET, } from "./hooked-blocks.js";
-import { readJsonFileSync } from "./json-utils.js";
-const WORKSPACE_COLLECTION_IMPORT_LINE = "import '../../collection';";
-const WORKSPACE_COLLECTION_IMPORT_PATTERN = /^\s*import\s+["']\.\.\/\.\.\/collection["']\s*;?\s*$/m;
-function getWorkspaceBlockRequiredFiles(block) {
-    const blockDir = path.join("src", "blocks", block.slug);
-    return Array.from(new Set([
-        block.typesFile,
-        block.apiTypesFile,
-        block.openApiFile,
-        path.join(blockDir, "index.tsx"),
-        ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path.join(blockDir, fileName)),
-    ].filter((filePath) => typeof filePath === "string")));
-}
-function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
-    const blockJsonRelativePath = path.join("src", "blocks", block.slug, "block.json");
-    const blockJsonPath = path.join(projectDir, blockJsonRelativePath);
-    if (!fs.existsSync(blockJsonPath)) {
-        return createDoctorCheck(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
-    }
-    let blockJson;
-    try {
-        blockJson = parseScaffoldBlockMetadata(readJsonFileSync(blockJsonPath, {
-            context: "workspace block metadata",
-        }));
-    }
-    catch (error) {
-        return createDoctorCheck(`Block metadata ${block.slug}`, "fail", error instanceof Error ? error.message : String(error));
-    }
-    const expectedName = `${workspace.workspace.namespace}/${block.slug}`;
-    const issues = [];
-    if (blockJson.name !== expectedName) {
-        issues.push(`block.json name must equal "${expectedName}"`);
-    }
-    if (blockJson.textdomain !== workspace.workspace.textDomain) {
-        issues.push(`block.json textdomain must equal "${workspace.workspace.textDomain}"`);
-    }
-    return createDoctorCheck(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0
-        ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}`
-        : issues.join("; "));
-}
-function checkWorkspaceBlockHooks(projectDir, blockSlug) {
-    const blockJsonRelativePath = path.join("src", "blocks", blockSlug, "block.json");
-    const blockJsonPath = path.join(projectDir, blockJsonRelativePath);
-    if (!fs.existsSync(blockJsonPath)) {
-        return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
-    }
-    let blockJson;
-    try {
-        blockJson = parseScaffoldBlockMetadata(readJsonFileSync(blockJsonPath, {
-            context: "workspace block metadata",
-        }));
-    }
-    catch (error) {
-        return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", error instanceof Error ? error.message : String(error));
-    }
-    const blockHooks = blockJson.blockHooks;
-    if (blockHooks === undefined) {
-        return createDoctorCheck(`Block hooks ${blockSlug}`, "pass", "No blockHooks metadata configured");
-    }
-    if (!blockHooks || typeof blockHooks !== "object" || Array.isArray(blockHooks)) {
-        return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", `${blockJsonRelativePath} must define blockHooks as an object when present.`);
-    }
-    const blockName = typeof blockJson.name === "string" && blockJson.name.trim().length > 0
-        ? blockJson.name.trim()
-        : null;
-    const invalidEntries = Object.entries(blockHooks).filter(([anchor, position]) => (blockName !== null && anchor.trim() === blockName) ||
-        anchor.trim().length === 0 ||
-        anchor !== anchor.trim() ||
-        !HOOKED_BLOCK_ANCHOR_PATTERN.test(anchor) ||
-        typeof position !== "string" ||
-        !HOOKED_BLOCK_POSITION_SET.has(position));
-    return createDoctorCheck(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0
-        ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0
-            ? ` (${Object.keys(blockHooks).join(", ")})`
-            : ""}`
-        : `Invalid blockHooks entries: ${invalidEntries
-            .map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`)
-            .join(", ")}`);
-}
-function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
-    const entryRelativePath = path.join("src", "blocks", blockSlug, "index.tsx");
-    const entryPath = path.join(projectDir, entryRelativePath);
-    if (!fs.existsSync(entryPath)) {
-        return createDoctorCheck(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
-    }
-    const source = fs.readFileSync(entryPath, "utf8");
-    const hasCollectionImport = WORKSPACE_COLLECTION_IMPORT_PATTERN.test(source);
-    return createDoctorCheck(`Block collection ${blockSlug}`, hasCollectionImport ? "pass" : "fail", hasCollectionImport
-        ? "Shared block collection import is present"
-        : `Missing a shared collection import like ${WORKSPACE_COLLECTION_IMPORT_LINE}`);
-}
-/**
- * Collect base file, metadata, hook, and collection-import checks for one block.
- *
- * @param workspace Resolved workspace metadata and filesystem paths.
- * @param block Inventory row describing the generated block.
- * @returns Ordered block core doctor checks.
- */
-export function getWorkspaceBlockCoreDoctorChecks(workspace, block) {
-    return [
-        checkExistingFiles(workspace.projectDir, `Block ${block.slug}`, getWorkspaceBlockRequiredFiles(block)),
-        checkWorkspaceBlockMetadata(workspace.projectDir, workspace, block),
-        checkWorkspaceBlockHooks(workspace.projectDir, block.slug),
-        checkWorkspaceBlockCollectionImport(workspace.projectDir, block.slug),
-    ];
-}
+export * from "./doctor/cli-doctor-workspace-block-metadata.js";

package/dist/runtime/cli-doctor-workspace-blocks.d.ts

@@ -1,11 +1 @@
-import type { DoctorCheck } from "./cli-doctor.js";
-import type { WorkspaceInventory } from "./workspace-inventory.js";
-import type { WorkspaceProject } from "./workspace-project.js";
-/**
- * Collect block-, variation-, transform-, and pattern-related workspace doctor checks.
- *
- * @param workspace Resolved workspace metadata and filesystem paths.
- * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
- * @returns Ordered `DoctorCheck[]` rows for extracted block diagnostics.
- */
-export declare function getWorkspaceBlockDoctorChecks(workspace: WorkspaceProject, inventory: WorkspaceInventory): DoctorCheck[];
+export * from "./doctor/cli-doctor-workspace-blocks.js";

package/dist/runtime/cli-doctor-workspace-blocks.js

@@ -1,20 +1 @@
-import { getWorkspaceBlockAddonDoctorChecks, } from "./cli-doctor-workspace-block-addons.js";
-import { getWorkspaceBlockIframeCompatibilityChecks, } from "./cli-doctor-workspace-block-iframe.js";
-import { getWorkspaceBlockCoreDoctorChecks, } from "./cli-doctor-workspace-block-metadata.js";
-/**
- * Collect block-, variation-, transform-, and pattern-related workspace doctor checks.
- *
- * @param workspace Resolved workspace metadata and filesystem paths.
- * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
- * @returns Ordered `DoctorCheck[]` rows for extracted block diagnostics.
- */
-export function getWorkspaceBlockDoctorChecks(workspace, inventory) {
-    const checks = [];
-    for (const block of inventory.blocks) {
-        checks.push(...getWorkspaceBlockCoreDoctorChecks(workspace, block));
-        checks.push(...getWorkspaceBlockIframeCompatibilityChecks(workspace.projectDir, block.slug));
-    }
-    const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
-    checks.push(...getWorkspaceBlockAddonDoctorChecks(workspace, inventory, registeredBlockSlugs));
-    return checks;
-}
+export * from "./doctor/cli-doctor-workspace-blocks.js";

package/dist/runtime/cli-doctor-workspace-features-abilities.d.ts

@@ -1,11 +1 @@
-import type { DoctorCheck } from "./cli-doctor.js";
-import type { WorkspaceInventory } from "./workspace-inventory.js";
-import type { WorkspaceProject } from "./workspace-project.js";
-/**
- * Collect ability workspace doctor checks while preserving existing row order.
- *
- * @param workspace Resolved workspace metadata and filesystem paths.
- * @param abilities Ability entries parsed from the workspace inventory.
- * @returns Ordered ability doctor checks.
- */
-export declare function getWorkspaceAbilityDoctorChecks(workspace: WorkspaceProject, abilities: WorkspaceInventory["abilities"]): DoctorCheck[];
+export * from "./doctor/cli-doctor-workspace-features-abilities.js";

package/dist/runtime/cli-doctor-workspace-features-abilities.js

@@ -1,112 +1 @@
-import fs from "node:fs";
-import path from "node:path";
-import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_ABILITY_EDITOR_ASSET, WORKSPACE_ABILITY_EDITOR_SCRIPT, WORKSPACE_ABILITY_GLOB, } from "./cli-doctor-workspace-shared.js";
-import { readJsonFileSync } from "./json-utils.js";
-import { escapeRegex } from "./php-utils.js";
-function getWorkspaceAbilityRequiredFiles(ability) {
-    return Array.from(new Set([
-        ability.clientFile,
-        ability.configFile,
-        ability.dataFile,
-        ability.inputSchemaFile,
-        ability.outputSchemaFile,
-        ability.phpFile,
-        ability.typesFile,
-    ]));
-}
-function checkWorkspaceAbilityConfig(projectDir, ability) {
-    const configPath = path.join(projectDir, ability.configFile);
-    if (!fs.existsSync(configPath)) {
-        return createDoctorCheck(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
-    }
-    try {
-        const config = readJsonFileSync(configPath, {
-            context: "workspace ability config",
-        });
-        const abilityId = typeof config.abilityId === "string" ? config.abilityId.trim() : "";
-        const categorySlug = typeof config.category?.slug === "string"
-            ? config.category.slug.trim()
-            : "";
-        const hasValidAbilityId = /^[a-z0-9-]+\/[a-z0-9-]+$/u.test(abilityId);
-        const hasValidCategorySlug = /^[a-z0-9-]+$/u.test(categorySlug);
-        return createDoctorCheck(`Ability config ${ability.slug}`, hasValidAbilityId && hasValidCategorySlug ? "pass" : "fail", hasValidAbilityId && hasValidCategorySlug
-            ? `Ability id ${abilityId} in category ${categorySlug} is valid`
-            : "Ability config must define a valid abilityId (`namespace/ability-name`) and category.slug.");
-    }
-    catch (error) {
-        return createDoctorCheck(`Ability config ${ability.slug}`, "fail", error instanceof Error ? error.message : String(error));
-    }
-}
-function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
-    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-    if (!fs.existsSync(bootstrapPath)) {
-        return createDoctorCheck("Ability bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
-    }
-    const source = fs.readFileSync(bootstrapPath, "utf8");
-    const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
-    const enqueueFunctionName = `${phpPrefix}_enqueue_workflow_abilities`;
-    const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
-    const adminEnqueueHook = `add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );`;
-    const editorEnqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
-    const hasLoaderHook = source.includes(loadHook);
-    const hasAdminEnqueueHook = source.includes(adminEnqueueHook);
-    const hasEditorEnqueueHook = source.includes(editorEnqueueHook);
-    const hasServerGlob = source.includes(WORKSPACE_ABILITY_GLOB);
-    const hasEditorScript = source.includes(WORKSPACE_ABILITY_EDITOR_SCRIPT);
-    const hasEditorAsset = source.includes(WORKSPACE_ABILITY_EDITOR_ASSET);
-    const hasScriptModuleEnqueue = source.includes("wp_enqueue_script_module");
-    return createDoctorCheck("Ability bootstrap", hasLoaderHook &&
-        hasAdminEnqueueHook &&
-        hasEditorEnqueueHook &&
-        hasServerGlob &&
-        hasEditorScript &&
-        hasEditorAsset &&
-        hasScriptModuleEnqueue
-        ? "pass"
-        : "fail", hasLoaderHook &&
-        hasAdminEnqueueHook &&
-        hasEditorEnqueueHook &&
-        hasServerGlob &&
-        hasEditorScript &&
-        hasEditorAsset &&
-        hasScriptModuleEnqueue
-        ? "Ability loader and admin/editor script-module bootstrap hooks are present"
-        : "Missing ability loader hook, script-module enqueue, or build/abilities asset references");
-}
-function checkWorkspaceAbilityIndex(projectDir, abilities) {
-    const indexRelativePath = [
-        path.join("src", "abilities", "index.ts"),
-        path.join("src", "abilities", "index.js"),
-    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
-    if (!indexRelativePath) {
-        return createDoctorCheck("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
-    }
-    const indexPath = path.join(projectDir, indexRelativePath);
-    const source = fs.readFileSync(indexPath, "utf8");
-    const missingExports = abilities.filter((ability) => {
-        const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex(ability.slug)}\\/client['"\`]`, "mu");
-        return !exportPattern.test(source);
-    });
-    return createDoctorCheck("Abilities index", missingExports.length === 0 ? "pass" : "fail", missingExports.length === 0
-        ? "Ability client helpers are aggregated"
-        : `Missing ability exports for: ${missingExports.map((entry) => entry.slug).join(", ")}`);
-}
-/**
- * Collect ability workspace doctor checks while preserving existing row order.
- *
- * @param workspace Resolved workspace metadata and filesystem paths.
- * @param abilities Ability entries parsed from the workspace inventory.
- * @returns Ordered ability doctor checks.
- */
-export function getWorkspaceAbilityDoctorChecks(workspace, abilities) {
-    const checks = [];
-    if (abilities.length > 0) {
-        checks.push(checkWorkspaceAbilityBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-        checks.push(checkWorkspaceAbilityIndex(workspace.projectDir, abilities));
-    }
-    for (const ability of abilities) {
-        checks.push(checkWorkspaceAbilityConfig(workspace.projectDir, ability));
-        checks.push(checkExistingFiles(workspace.projectDir, `Ability ${ability.slug}`, getWorkspaceAbilityRequiredFiles(ability)));
-    }
-    return checks;
-}
+export * from "./doctor/cli-doctor-workspace-features-abilities.js";

package/dist/runtime/cli-doctor-workspace-features-admin-views.d.ts

@@ -1,11 +1 @@
-import type { DoctorCheck } from "./cli-doctor.js";
-import type { WorkspaceInventory } from "./workspace-inventory.js";
-import type { WorkspaceProject } from "./workspace-project.js";
-/**
- * Collect admin view workspace doctor checks while preserving existing row order.
- *
- * @param workspace Resolved workspace metadata and filesystem paths.
- * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
- * @returns Ordered admin view doctor checks.
- */
-export declare function getWorkspaceAdminViewDoctorChecks(workspace: WorkspaceProject, inventory: WorkspaceInventory): DoctorCheck[];
+export * from "./doctor/cli-doctor-workspace-features-admin-views.js";