@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/add/cli-add-workspace-core-variation.js

@@ -0,0 +1,429 @@
+import fs, { promises as fsp } from "node:fs";
+import path from "node:path";
+import { assertFullBlockName } from "./block-targets.js";
+import { assertValidGeneratedSlug, normalizeBlockSlug, quoteTsString, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { ensureEditorPluginBootstrapAnchors, ensureEditorPluginBuildScriptAnchors, ensureEditorPluginWebpackAnchors, resolveEditorPluginRegistryPath, writeEditorPluginRegistry, } from "./cli-add-workspace-editor-plugin.js";
+import { pathExists } from "../shared/fs-async.js";
+import { toKebabCase, toPascalCase, toTitleCase } from "../shared/string-case.js";
+import { resolveWorkspaceProject } from "../workspace/workspace-project.js";
+const CORE_VARIATIONS_EDITOR_PLUGIN_SLUG = "core-variations";
+const CORE_VARIATION_USAGE = "wp-typia add core-variation <block-name> <name> or wp-typia add core-variation <name> --block <namespace/block>";
+const KNOWN_CORE_VARIATION_TARGETS = new Set([
+    "core/archives",
+    "core/audio",
+    "core/avatar",
+    "core/block",
+    "core/button",
+    "core/buttons",
+    "core/calendar",
+    "core/categories",
+    "core/code",
+    "core/column",
+    "core/columns",
+    "core/comment-author-name",
+    "core/comment-content",
+    "core/comment-date",
+    "core/comment-edit-link",
+    "core/comment-reply-link",
+    "core/comment-template",
+    "core/comments",
+    "core/comments-pagination",
+    "core/comments-pagination-next",
+    "core/comments-pagination-numbers",
+    "core/comments-pagination-previous",
+    "core/comments-title",
+    "core/cover",
+    "core/details",
+    "core/embed",
+    "core/file",
+    "core/footnotes",
+    "core/freeform",
+    "core/gallery",
+    "core/group",
+    "core/heading",
+    "core/home-link",
+    "core/html",
+    "core/image",
+    "core/latest-comments",
+    "core/latest-posts",
+    "core/legacy-widget",
+    "core/list",
+    "core/list-item",
+    "core/loginout",
+    "core/media-text",
+    "core/missing",
+    "core/more",
+    "core/navigation",
+    "core/navigation-link",
+    "core/navigation-submenu",
+    "core/nextpage",
+    "core/page-list",
+    "core/paragraph",
+    "core/pattern",
+    "core/post-author",
+    "core/post-author-biography",
+    "core/post-author-name",
+    "core/post-comments",
+    "core/post-comments-form",
+    "core/post-content",
+    "core/post-date",
+    "core/post-excerpt",
+    "core/post-featured-image",
+    "core/post-navigation-link",
+    "core/post-terms",
+    "core/post-template",
+    "core/post-title",
+    "core/preformatted",
+    "core/pullquote",
+    "core/query",
+    "core/query-no-results",
+    "core/query-pagination",
+    "core/query-pagination-next",
+    "core/query-pagination-numbers",
+    "core/query-pagination-previous",
+    "core/query-title",
+    "core/quote",
+    "core/read-more",
+    "core/rss",
+    "core/search",
+    "core/separator",
+    "core/shortcode",
+    "core/site-logo",
+    "core/site-tagline",
+    "core/site-title",
+    "core/social-link",
+    "core/social-links",
+    "core/spacer",
+    "core/table",
+    "core/table-of-contents",
+    "core/tag-cloud",
+    "core/template-part",
+    "core/term-description",
+    "core/text-columns",
+    "core/verse",
+    "core/video",
+]);
+const CORE_VARIATION_SIMPLE_CONTAINER_BLOCKS = new Set([
+    "core/column",
+    "core/cover",
+    "core/group",
+    "core/media-text",
+]);
+function getCoreVariationRootDir(projectDir) {
+    return path.join(projectDir, "src", "editor-plugins", CORE_VARIATIONS_EDITOR_PLUGIN_SLUG);
+}
+function getCoreVariationBlockDir(projectDir, targetBlockName) {
+    const [namespace, blockSlug] = targetBlockName.split("/");
+    return path.join(getCoreVariationRootDir(projectDir), namespace ?? "", blockSlug ?? "");
+}
+function getCoreVariationFilePath(projectDir, targetBlockName, variationSlug) {
+    return path.join(getCoreVariationBlockDir(projectDir, targetBlockName), `${variationSlug}.ts`);
+}
+function getCoreVariationIndexPath(projectDir) {
+    return path.join(getCoreVariationRootDir(projectDir), "index.ts");
+}
+function buildCoreVariationIdentifier(targetBlockName, variationSlug) {
+    return toKebabCase(`${targetBlockName}-${variationSlug}`)
+        .split("-")
+        .filter(Boolean)
+        .join("_");
+}
+function buildCoreVariationConstName(targetBlockName, variationSlug) {
+    return `coreVariation_${buildCoreVariationIdentifier(targetBlockName, variationSlug)}`;
+}
+function buildCoreVariationBlockConstName(targetBlockName, variationSlug) {
+    return `${buildCoreVariationIdentifier(targetBlockName, variationSlug).toUpperCase()}_BLOCK_NAME`;
+}
+function buildCoreVariationAttributesTypeName(targetBlockName, variationSlug) {
+    return `${toPascalCase(`${targetBlockName}-${variationSlug}`)}Attributes`;
+}
+function buildCoreVariationAttributesConstName(targetBlockName, variationSlug) {
+    return `${buildCoreVariationIdentifier(targetBlockName, variationSlug)}Attributes`;
+}
+function buildCoreVariationInnerBlocksConstName(targetBlockName, variationSlug) {
+    return `${buildCoreVariationIdentifier(targetBlockName, variationSlug)}InnerBlocks`;
+}
+function buildCoreVariationImportPath(ref) {
+    return `./${ref.targetBlockName}/${ref.variationSlug}`;
+}
+function formatCoreVariationTitle(variationSlug) {
+    return toTitleCase(variationSlug);
+}
+function getUnknownCoreVariationTargetWarning(targetBlockName) {
+    if (!targetBlockName.startsWith("core/") ||
+        KNOWN_CORE_VARIATION_TARGETS.has(targetBlockName)) {
+        return undefined;
+    }
+    return `Target block "${targetBlockName}" uses the WordPress core namespace but is not in wp-typia's known core block list. The variation was generated for forward compatibility; verify the block name or update wp-typia if this is a newer core block.`;
+}
+function assertCoreVariationDoesNotExist(projectDir, targetBlockName, variationSlug) {
+    const variationFilePath = getCoreVariationFilePath(projectDir, targetBlockName, variationSlug);
+    if (fs.existsSync(variationFilePath)) {
+        throw new Error(`A core block variation already exists at ${path.relative(projectDir, variationFilePath)}. Choose a different name.`);
+    }
+}
+function assertCoreVariationSlugIsNotRegistryIndex(variationSlug) {
+    if (variationSlug === "index") {
+        throw new Error("Core variation name must not normalize to `index`. Choose a different name so the variation module can be registered.");
+    }
+}
+function buildCoreVariationInnerBlocksSource(options) {
+    if (options.targetBlockName === "core/columns") {
+        return `export const ${options.constName} = [
+\t[
+\t\t'core/column',
+\t\t{},
+\t\t[
+\t\t\t[
+\t\t\t\t'core/heading',
+\t\t\t\t{
+\t\t\t\t\tlevel: 2,
+\t\t\t\t\tplaceholder: __( ${quoteTsString("Add a section heading")}, ${quoteTsString(options.textDomain)} ),
+\t\t\t\t},
+\t\t\t],
+\t\t\t[
+\t\t\t\t'core/paragraph',
+\t\t\t\t{
+\t\t\t\t\tplaceholder: __( ${quoteTsString("Add supporting copy")}, ${quoteTsString(options.textDomain)} ),
+\t\t\t\t},
+\t\t\t],
+\t\t],
+\t],
+] satisfies BlockTemplate;`;
+    }
+    if (CORE_VARIATION_SIMPLE_CONTAINER_BLOCKS.has(options.targetBlockName)) {
+        return `export const ${options.constName} = [
+\t[
+\t\t'core/heading',
+\t\t{
+\t\t\tlevel: 2,
+\t\t\tplaceholder: __( ${quoteTsString("Add a section heading")}, ${quoteTsString(options.textDomain)} ),
+\t\t},
+\t],
+\t[
+\t\t'core/paragraph',
+\t\t{
+\t\t\tplaceholder: __( ${quoteTsString("Add supporting copy")}, ${quoteTsString(options.textDomain)} ),
+\t\t},
+\t],
+] satisfies BlockTemplate;`;
+    }
+    return `// Non-container core blocks can keep this empty or replace it with a
+// block-supported InnerBlocks template when the target block accepts children.
+export const ${options.constName} = [] satisfies BlockTemplate;`;
+}
+function buildCoreVariationSource(options) {
+    const attributesTypeName = buildCoreVariationAttributesTypeName(options.targetBlockName, options.variationSlug);
+    const blockConstName = buildCoreVariationBlockConstName(options.targetBlockName, options.variationSlug);
+    const attributesConstName = buildCoreVariationAttributesConstName(options.targetBlockName, options.variationSlug);
+    const innerBlocksConstName = buildCoreVariationInnerBlocksConstName(options.targetBlockName, options.variationSlug);
+    const variationConstName = buildCoreVariationConstName(options.targetBlockName, options.variationSlug);
+    const variationTitle = formatCoreVariationTitle(options.variationSlug);
+    const variationClassName = `is-${options.variationSlug}`;
+    return `import type {
+\tBlockTemplate,
+\tBlockVariation,
+} from '@wp-typia/block-types/blocks/registration';
+import { __ } from '@wordpress/i18n';
+
+export const ${blockConstName} = ${quoteTsString(options.targetBlockName)};
+
+export interface ${attributesTypeName} {
+\tclassName?: string;
+\tmetadata?: {
+\t\tname?: string;
+\t};
+\t[key: string]: unknown;
+}
+
+export const ${attributesConstName} = {
+\tclassName: ${quoteTsString(variationClassName)},
+\tmetadata: {
+\t\tname: ${quoteTsString(variationTitle)},
+\t},
+} satisfies ${attributesTypeName};
+
+${buildCoreVariationInnerBlocksSource({
+        constName: innerBlocksConstName,
+        targetBlockName: options.targetBlockName,
+        textDomain: options.textDomain,
+    })}
+
+export const ${variationConstName} = {
+\tname: ${quoteTsString(options.variationSlug)},
+\ttitle: __( ${quoteTsString(variationTitle)}, ${quoteTsString(options.textDomain)} ),
+\tdescription: __(
+\t\t${quoteTsString(`A starter ${options.targetBlockName} variation for ${variationTitle}.`)},
+\t\t${quoteTsString(options.textDomain)},
+\t),
+\tcategory: 'design',
+\ticon: 'layout',
+\tkeywords: [
+\t\t__( ${quoteTsString("variation")}, ${quoteTsString(options.textDomain)} ),
+\t\t__( ${quoteTsString(variationTitle)}, ${quoteTsString(options.textDomain)} ),
+\t],
+\tattributes: ${attributesConstName},
+\tinnerBlocks: ${innerBlocksConstName},
+\tisActive: ['className'],
+\tscope: ['block', 'inserter', 'transform'],
+} satisfies BlockVariation<${attributesTypeName}>;
+`;
+}
+async function readCoreVariationModuleRefs(coreVariationsDir) {
+    if (!(await pathExists(coreVariationsDir))) {
+        return [];
+    }
+    const refs = [];
+    const namespaceEntries = await fsp.readdir(coreVariationsDir, {
+        withFileTypes: true,
+    });
+    for (const namespaceEntry of namespaceEntries) {
+        if (!namespaceEntry.isDirectory()) {
+            continue;
+        }
+        const namespaceDir = path.join(coreVariationsDir, namespaceEntry.name);
+        const blockEntries = await fsp.readdir(namespaceDir, {
+            withFileTypes: true,
+        });
+        for (const blockEntry of blockEntries) {
+            if (!blockEntry.isDirectory()) {
+                continue;
+            }
+            const blockDir = path.join(namespaceDir, blockEntry.name);
+            const variationEntries = await fsp.readdir(blockDir, {
+                withFileTypes: true,
+            });
+            for (const variationEntry of variationEntries) {
+                if (!variationEntry.isFile() || !variationEntry.name.endsWith(".ts")) {
+                    continue;
+                }
+                const variationSlug = variationEntry.name.replace(/\.ts$/u, "");
+                if (variationSlug === "index") {
+                    continue;
+                }
+                refs.push({
+                    targetBlockName: `${namespaceEntry.name}/${blockEntry.name}`,
+                    variationSlug,
+                });
+            }
+        }
+    }
+    return refs.sort((left, right) => {
+        const leftKey = `${left.targetBlockName}/${left.variationSlug}`;
+        const rightKey = `${right.targetBlockName}/${right.variationSlug}`;
+        return leftKey.localeCompare(rightKey);
+    });
+}
+function buildCoreVariationIndexSource(refs) {
+    const importLines = refs
+        .map((ref, index) => {
+        const blockConstName = buildCoreVariationBlockConstName(ref.targetBlockName, ref.variationSlug);
+        const variationConstName = buildCoreVariationConstName(ref.targetBlockName, ref.variationSlug);
+        return `import { ${blockConstName} as CORE_VARIATION_BLOCK_${index}, ${variationConstName} as coreVariationEntry${index} } from '${buildCoreVariationImportPath(ref)}';`;
+    })
+        .join("\n");
+    const entryLines = refs
+        .map((_, index) => {
+        return `\t{ blockName: CORE_VARIATION_BLOCK_${index}, variation: coreVariationEntry${index} },`;
+    })
+        .join("\n");
+    return `import { registerBlockVariation } from '@wordpress/blocks';
+${importLines ? `\n${importLines}\n` : ""}
+const WORKSPACE_CORE_VARIATIONS = [
+${entryLines}
+] as const;
+
+export function registerWorkspaceCoreVariations() {
+\tfor (const { blockName, variation } of WORKSPACE_CORE_VARIATIONS) {
+\t\tregisterBlockVariation(blockName, variation);
+\t}
+}
+
+registerWorkspaceCoreVariations();
+`;
+}
+async function writeCoreVariationRegistry(projectDir, targetBlockName, textDomain, variationSlug) {
+    const coreVariationsDir = getCoreVariationRootDir(projectDir);
+    const targetBlockDir = getCoreVariationBlockDir(projectDir, targetBlockName);
+    const variationFilePath = getCoreVariationFilePath(projectDir, targetBlockName, variationSlug);
+    await fsp.mkdir(targetBlockDir, { recursive: true });
+    await fsp.writeFile(variationFilePath, buildCoreVariationSource({
+        targetBlockName,
+        textDomain,
+        variationSlug,
+    }), "utf8");
+    const refs = await readCoreVariationModuleRefs(coreVariationsDir);
+    await fsp.writeFile(getCoreVariationIndexPath(projectDir), buildCoreVariationIndexSource(refs), "utf8");
+}
+/**
+ * Add one editor-side variation registration for an existing core or external block.
+ *
+ * @param options Command options for the core-variation scaffold workflow.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.targetBlockName Full `namespace/block` name that receives the variation.
+ * @param options.variationName Human-entered variation name normalized into the generated slug.
+ * @returns The normalized variation metadata, owning workspace directory, and
+ * optional warnings for suspicious but forward-compatible targets.
+ * @throws {Error} When the command is run outside an official workspace, the
+ * target block name is not full `namespace/block` form, or the generated file
+ * already exists.
+ */
+export async function runAddCoreVariationCommand({ cwd = process.cwd(), targetBlockName, targetBlockNameDiagnostics = "core-variation target", variationName, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const resolvedTargetBlockName = assertFullBlockName(targetBlockName, targetBlockNameDiagnostics);
+    const variationSlug = assertValidGeneratedSlug("Core variation name", normalizeBlockSlug(variationName), CORE_VARIATION_USAGE);
+    const unknownCoreTargetWarning = getUnknownCoreVariationTargetWarning(resolvedTargetBlockName);
+    assertCoreVariationSlugIsNotRegistryIndex(variationSlug);
+    assertCoreVariationDoesNotExist(workspace.projectDir, resolvedTargetBlockName, variationSlug);
+    const bootstrapPath = path.join(workspace.projectDir, `${workspace.packageName.split("/").pop() ?? workspace.packageName}.php`);
+    const buildScriptPath = path.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+    const webpackConfigPath = path.join(workspace.projectDir, "webpack.config.js");
+    const editorPluginsIndexPath = await resolveEditorPluginRegistryPath(workspace.projectDir);
+    const coreVariationsDir = getCoreVariationRootDir(workspace.projectDir);
+    const targetNamespaceDir = path.join(coreVariationsDir, resolvedTargetBlockName.split("/")[0] ?? "");
+    const targetBlockDir = getCoreVariationBlockDir(workspace.projectDir, resolvedTargetBlockName);
+    const variationFilePath = getCoreVariationFilePath(workspace.projectDir, resolvedTargetBlockName, variationSlug);
+    const coreVariationsIndexPath = getCoreVariationIndexPath(workspace.projectDir);
+    const shouldRemoveCoreVariationsDir = !(await pathExists(coreVariationsDir));
+    const shouldRemoveTargetNamespaceDir = !shouldRemoveCoreVariationsDir && !(await pathExists(targetNamespaceDir));
+    const shouldRemoveTargetBlockDir = !shouldRemoveCoreVariationsDir &&
+        !shouldRemoveTargetNamespaceDir &&
+        !(await pathExists(targetBlockDir));
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles([
+            bootstrapPath,
+            buildScriptPath,
+            editorPluginsIndexPath,
+            webpackConfigPath,
+            coreVariationsIndexPath,
+        ]),
+        snapshotDirs: [],
+        targetPaths: [
+            variationFilePath,
+            ...(shouldRemoveCoreVariationsDir ? [coreVariationsDir] : []),
+            ...(shouldRemoveTargetNamespaceDir ? [targetNamespaceDir] : []),
+            ...(shouldRemoveTargetBlockDir ? [targetBlockDir] : []),
+        ],
+    };
+    try {
+        await ensureEditorPluginBootstrapAnchors(workspace);
+        await ensureEditorPluginBuildScriptAnchors(workspace);
+        await ensureEditorPluginWebpackAnchors(workspace);
+        await writeCoreVariationRegistry(workspace.projectDir, resolvedTargetBlockName, workspace.workspace.textDomain, variationSlug);
+        await writeEditorPluginRegistry(workspace.projectDir, CORE_VARIATIONS_EDITOR_PLUGIN_SLUG);
+        return {
+            projectDir: workspace.projectDir,
+            targetBlockName: resolvedTargetBlockName,
+            variationFile: path.relative(workspace.projectDir, variationFilePath),
+            variationSlug,
+            ...(unknownCoreTargetWarning
+                ? { warnings: [unknownCoreTargetWarning] }
+                : {}),
+        };
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw error;
+    }
+}

package/dist/runtime/add/cli-add-workspace-editor-plugin-anchors.d.ts

@@ -0,0 +1,37 @@
+import type { WorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Ensures the workspace bootstrap enqueues the shared editor plugin bundle.
+ *
+ * @param workspace Official workspace metadata used to locate and patch the bootstrap file.
+ * @returns A promise that resolves after the bootstrap anchors are present.
+ */
+export declare function ensureEditorPluginBootstrapAnchors(workspace: WorkspaceProject): Promise<void>;
+/**
+ * Ensures the workspace build script includes the shared editor plugin entry.
+ *
+ * @param workspace Official workspace metadata used to locate the build script.
+ * @returns A promise that resolves after the build script anchors are present.
+ */
+export declare function ensureEditorPluginBuildScriptAnchors(workspace: WorkspaceProject): Promise<void>;
+/**
+ * Ensures the workspace webpack config builds the shared editor plugin entry.
+ *
+ * @param workspace Official workspace metadata used to locate the webpack config.
+ * @returns A promise that resolves after the webpack anchors are present.
+ */
+export declare function ensureEditorPluginWebpackAnchors(workspace: WorkspaceProject): Promise<void>;
+/**
+ * Resolves the editor plugin registry path, preferring existing TypeScript or JavaScript registries.
+ *
+ * @param projectDir Workspace root directory to inspect.
+ * @returns A promise for the registry path to read or write.
+ */
+export declare function resolveEditorPluginRegistryPath(projectDir: string): Promise<string>;
+/**
+ * Rewrites the shared editor plugin registry with the requested plugin slug included.
+ *
+ * @param projectDir Workspace root directory that owns `src/editor-plugins`.
+ * @param editorPluginSlug Editor plugin slug that must be imported by the registry.
+ * @returns A promise that resolves after the registry has been written.
+ */
+export declare function writeEditorPluginRegistry(projectDir: string, editorPluginSlug: string): Promise<void>;

package/dist/runtime/add/cli-add-workspace-editor-plugin-anchors.js

@@ -0,0 +1,206 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
+import { appendPhpSnippetBeforeClosingTag, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
+import { pathExists, readOptionalUtf8File } from "../shared/fs-async.js";
+import { findPhpFunctionRange, hasPhpFunctionDefinition, replacePhpFunctionDefinition, } from "../shared/php-utils.js";
+import { readWorkspaceInventoryAsync } from "../workspace/workspace-inventory.js";
+const EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
+const EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
+const EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
+const EDITOR_PLUGIN_EDITOR_STYLE_RTL = "build/editor-plugins/style-index-rtl.css";
+function buildEditorPluginRegistrySource(editorPluginSlugs) {
+    const importLines = editorPluginSlugs
+        .map((editorPluginSlug) => `import './${editorPluginSlug}';`)
+        .join("\n");
+    return `${importLines}${importLines ? "\n\n" : ""}// wp-typia add editor-plugin entries\n`;
+}
+/**
+ * Ensures the workspace bootstrap enqueues the shared editor plugin bundle.
+ *
+ * @param workspace Official workspace metadata used to locate and patch the bootstrap file.
+ * @returns A promise that resolves after the bootstrap anchors are present.
+ */
+export async function ensureEditorPluginBootstrapAnchors(workspace) {
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    await patchFile(bootstrapPath, (source) => {
+        let nextSource = source;
+        const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
+        const enqueueFunctionName = `${workspace.workspace.phpPrefix}_enqueue_editor_plugins_editor`;
+        const enqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
+        const enqueueFunction = `
+
+function ${enqueueFunctionName}() {
+\t$script_path = __DIR__ . '/${EDITOR_PLUGIN_EDITOR_SCRIPT}';
+\t$asset_path  = __DIR__ . '/${EDITOR_PLUGIN_EDITOR_ASSET}';
+\t$style_path  = __DIR__ . '/${EDITOR_PLUGIN_EDITOR_STYLE}';
+\t$style_rtl_path = __DIR__ . '/${EDITOR_PLUGIN_EDITOR_STYLE_RTL}';
+
+\tif ( ! file_exists( $script_path ) || ! file_exists( $asset_path ) ) {
+\t\treturn;
+\t}
+
+\t$asset = require $asset_path;
+\tif ( ! is_array( $asset ) ) {
+\t\t$asset = array();
+\t}
+
+\twp_enqueue_script(
+\t\t'${workspaceBaseName}-editor-plugins',
+\t\tplugins_url( '${EDITOR_PLUGIN_EDITOR_SCRIPT}', __FILE__ ),
+\t\tisset( $asset['dependencies'] ) && is_array( $asset['dependencies'] ) ? $asset['dependencies'] : array(),
+\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
+\t\ttrue
+\t);
+
+\tif ( file_exists( $style_path ) ) {
+\t\twp_enqueue_style(
+\t\t\t'${workspaceBaseName}-editor-plugins',
+\t\t\tplugins_url( '${EDITOR_PLUGIN_EDITOR_STYLE}', __FILE__ ),
+\t\t\tarray(),
+\t\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $style_path )
+\t\t);
+\t\tif ( file_exists( $style_rtl_path ) ) {
+\t\t\twp_style_add_data( '${workspaceBaseName}-editor-plugins', 'rtl', 'replace' );
+\t\t}
+\t}
+}
+`;
+        if (!hasPhpFunctionDefinition(nextSource, enqueueFunctionName)) {
+            nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, enqueueFunction);
+        }
+        else {
+            const requiredReferences = [
+                EDITOR_PLUGIN_EDITOR_SCRIPT,
+                EDITOR_PLUGIN_EDITOR_ASSET,
+                EDITOR_PLUGIN_EDITOR_STYLE,
+                EDITOR_PLUGIN_EDITOR_STYLE_RTL,
+                "wp_style_add_data",
+            ];
+            const functionRange = findPhpFunctionRange(nextSource, enqueueFunctionName);
+            const functionSource = functionRange
+                ? nextSource.slice(functionRange.start, functionRange.end)
+                : "";
+            const missingReferences = requiredReferences.filter((reference) => !functionSource.includes(reference));
+            if (missingReferences.length > 0) {
+                const replacedSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
+                if (!replacedSource) {
+                    throw new Error(`Unable to repair ${path.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
+                }
+                nextSource = replacedSource;
+            }
+        }
+        if (!nextSource.includes(enqueueHook)) {
+            nextSource = appendPhpSnippetBeforeClosingTag(nextSource, enqueueHook);
+        }
+        return nextSource;
+    });
+}
+/**
+ * Ensures the workspace build script includes the shared editor plugin entry.
+ *
+ * @param workspace Official workspace metadata used to locate the build script.
+ * @returns A promise that resolves after the build script anchors are present.
+ */
+export async function ensureEditorPluginBuildScriptAnchors(workspace) {
+    const buildScriptPath = path.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+    await patchFile(buildScriptPath, (source) => {
+        if (/['"]src\/editor-plugins\/index\.(?:ts|js)['"]/u.test(source)) {
+            return source;
+        }
+        const legacySharedEntriesPattern = /\[\s*['"]src\/bindings\/index\.ts['"]\s*,\s*['"]src\/bindings\/index\.js['"]\s*(?:,\s*)?\]/u;
+        const nextSource = source.replace(legacySharedEntriesPattern, `[
+\t\t'src/bindings/index.ts',
+\t\t'src/bindings/index.js',
+\t\t'src/editor-plugins/index.ts',
+\t\t'src/editor-plugins/index.js',
+\t]`);
+        if (nextSource === source) {
+            throw new Error(`Unable to update ${path.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
+        }
+        return nextSource;
+    });
+}
+/**
+ * Ensures the workspace webpack config builds the shared editor plugin entry.
+ *
+ * @param workspace Official workspace metadata used to locate the webpack config.
+ * @returns A promise that resolves after the webpack anchors are present.
+ */
+export async function ensureEditorPluginWebpackAnchors(workspace) {
+    const webpackConfigPath = path.join(workspace.projectDir, "webpack.config.js");
+    await patchFile(webpackConfigPath, (source) => {
+        if (/['"]editor-plugins\/index['"]/u.test(source)) {
+            return source;
+        }
+        const legacySharedEntriesBlockPattern = /for\s*\(\s*const\s+relativePath\s+of\s+\[\s*['"]src\/bindings\/index\.ts['"]\s*,\s*['"]src\/bindings\/index\.js['"]\s*(?:,\s*)?\]\s*\)\s*\{[\s\S]*?entries\.push\(\s*\[\s*['"]bindings\/index['"]\s*,\s*entryPath\s*\]\s*\);\s*break;\s*\}/u;
+        const nextSharedEntriesBlock = [
+            "\tfor ( const [ entryName, candidates ] of [",
+            "\t\t[",
+            "\t\t\t'bindings/index',",
+            "\t\t\t[ 'src/bindings/index.ts', 'src/bindings/index.js' ],",
+            "\t\t],",
+            "\t\t[",
+            "\t\t\t'editor-plugins/index',",
+            "\t\t\t[ 'src/editor-plugins/index.ts', 'src/editor-plugins/index.js' ],",
+            "\t\t],",
+            "\t] ) {",
+            "\t\tfor ( const relativePath of candidates ) {",
+            "\t\t\tconst entryPath = path.resolve( process.cwd(), relativePath );",
+            "\t\t\tif ( ! fs.existsSync( entryPath ) ) {",
+            "\t\t\t\tcontinue;",
+            "\t\t\t}",
+            "",
+            "\t\t\tentries.push( [ entryName, entryPath ] );",
+            "\t\t\tbreak;",
+            "\t\t}",
+            "\t}",
+        ].join("\n");
+        const nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
+        if (nextSource === source) {
+            throw new Error(`Unable to update ${path.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
+        }
+        return nextSource;
+    });
+}
+/**
+ * Resolves the editor plugin registry path, preferring existing TypeScript or JavaScript registries.
+ *
+ * @param projectDir Workspace root directory to inspect.
+ * @returns A promise for the registry path to read or write.
+ */
+export async function resolveEditorPluginRegistryPath(projectDir) {
+    const editorPluginsDir = path.join(projectDir, "src", "editor-plugins");
+    for (const candidatePath of [
+        path.join(editorPluginsDir, "index.ts"),
+        path.join(editorPluginsDir, "index.js"),
+    ]) {
+        if (await pathExists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return path.join(editorPluginsDir, "index.ts");
+}
+async function readEditorPluginRegistrySlugs(registryPath) {
+    const source = await readOptionalUtf8File(registryPath);
+    if (source === null) {
+        return [];
+    }
+    return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match) => match[1]);
+}
+/**
+ * Rewrites the shared editor plugin registry with the requested plugin slug included.
+ *
+ * @param projectDir Workspace root directory that owns `src/editor-plugins`.
+ * @param editorPluginSlug Editor plugin slug that must be imported by the registry.
+ * @returns A promise that resolves after the registry has been written.
+ */
+export async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
+    const editorPluginsDir = path.join(projectDir, "src", "editor-plugins");
+    const registryPath = await resolveEditorPluginRegistryPath(projectDir);
+    await fsp.mkdir(editorPluginsDir, { recursive: true });
+    const existingEditorPluginSlugs = (await readWorkspaceInventoryAsync(projectDir)).editorPlugins.map((entry) => entry.slug);
+    const existingRegistrySlugs = await readEditorPluginRegistrySlugs(registryPath);
+    const nextEditorPluginSlugs = Array.from(new Set([...existingEditorPluginSlugs, ...existingRegistrySlugs, editorPluginSlug])).sort();
+    await fsp.writeFile(registryPath, buildEditorPluginRegistrySource(nextEditorPluginSlugs), "utf8");
+}