@wp-typia/project-tools 0.24.4 → 0.24.5

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

@@ -1,275 +1 @@
-import { promises as fsp } from "node:fs";
-import path from "node:path";
-import { syncBlockMetadata, } from "@wp-typia/block-runtime/metadata-core";
-import ts from "typescript";
-import { resolveWorkspaceProject } from "./workspace-project.js";
-import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from "./workspace-inventory.js";
-import { assertBindingSourceDoesNotExist, assertValidGeneratedSlug, getWorkspaceBootstrapPath, normalizeBlockSlug, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
-import { ensureBindingSourceBootstrapAnchors, resolveBindingSourceRegistryPath, writeBindingSourceRegistry, } from "./cli-add-workspace-binding-source-anchors.js";
-import { buildBindingSourceConfigEntry, buildBindingSourceEditorSource, buildBindingSourceServerSource, } from "./cli-add-workspace-binding-source-source-emitters.js";
-import { resolveWorkspaceBlockTargetName } from "./block-targets.js";
-import { normalizeOptionalCliString } from "./cli-validation.js";
-import { getPropertyNameText } from "./ts-property-names.js";
-import { assertPostMetaBindingPath, loadPostMetaBindingFields, } from "./post-meta-binding-fields.js";
-const BINDING_ATTRIBUTE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
-function assertValidBindingAttributeName(attributeName) {
-    const trimmed = attributeName.trim();
-    if (!trimmed) {
-        throw new Error("`wp-typia add binding-source` requires --attribute <attribute> to include a value when --block is provided.");
-    }
-    if (!BINDING_ATTRIBUTE_NAME_PATTERN.test(trimmed)) {
-        throw new Error(`Binding attribute "${trimmed}" must start with a letter and use only letters, numbers, underscores, or hyphens.`);
-    }
-    return trimmed;
-}
-function resolveBindingTarget(options, namespace) {
-    const blockName = normalizeOptionalCliString(options.blockName);
-    const attributeName = normalizeOptionalCliString(options.attributeName);
-    const hasBlock = blockName !== undefined;
-    const hasAttribute = attributeName !== undefined;
-    if (!hasBlock && !hasAttribute) {
-        return undefined;
-    }
-    if (!hasBlock || !hasAttribute) {
-        throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
-    }
-    const targetBlock = resolveWorkspaceBlockTargetName(blockName ?? "", namespace, {
-        empty: () => "`wp-typia add binding-source` requires --block <block-slug|namespace/block-slug> to include a value when --attribute is provided.",
-        emptySegment: (input) => `Binding target block "${input}" must use <block-slug> or <namespace/block-slug> format without empty path segments.`,
-        invalidFormat: (input) => `Binding target block "${input}" must use <block-slug> or <namespace/block-slug> format.`,
-        namespaceMismatch: (input, actualNamespace, expectedNamespace) => `Binding target block "${input}" uses namespace "${actualNamespace}". Expected "${expectedNamespace}".`,
-    });
-    return {
-        attributeName: assertValidBindingAttributeName(attributeName ?? ""),
-        blockSlug: targetBlock.blockSlug,
-    };
-}
-function resolvePostMetaInventoryEntry(inventory, postMetaName) {
-    const postMetaSlug = assertValidGeneratedSlug("Post meta source", normalizeBlockSlug(postMetaName), "wp-typia add binding-source <name> --from-post-meta <post-meta> [--meta-path <field>]");
-    const postMeta = inventory.postMeta.find((entry) => entry.slug === postMetaSlug);
-    if (!postMeta) {
-        throw new Error(`Post meta contract "${postMetaSlug}" does not exist in scripts/block-config.ts. Run \`wp-typia add post-meta ${postMetaSlug} --post-type <post-type>\` first, then retry \`wp-typia add binding-source\`.`);
-    }
-    return postMeta;
-}
-async function resolveBindingPostMetaSource(projectDir, inventory, options) {
-    const postMetaName = normalizeOptionalCliString(options.postMetaName);
-    const metaPath = normalizeOptionalCliString(options.metaPath);
-    if (!postMetaName && !metaPath) {
-        return undefined;
-    }
-    if (!postMetaName) {
-        throw new Error("`wp-typia add binding-source` requires --from-post-meta <post-meta> or --post-meta <post-meta> when --meta-path is provided.");
-    }
-    const postMeta = resolvePostMetaInventoryEntry(inventory, postMetaName);
-    const fields = await loadPostMetaBindingFields(projectDir, postMeta);
-    const selectedField = metaPath
-        ? assertPostMetaBindingPath(fields, postMeta.slug, metaPath)
-        : fields[0];
-    if (!selectedField) {
-        throw new Error(`Post meta contract "${postMeta.slug}" does not expose a top-level field for binding-source defaults.`);
-    }
-    return {
-        fields,
-        metaKey: postMeta.metaKey,
-        metaPath: selectedField.name,
-        postMetaSlug: postMeta.slug,
-        postType: postMeta.postType,
-        schemaFile: postMeta.schemaFile,
-        sourceTypeName: postMeta.sourceTypeName,
-    };
-}
-function resolveBindingAttributeTsType(schemaType) {
-    switch (schemaType) {
-        case "array":
-            return "unknown[]";
-        case "boolean":
-            return "boolean";
-        case "integer":
-        case "number":
-            return "number";
-        case "object":
-            return "Record<string, unknown>";
-        default:
-            return "string";
-    }
-}
-function formatBindingAttributeTypeMember(attributeName, schemaType = "string") {
-    const propertyName = /^[A-Za-z_$][\w$]*$/u.test(attributeName)
-        ? attributeName
-        : JSON.stringify(attributeName);
-    const tsType = resolveBindingAttributeTsType(schemaType);
-    return [
-        "\t/**",
-        `\t * Starter ${tsType} attribute declared for WordPress Block Bindings.`,
-        "\t */",
-        `\t${propertyName}?: ${tsType};`,
-    ].join("\n");
-}
-function getInterfaceDeclaration(source, interfaceName) {
-    const sourceFile = ts.createSourceFile("types.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    let declaration;
-    const visit = (node) => {
-        if (ts.isInterfaceDeclaration(node) && node.name.text === interfaceName) {
-            declaration = node;
-            return true;
-        }
-        return ts.forEachChild(node, (child) => (visit(child) ? true : undefined)) ?? false;
-    };
-    visit(sourceFile);
-    return declaration ? { declaration, sourceFile } : undefined;
-}
-function interfaceHasAttributeMember(declaration, attributeName) {
-    return declaration.members.some((member) => ts.isPropertySignature(member) &&
-        member.name !== undefined &&
-        getPropertyNameText(member.name) === attributeName);
-}
-function insertBindingAttributeTypeMember(source, declaration, attributeName, schemaType = "string") {
-    let closeBracePosition = declaration.end - 1;
-    while (closeBracePosition > declaration.pos && source[closeBracePosition] !== "}") {
-        closeBracePosition -= 1;
-    }
-    if (source[closeBracePosition] !== "}") {
-        throw new Error("Unable to locate the target interface closing brace.");
-    }
-    const lineEnding = source.includes("\r\n") ? "\r\n" : "\n";
-    const beforeCloseBrace = source.slice(0, closeBracePosition);
-    const afterCloseBrace = source.slice(closeBracePosition);
-    const memberSource = formatBindingAttributeTypeMember(attributeName, schemaType)
-        .split("\n")
-        .join(lineEnding);
-    const prefix = beforeCloseBrace.endsWith(lineEnding) ? "" : lineEnding;
-    return `${beforeCloseBrace}${prefix}${memberSource}${lineEnding}${afterCloseBrace}`;
-}
-async function ensureBindingTargetBlockAttributeType(projectDir, block, target, schemaType = "string") {
-    if (!block.attributeTypeName) {
-        throw new Error(`Workspace block "${block.slug}" must include attributeTypeName in scripts/block-config.ts before it can receive binding-source targets.`);
-    }
-    const typesPath = path.join(projectDir, block.typesFile);
-    const source = await fsp.readFile(typesPath, "utf8");
-    const targetInterface = getInterfaceDeclaration(source, block.attributeTypeName);
-    if (!targetInterface) {
-        throw new Error(`Unable to locate interface ${block.attributeTypeName} in ${block.typesFile}.`);
-    }
-    let nextSource = source;
-    if (!interfaceHasAttributeMember(targetInterface.declaration, target.attributeName)) {
-        nextSource = insertBindingAttributeTypeMember(source, targetInterface.declaration, target.attributeName, schemaType);
-        await fsp.writeFile(typesPath, nextSource, "utf8");
-    }
-    await syncBlockMetadata({
-        blockJsonFile: path.join("src", "blocks", block.slug, "block.json"),
-        jsonSchemaFile: path.join("src", "blocks", block.slug, "typia.schema.json"),
-        manifestFile: path.join("src", "blocks", block.slug, "typia.manifest.json"),
-        openApiFile: path.join("src", "blocks", block.slug, "typia.openapi.json"),
-        projectRoot: projectDir,
-        sourceTypeName: block.attributeTypeName,
-        typesFile: block.typesFile,
-    });
-}
-/**
- * Add one block binding source scaffold to an official workspace project.
- *
- * @param options Command options for the binding-source scaffold workflow.
- * @param options.attributeName Optional generated block attribute to declare as
- * bindable. Must be provided together with `blockName`.
- * @param options.blockName Optional generated block slug or full block name to
- * receive the bindable attribute wiring. Must be provided together with
- * `attributeName`.
- * @param options.bindingSourceName Human-entered binding source name that will
- * be normalized and validated before files are written.
- * @param options.cwd Working directory used to resolve the nearest official
- * workspace. Defaults to `process.cwd()`.
- * @param options.metaPath Optional top-level post-meta field used as the
- * binding source's default `field` arg. Requires `postMetaName`.
- * @param options.postMetaName Optional generated post-meta contract slug used
- * to back the binding source with `get_post_meta()`.
- * @returns A promise that resolves with the normalized `bindingSourceSlug` and
- * owning `projectDir` after the server/editor files, optional target block
- * metadata, and inventory entry have been written successfully. Post-meta
- * backed results additionally include `metaKey`, `metaPath`, `postMetaSlug`,
- * `postType`, and `schemaFile`.
- * @throws {Error} When the command is run outside an official workspace, when
- * the slug is invalid, when a binding target is incomplete or unknown, or when
- * a conflicting file or inventory entry exists. Post-meta backed runs also
- * throw when the referenced contract or requested top-level field cannot be
- * resolved.
- */
-export async function runAddBindingSourceCommand({ attributeName, bindingSourceName, blockName, cwd = process.cwd(), metaPath, postMetaName, }) {
-    const workspace = resolveWorkspaceProject(cwd);
-    const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--from-post-meta <post-meta> --meta-path <field>]");
-    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
-    assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
-    const target = resolveBindingTarget({
-        attributeName,
-        blockName,
-    }, workspace.workspace.namespace);
-    const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
-    const postMeta = await resolveBindingPostMetaSource(workspace.projectDir, inventory, {
-        metaPath,
-        postMetaName,
-    });
-    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
-    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-    const bindingsIndexPath = await resolveBindingSourceRegistryPath(workspace.projectDir);
-    const bindingSourceDir = path.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-    const serverFilePath = path.join(bindingSourceDir, "server.php");
-    const editorFilePath = path.join(bindingSourceDir, "editor.ts");
-    const blockJsonPath = target
-        ? path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json")
-        : undefined;
-    const targetGeneratedMetadataPaths = target
-        ? [
-            path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
-            path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
-            path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
-            path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php"),
-        ]
-        : [];
-    const mutationSnapshot = {
-        fileSources: await snapshotWorkspaceFiles([
-            blockConfigPath,
-            bootstrapPath,
-            bindingsIndexPath,
-            ...(blockJsonPath ? [blockJsonPath] : []),
-            ...(targetBlock ? [path.join(workspace.projectDir, targetBlock.typesFile)] : []),
-            ...targetGeneratedMetadataPaths,
-        ]),
-        snapshotDirs: [],
-        targetPaths: [bindingSourceDir],
-    };
-    try {
-        await fsp.mkdir(bindingSourceDir, { recursive: true });
-        await ensureBindingSourceBootstrapAnchors(workspace);
-        await fsp.writeFile(serverFilePath, buildBindingSourceServerSource(bindingSourceSlug, workspace.workspace.phpPrefix, workspace.workspace.namespace, workspace.workspace.textDomain, target, postMeta), "utf8");
-        await fsp.writeFile(editorFilePath, buildBindingSourceEditorSource(bindingSourceSlug, workspace.workspace.namespace, workspace.workspace.textDomain, target, postMeta), "utf8");
-        if (target && targetBlock) {
-            const targetSchemaType = postMeta?.fields.find((field) => field.name === postMeta.metaPath)?.schemaType ??
-                "string";
-            await ensureBindingTargetBlockAttributeType(workspace.projectDir, targetBlock, target, targetSchemaType);
-        }
-        await writeBindingSourceRegistry(workspace.projectDir, bindingSourceSlug);
-        await appendWorkspaceInventoryEntries(workspace.projectDir, {
-            bindingSourceEntries: [
-                buildBindingSourceConfigEntry(bindingSourceSlug, target, postMeta),
-            ],
-        });
-        return {
-            ...(target ? { attributeName: target.attributeName, blockSlug: target.blockSlug } : {}),
-            bindingSourceSlug,
-            ...(postMeta
-                ? {
-                    metaKey: postMeta.metaKey,
-                    metaPath: postMeta.metaPath,
-                    postMetaSlug: postMeta.postMetaSlug,
-                    postType: postMeta.postType,
-                    schemaFile: postMeta.schemaFile,
-                }
-                : {}),
-            projectDir: workspace.projectDir,
-        };
-    }
-    catch (error) {
-        await rollbackWorkspaceMutation(mutationSnapshot);
-        throw error;
-    }
-}
+export * from "./add/cli-add-workspace-binding-source.js";

package/dist/runtime/cli-add-workspace-block-style.d.ts

@@ -1,22 +1 @@
-import { type RunAddBlockStyleCommandOptions } from "./cli-add-shared.js";
-/**
- * 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 declare function runAddBlockStyleCommand({ blockName, cwd, styleName, }: RunAddBlockStyleCommandOptions): Promise<{
-    blockSlug: string;
-    projectDir: string;
-    styleSlug: string;
-}>;
+export * from "./add/cli-add-workspace-block-style.js";

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

@@ -1,148 +1 @@
-import { promises as fsp } from "node:fs";
-import path from "node:path";
-import { pathExists } from "./fs-async.js";
-import { assertBlockStyleDoesNotExist, assertValidGeneratedSlug, normalizeBlockSlug, quoteTsString, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
-import { ensureWorkspaceEntrypointCall } from "./cli-add-workspace-registration-hooks.js";
-import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from "./workspace-inventory.js";
-import { resolveWorkspaceProject } from "./workspace-project.js";
-import { toSnakeCase, toTitleCase } from "./string-case.js";
-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;
-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 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 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}
-}
-`;
-}
-async function ensureBlockStyleRegistrationHook(blockIndexPath) {
-    await ensureWorkspaceEntrypointCall({
-        blockIndexPath,
-        callLine: BLOCK_STYLES_CALL_LINE,
-        callPattern: BLOCK_STYLES_CALL_PATTERN,
-        importLine: BLOCK_STYLES_IMPORT_LINE,
-        importPattern: BLOCK_STYLES_IMPORT_PATTERN,
-    });
-}
-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 = (await fsp.readdir(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");
-}
-/**
- * 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 = await readWorkspaceInventoryAsync(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 = !(await pathExists(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;
-    }
-}
+export * from "./add/cli-add-workspace-block-style.js";

package/dist/runtime/cli-add-workspace-block-transform.d.ts

@@ -1,32 +1 @@
-import { type RunAddBlockTransformCommandOptions } from "./cli-add-shared.js";
-/**
- * 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 declare function runAddBlockTransformCommand({ cwd, fromBlockName, toBlockName, transformName, }: RunAddBlockTransformCommandOptions): Promise<{
-    blockSlug: string;
-    fromBlockName: string;
-    projectDir: string;
-    toBlockName: string;
-    transformSlug: string;
-}>;
+export * from "./add/cli-add-workspace-block-transform.js";