@wp-typia/project-tools 0.20.1 → 0.21.0

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

@@ -3,10 +3,178 @@ import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { appendWorkspaceInventoryEntries, readWorkspaceInventory } from "./workspace-inventory.js";
-import { toKebabCase, toTitleCase } from "./string-case.js";
+import { toKebabCase, toSnakeCase, toTitleCase } from "./string-case.js";
 import { assertValidGeneratedSlug, assertValidHookAnchor, assertValidHookedBlockPosition, assertVariationDoesNotExist, getMutableBlockHooks, normalizeBlockSlug, patchFile, quoteTsString, readWorkspaceBlockJson, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
 const VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
+const VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
 const VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
+const VARIATIONS_CALL_PATTERN = /registerWorkspaceVariations\s*\(\s*\)\s*;?/u;
+const BLOCK_STYLES_IMPORT_LINE = "import { registerWorkspaceBlockStyles } from './styles';";
+const BLOCK_STYLES_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceBlockStyles\s*\}\s*from\s*["']\.\/styles["']\s*;?\s*$/mu;
+const BLOCK_STYLES_CALL_LINE = "registerWorkspaceBlockStyles();";
+const BLOCK_STYLES_CALL_PATTERN = /registerWorkspaceBlockStyles\s*\(\s*\)\s*;?/u;
+const BLOCK_TRANSFORMS_IMPORT_LINE = "import { applyWorkspaceBlockTransforms } from './transforms';";
+const BLOCK_TRANSFORMS_IMPORT_PATTERN = /^\s*import\s*\{\s*applyWorkspaceBlockTransforms\s*\}\s*from\s*["']\.\/transforms["']\s*;?\s*$/mu;
+const BLOCK_TRANSFORMS_CALL_LINE = "applyWorkspaceBlockTransforms(registration.settings);";
+const BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+const SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN = /registerScaffoldBlockType\s*\(\s*registration\s*\.\s*name\s*,\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+const FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+function maskSourceSegment(segment) {
+    return segment.replace(/[^\n\r]/gu, " ");
+}
+function maskTypeScriptComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment)
+        .replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
+}
+// Preserve source offsets so executable-code match indexes still map to the original file.
+function maskTypeScriptCommentsAndLiterals(source) {
+    let maskedSource = "";
+    let index = 0;
+    while (index < source.length) {
+        const current = source[index];
+        const next = source[index + 1];
+        if (current === "/" && next === "/") {
+            const start = index;
+            index += 2;
+            while (index < source.length &&
+                source[index] !== "\n" &&
+                source[index] !== "\r") {
+                index += 1;
+            }
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        if (current === "/" && next === "*") {
+            const start = index;
+            index += 2;
+            while (index < source.length &&
+                !(source[index] === "*" && source[index + 1] === "/")) {
+                index += 1;
+            }
+            index = Math.min(index + 2, source.length);
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        if (current === "'" || current === '"' || current === "`") {
+            const start = index;
+            const quote = current;
+            index += 1;
+            while (index < source.length) {
+                const char = source[index];
+                if (char === "\\") {
+                    index += 2;
+                    continue;
+                }
+                index += 1;
+                if (char === quote) {
+                    break;
+                }
+            }
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        maskedSource += current;
+        index += 1;
+    }
+    return maskedSource;
+}
+function hasExecutablePattern(source, pattern) {
+    return pattern.test(maskTypeScriptCommentsAndLiterals(source));
+}
+function hasUncommentedPattern(source, pattern) {
+    return pattern.test(maskTypeScriptComments(source));
+}
+function findExecutablePatternMatch(source, patterns) {
+    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+    for (const pattern of patterns) {
+        const match = pattern.exec(maskedSource);
+        if (match && match.index !== undefined) {
+            return {
+                end: match.index + match[0].length,
+                start: match.index,
+            };
+        }
+    }
+    return undefined;
+}
+function isIdentifierBoundary(source, index) {
+    if (index < 0 || index >= source.length) {
+        return true;
+    }
+    return !/[A-Za-z0-9_$]/u.test(source[index] ?? "");
+}
+function skipWhitespace(source, index) {
+    let cursor = index;
+    while (cursor < source.length && /\s/u.test(source[cursor] ?? "")) {
+        cursor += 1;
+    }
+    return cursor;
+}
+function findMatchingDelimiterEnd(source, openIndex, openDelimiter, closeDelimiter) {
+    let depth = 0;
+    for (let index = openIndex; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === openDelimiter) {
+            depth += 1;
+            continue;
+        }
+        if (char === closeDelimiter) {
+            depth -= 1;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+    }
+    return undefined;
+}
+function findExecutableCallRange(source, callName) {
+    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+    let searchIndex = 0;
+    while (searchIndex < maskedSource.length) {
+        const callNameIndex = maskedSource.indexOf(callName, searchIndex);
+        if (callNameIndex === -1) {
+            return undefined;
+        }
+        const callNameEnd = callNameIndex + callName.length;
+        if (!isIdentifierBoundary(maskedSource, callNameIndex - 1) ||
+            !isIdentifierBoundary(maskedSource, callNameEnd)) {
+            searchIndex = callNameEnd;
+            continue;
+        }
+        let cursor = skipWhitespace(maskedSource, callNameEnd);
+        if (maskedSource[cursor] === "<") {
+            const genericEnd = findMatchingDelimiterEnd(maskedSource, cursor, "<", ">");
+            if (genericEnd === undefined) {
+                searchIndex = callNameEnd;
+                continue;
+            }
+            cursor = skipWhitespace(maskedSource, genericEnd);
+        }
+        if (maskedSource[cursor] !== "(") {
+            searchIndex = callNameEnd;
+            continue;
+        }
+        const callEnd = findMatchingDelimiterEnd(maskedSource, cursor, "(", ")");
+        if (callEnd === undefined) {
+            searchIndex = callNameEnd;
+            continue;
+        }
+        let end = skipWhitespace(maskedSource, callEnd);
+        if (maskedSource[end] === ";") {
+            end += 1;
+        }
+        return {
+            end,
+            start: callNameIndex,
+        };
+    }
+    return undefined;
+}
+function findBlockRegistrationCallRange(source) {
+    return (findExecutableCallRange(source, "registerScaffoldBlockType") ??
+        findExecutableCallRange(source, "registerBlockType"));
+}
 function buildVariationConfigEntry(blockSlug, variationSlug) {
     return [
         "\t{",
@@ -78,36 +246,215 @@ export function registerWorkspaceVariations() {
 }
 `;
 }
+function buildWorkspaceConstName(prefix, slug) {
+    return `workspace${prefix}_${toSnakeCase(slug)}`;
+}
+function buildBlockStyleConfigEntry(blockSlug, styleSlug) {
+    return [
+        "\t{",
+        `\t\tblock: ${quoteTsString(blockSlug)},`,
+        `\t\tfile: ${quoteTsString(`src/blocks/${blockSlug}/styles/${styleSlug}.ts`)},`,
+        `\t\tslug: ${quoteTsString(styleSlug)},`,
+        "\t},",
+    ].join("\n");
+}
+function buildBlockTransformConfigEntry(options) {
+    return [
+        "\t{",
+        `\t\tblock: ${quoteTsString(options.blockSlug)},`,
+        `\t\tfile: ${quoteTsString(`src/blocks/${options.blockSlug}/transforms/${options.transformSlug}.ts`)},`,
+        `\t\tfrom: ${quoteTsString(options.fromBlockName)},`,
+        `\t\tslug: ${quoteTsString(options.transformSlug)},`,
+        `\t\tto: ${quoteTsString(options.toBlockName)},`,
+        "\t},",
+    ].join("\n");
+}
+function getBlockStyleConstBindings(styleSlugs) {
+    const seenConstNames = new Map();
+    return styleSlugs.map((styleSlug) => {
+        const constName = buildWorkspaceConstName("BlockStyle", styleSlug);
+        const previousSlug = seenConstNames.get(constName);
+        if (previousSlug && previousSlug !== styleSlug) {
+            throw new Error(`Style slugs "${previousSlug}" and "${styleSlug}" generate the same registry identifier "${constName}". Rename one of the styles.`);
+        }
+        seenConstNames.set(constName, styleSlug);
+        return { constName, styleSlug };
+    });
+}
+function getBlockTransformConstBindings(transformSlugs) {
+    const seenConstNames = new Map();
+    return transformSlugs.map((transformSlug) => {
+        const constName = buildWorkspaceConstName("BlockTransform", transformSlug);
+        const previousSlug = seenConstNames.get(constName);
+        if (previousSlug && previousSlug !== transformSlug) {
+            throw new Error(`Transform slugs "${previousSlug}" and "${transformSlug}" generate the same registry identifier "${constName}". Rename one of the transforms.`);
+        }
+        seenConstNames.set(constName, transformSlug);
+        return { constName, transformSlug };
+    });
+}
+function buildBlockStyleSource(styleSlug, textDomain) {
+    const styleTitle = toTitleCase(styleSlug);
+    const styleConstName = buildWorkspaceConstName("BlockStyle", styleSlug);
+    return `import { __ } from '@wordpress/i18n';
+
+export const ${styleConstName} = {
+\tname: ${quoteTsString(styleSlug)},
+\tlabel: __( ${quoteTsString(styleTitle)}, ${quoteTsString(textDomain)} ),
+} as const;
+`;
+}
+function buildBlockStyleIndexSource(styleSlugs) {
+    const styleBindings = getBlockStyleConstBindings(styleSlugs);
+    const importLines = styleBindings
+        .map(({ constName, styleSlug }) => `import { ${constName} } from './${styleSlug}';`)
+        .join("\n");
+    const styleConstNames = styleBindings.map(({ constName }) => constName).join(",\n\t");
+    return `import { registerBlockStyle } from '@wordpress/blocks';
+import metadata from '../block.json';
+${importLines ? `\n${importLines}` : ""}
+
+const WORKSPACE_BLOCK_STYLES = [
+\t${styleConstNames}
+\t// wp-typia add style entries
+] as const;
+
+export function registerWorkspaceBlockStyles() {
+\tfor (const style of WORKSPACE_BLOCK_STYLES) {
+\t\tregisterBlockStyle(metadata.name, style);
+\t}
+}
+`;
+}
+function buildBlockTransformSource(options) {
+    const transformTitle = toTitleCase(options.transformSlug);
+    const transformConstName = buildWorkspaceConstName("BlockTransform", options.transformSlug);
+    return `import { createBlock } from '@wordpress/blocks';
+import { __ } from '@wordpress/i18n';
+import metadata from '../block.json';
+
+type TransformAttributes = Record<string, unknown>;
+type TransformInnerBlock = ReturnType<typeof createBlock>;
+
+function mapTransformAttributes(attributes: TransformAttributes): TransformAttributes {
+\tconst content = attributes.content;
+
+\treturn typeof content === 'string' ? { content } : {};
+}
+
+export const ${transformConstName} = {
+\ttype: 'block',
+\tblocks: [${quoteTsString(options.fromBlockName)}],
+\ttitle: __( ${quoteTsString(transformTitle)}, ${quoteTsString(options.textDomain)} ),
+\ttransform: (
+\t\tattributes: TransformAttributes,
+\t\tinnerBlocks: TransformInnerBlock[] = [],
+\t) => createBlock(metadata.name, mapTransformAttributes(attributes), innerBlocks),
+} as const;
+`;
+}
+function buildBlockTransformIndexSource(transformSlugs) {
+    const transformBindings = getBlockTransformConstBindings(transformSlugs);
+    const importLines = transformBindings
+        .map(({ constName, transformSlug }) => `import { ${constName} } from './${transformSlug}';`)
+        .join("\n");
+    const transformConstNames = transformBindings
+        .map(({ constName }) => constName)
+        .join(",\n\t");
+    return `${importLines ? `${importLines}\n\n` : ""}type BlockSettingsWithTransforms = {
+\ttransforms?: {
+\t\tfrom?: unknown[];
+\t\tto?: unknown[];
+\t};
+};
+
+const WORKSPACE_BLOCK_TRANSFORMS = [
+\t${transformConstNames}
+\t// wp-typia add transform entries
+] as const;
+
+export function applyWorkspaceBlockTransforms(settings: BlockSettingsWithTransforms) {
+\tconst transforms = settings.transforms ?? {};
+
+\tsettings.transforms = {
+\t\t...transforms,
+\t\tfrom: [...(transforms.from ?? []), ...WORKSPACE_BLOCK_TRANSFORMS],
+\t};
+}
+`;
+}
 async function ensureVariationRegistrationHook(blockIndexPath) {
     await patchFile(blockIndexPath, (source) => {
         let nextSource = source;
-        if (!nextSource.includes(VARIATIONS_IMPORT_LINE)) {
+        if (!hasUncommentedPattern(nextSource, VARIATIONS_IMPORT_PATTERN)) {
             nextSource = `${VARIATIONS_IMPORT_LINE}\n${nextSource}`;
         }
-        if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
-            const callInsertionPatterns = [
-                /(registerBlockType<[\s\S]*?\);\s*)/u,
-                /(registerBlockType\([\s\S]*?\);\s*)/u,
-            ];
-            let inserted = false;
-            for (const pattern of callInsertionPatterns) {
-                const candidate = nextSource.replace(pattern, (match) => `${match}\n${VARIATIONS_CALL_LINE}\n`);
-                if (candidate !== nextSource) {
-                    nextSource = candidate;
-                    inserted = true;
-                    break;
-                }
+        if (!hasExecutablePattern(nextSource, VARIATIONS_CALL_PATTERN)) {
+            const callRange = findBlockRegistrationCallRange(nextSource);
+            if (callRange) {
+                nextSource = [
+                    nextSource.slice(0, callRange.end),
+                    `\n${VARIATIONS_CALL_LINE}\n`,
+                    nextSource.slice(callRange.end),
+                ].join("");
             }
-            if (!inserted) {
+            else {
                 nextSource = `${nextSource.trimEnd()}\n\n${VARIATIONS_CALL_LINE}\n`;
             }
         }
-        if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
+        if (!hasExecutablePattern(nextSource, VARIATIONS_CALL_PATTERN)) {
             throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path.basename(blockIndexPath)}.`);
         }
         return nextSource;
     });
 }
+async function ensureBlockStyleRegistrationHook(blockIndexPath) {
+    await patchFile(blockIndexPath, (source) => {
+        let nextSource = source;
+        if (!hasUncommentedPattern(nextSource, BLOCK_STYLES_IMPORT_PATTERN)) {
+            nextSource = `${BLOCK_STYLES_IMPORT_LINE}\n${nextSource}`;
+        }
+        if (!hasExecutablePattern(nextSource, BLOCK_STYLES_CALL_PATTERN)) {
+            const callRange = findBlockRegistrationCallRange(nextSource);
+            if (callRange) {
+                nextSource = [
+                    nextSource.slice(0, callRange.end),
+                    `\n${BLOCK_STYLES_CALL_LINE}\n`,
+                    nextSource.slice(callRange.end),
+                ].join("");
+            }
+            else {
+                nextSource = `${nextSource.trimEnd()}\n\n${BLOCK_STYLES_CALL_LINE}\n`;
+            }
+        }
+        if (!hasExecutablePattern(nextSource, BLOCK_STYLES_CALL_PATTERN)) {
+            throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path.basename(blockIndexPath)}.`);
+        }
+        return nextSource;
+    });
+}
+async function ensureBlockTransformRegistrationHook(blockIndexPath) {
+    await patchFile(blockIndexPath, (source) => {
+        let nextSource = source;
+        if (!hasUncommentedPattern(nextSource, BLOCK_TRANSFORMS_IMPORT_PATTERN)) {
+            nextSource = `${BLOCK_TRANSFORMS_IMPORT_LINE}\n${nextSource}`;
+        }
+        if (!hasExecutablePattern(nextSource, BLOCK_TRANSFORMS_CALL_PATTERN)) {
+            const callRange = findExecutablePatternMatch(nextSource, [
+                SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN,
+            ]);
+            if (!callRange) {
+                throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
+            }
+            nextSource = [
+                nextSource.slice(0, callRange.start),
+                `${BLOCK_TRANSFORMS_CALL_LINE}\n`,
+                nextSource.slice(callRange.start),
+            ].join("");
+        }
+        return nextSource;
+    });
+}
 async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
     const variationsDir = path.join(projectDir, "src", "blocks", blockSlug, "variations");
     const variationsIndexPath = path.join(variationsDir, "index.ts");
@@ -119,6 +466,83 @@ async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
     const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
     await fsp.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
+async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
+    const stylesDir = path.join(projectDir, "src", "blocks", blockSlug, "styles");
+    const stylesIndexPath = path.join(stylesDir, "index.ts");
+    await fsp.mkdir(stylesDir, { recursive: true });
+    const existingStyleSlugs = fs
+        .readdirSync(stylesDir)
+        .filter((entry) => entry.endsWith(".ts") && entry !== "index.ts")
+        .map((entry) => entry.replace(/\.ts$/u, ""));
+    const nextStyleSlugs = Array.from(new Set([...existingStyleSlugs, styleSlug])).sort();
+    await fsp.writeFile(stylesIndexPath, buildBlockStyleIndexSource(nextStyleSlugs), "utf8");
+}
+async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug) {
+    const transformsDir = path.join(projectDir, "src", "blocks", blockSlug, "transforms");
+    const transformsIndexPath = path.join(transformsDir, "index.ts");
+    await fsp.mkdir(transformsDir, { recursive: true });
+    const existingTransformSlugs = fs
+        .readdirSync(transformsDir)
+        .filter((entry) => entry.endsWith(".ts") && entry !== "index.ts")
+        .map((entry) => entry.replace(/\.ts$/u, ""));
+    const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
+    await fsp.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
+}
+function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
+    const stylePath = path.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
+    if (fs.existsSync(stylePath)) {
+        throw new Error(`A block style already exists at ${path.relative(projectDir, stylePath)}. Choose a different name.`);
+    }
+    if (inventory.blockStyles.some((entry) => entry.block === blockSlug && entry.slug === styleSlug)) {
+        throw new Error(`A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`);
+    }
+}
+function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
+    const transformPath = path.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
+    if (fs.existsSync(transformPath)) {
+        throw new Error(`A block transform already exists at ${path.relative(projectDir, transformPath)}. Choose a different name.`);
+    }
+    if (inventory.blockTransforms.some((entry) => entry.block === blockSlug && entry.slug === transformSlug)) {
+        throw new Error(`A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`);
+    }
+}
+function assertFullBlockName(blockName, flagName) {
+    const trimmed = blockName.trim();
+    if (!trimmed) {
+        throw new Error(`\`${flagName}\` requires a block name.`);
+    }
+    if (!FULL_BLOCK_NAME_PATTERN.test(trimmed)) {
+        throw new Error(`\`${flagName}\` must use <namespace/block-slug> format.`);
+    }
+    return trimmed;
+}
+function resolveWorkspaceTargetBlockName(blockName, namespace, flagName) {
+    const trimmed = blockName.trim();
+    if (!trimmed) {
+        throw new Error(`\`${flagName}\` requires <block-slug|namespace/block-slug>.`);
+    }
+    const blockNameSegments = trimmed.split("/");
+    if (blockNameSegments.length > 2 ||
+        blockNameSegments.some((segment) => segment.trim() === "")) {
+        throw new Error(`\`${flagName}\` must use <block-slug|namespace/block-slug> format.`);
+    }
+    const [maybeNamespace, maybeSlug] = blockNameSegments.length === 2
+        ? blockNameSegments
+        : [undefined, blockNameSegments[0]];
+    if (maybeNamespace && maybeNamespace !== namespace) {
+        throw new Error(`\`${flagName}\` references namespace "${maybeNamespace}". Expected "${namespace}".`);
+    }
+    const blockSlug = normalizeBlockSlug(maybeSlug ?? "");
+    return {
+        blockName: `${namespace}/${blockSlug}`,
+        blockSlug,
+    };
+}
+/**
+ * Re-export the DataViews admin screen scaffold workflow from the focused
+ * admin-view runtime helper module.
+ */
+export { runAddAdminViewCommand, } from "./cli-add-workspace-admin-view.js";
 /**
  * Re-export focused workspace asset scaffold commands from the companion
  * `cli-add-workspace-assets` module.
@@ -167,6 +591,7 @@ export async function runAddVariationCommand({ blockName, cwd = process.cwd(), v
     const variationsDir = path.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
     const variationFilePath = path.join(variationsDir, `${variationSlug}.ts`);
     const variationsIndexPath = path.join(variationsDir, "index.ts");
+    const shouldRemoveVariationsDirOnRollback = !fs.existsSync(variationsDir);
     const mutationSnapshot = {
         fileSources: await snapshotWorkspaceFiles([
             blockConfigPath,
@@ -174,7 +599,10 @@ export async function runAddVariationCommand({ blockName, cwd = process.cwd(), v
             variationsIndexPath,
         ]),
         snapshotDirs: [],
-        targetPaths: [variationFilePath],
+        targetPaths: [
+            variationFilePath,
+            ...(shouldRemoveVariationsDirOnRollback ? [variationsDir] : []),
+        ],
     };
     try {
         await fsp.mkdir(variationsDir, { recursive: true });
@@ -195,6 +623,148 @@ export async function runAddVariationCommand({ blockName, cwd = process.cwd(), v
         throw error;
     }
 }
+/**
+ * Add one Block Styles registration to an existing workspace block.
+ *
+ * @param options Command options for the Block Styles scaffold workflow.
+ * @param options.blockName Target workspace block slug that will own the style.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.styleName Human-entered style name that will be normalized and
+ * validated before files are written.
+ * @returns A promise that resolves with the normalized `blockSlug`, `styleSlug`,
+ * and owning `projectDir` after the style module, style registry, entrypoint
+ * hook, and inventory entry have been written successfully.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the target block is unknown, when the style slug is invalid, or when a
+ * conflicting file or inventory entry already exists.
+ */
+export async function runAddBlockStyleCommand({ blockName, cwd = process.cwd(), styleName, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const blockSlug = normalizeBlockSlug(blockName);
+    const styleSlug = assertValidGeneratedSlug("Style name", normalizeBlockSlug(styleName), "wp-typia add style <name> --block <block-slug>");
+    const inventory = readWorkspaceInventory(workspace.projectDir);
+    resolveWorkspaceBlock(inventory, blockSlug);
+    assertBlockStyleDoesNotExist(workspace.projectDir, blockSlug, styleSlug, inventory);
+    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
+    const blockIndexPath = path.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+    const stylesDir = path.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
+    const styleFilePath = path.join(stylesDir, `${styleSlug}.ts`);
+    const stylesIndexPath = path.join(stylesDir, "index.ts");
+    const shouldRemoveStylesDirOnRollback = !fs.existsSync(stylesDir);
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles([
+            blockConfigPath,
+            blockIndexPath,
+            stylesIndexPath,
+        ]),
+        snapshotDirs: [],
+        targetPaths: [
+            styleFilePath,
+            ...(shouldRemoveStylesDirOnRollback ? [stylesDir] : []),
+        ],
+    };
+    try {
+        await fsp.mkdir(stylesDir, { recursive: true });
+        await fsp.writeFile(styleFilePath, buildBlockStyleSource(styleSlug, workspace.workspace.textDomain), "utf8");
+        await writeBlockStyleRegistry(workspace.projectDir, blockSlug, styleSlug);
+        await ensureBlockStyleRegistrationHook(blockIndexPath);
+        await appendWorkspaceInventoryEntries(workspace.projectDir, {
+            blockStyleEntries: [buildBlockStyleConfigEntry(blockSlug, styleSlug)],
+        });
+        return {
+            blockSlug,
+            projectDir: workspace.projectDir,
+            styleSlug,
+        };
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw error;
+    }
+}
+/**
+ * Add one block-to-block transform registration to an existing workspace block.
+ *
+ * @param options Command options for the block transform scaffold workflow.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.fromBlockName Source block name for `--from`. This must be the
+ * full `namespace/block` form because transforms may originate from WordPress
+ * core or third-party blocks outside the workspace.
+ * @param options.toBlockName Target block for `--to`. A workspace block slug is
+ * resolved against the workspace namespace, while a full `namespace/block` name
+ * must still point at an existing workspace block.
+ * @param options.transformName Human-entered transform name that will be
+ * normalized and validated before files are written.
+ * @returns A promise that resolves with the normalized target `blockSlug`,
+ * resolved `fromBlockName`, resolved `toBlockName`, `transformSlug`, and owning
+ * `projectDir` after the transform module, transform registry, entrypoint hook,
+ * and inventory entry have been written successfully.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the target block is unknown, when `--from` is not a full block name, when
+ * `--to` uses a non-workspace namespace, when the target block entrypoint does
+ * not expose `registration.settings`, when the transform slug is invalid, or
+ * when a conflicting file or inventory entry already exists.
+ */
+export async function runAddBlockTransformCommand({ cwd = process.cwd(), fromBlockName, toBlockName, transformName, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const transformSlug = assertValidGeneratedSlug("Transform name", normalizeBlockSlug(transformName), "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>");
+    const resolvedFromBlockName = assertFullBlockName(fromBlockName, "--from");
+    const target = resolveWorkspaceTargetBlockName(toBlockName, workspace.workspace.namespace, "--to");
+    const inventory = readWorkspaceInventory(workspace.projectDir);
+    resolveWorkspaceBlock(inventory, target.blockSlug);
+    assertBlockTransformDoesNotExist(workspace.projectDir, target.blockSlug, transformSlug, inventory);
+    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
+    const blockIndexPath = path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
+    const transformsDir = path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
+    const transformFilePath = path.join(transformsDir, `${transformSlug}.ts`);
+    const transformsIndexPath = path.join(transformsDir, "index.ts");
+    const shouldRemoveTransformsDirOnRollback = !fs.existsSync(transformsDir);
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles([
+            blockConfigPath,
+            blockIndexPath,
+            transformsIndexPath,
+        ]),
+        snapshotDirs: [],
+        targetPaths: [
+            transformFilePath,
+            ...(shouldRemoveTransformsDirOnRollback ? [transformsDir] : []),
+        ],
+    };
+    try {
+        await fsp.mkdir(transformsDir, { recursive: true });
+        await fsp.writeFile(transformFilePath, buildBlockTransformSource({
+            fromBlockName: resolvedFromBlockName,
+            textDomain: workspace.workspace.textDomain,
+            transformSlug,
+        }), "utf8");
+        await writeBlockTransformRegistry(workspace.projectDir, target.blockSlug, transformSlug);
+        await ensureBlockTransformRegistrationHook(blockIndexPath);
+        await appendWorkspaceInventoryEntries(workspace.projectDir, {
+            blockTransformEntries: [
+                buildBlockTransformConfigEntry({
+                    blockSlug: target.blockSlug,
+                    fromBlockName: resolvedFromBlockName,
+                    toBlockName: target.blockName,
+                    transformSlug,
+                }),
+            ],
+        });
+        return {
+            blockSlug: target.blockSlug,
+            fromBlockName: resolvedFromBlockName,
+            projectDir: workspace.projectDir,
+            toBlockName: target.blockName,
+            transformSlug,
+        };
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw error;
+    }
+}
 /**
  * Add one `blockHooks` entry to an existing official workspace block.
  *

package/dist/runtime/cli-add.d.ts

@@ -10,5 +10,5 @@
 export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, } from "./cli-add-shared.js";
 export type { AddBlockTemplateId, AddKindId, EditorPluginSlotId, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
-export { runAddBindingSourceCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
+export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
 export { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";

package/dist/runtime/cli-add.js

@@ -9,5 +9,5 @@
  */
 export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
-export { runAddBindingSourceCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
+export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
 export { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";