wp-typia 0.22.2 → 0.22.3

package/dist-bunli/{cli-add-s0p4w1wz.js → cli-add-p3re8act.js}

@@ -21,7 +21,7 @@ import {
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-kww2sraq.js";
+} from "./cli-tbd9x8b6.js";
 import {
   DEFAULT_WORDPRESS_ABILITIES_VERSION,
   DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
@@ -34,7 +34,7 @@ import {
 } from "./cli-1sm60g1z.js";
 import {
   snapshotProjectVersion
-} from "./cli-6hcbjvym.js";
+} from "./cli-prc42zqd.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
@@ -58,6 +58,8 @@ import {
   assertAdminViewDoesNotExist,
   assertAiFeatureDoesNotExist,
   assertBindingSourceDoesNotExist,
+  assertBlockStyleDoesNotExist,
+  assertBlockTransformDoesNotExist,
   assertEditorPluginDoesNotExist,
   assertPatternDoesNotExist,
   assertRestResourceDoesNotExist,
@@ -95,7 +97,7 @@ import {
   toPascalCase,
   toSnakeCase,
   toTitleCase
-} from "./cli-smzkbfna.js";
+} from "./cli-x0h03qqe.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -2377,8 +2379,10 @@ registerBlockBindingsSource( {
 `;
 }
 function resolveBindingTarget(options, namespace) {
-  const hasBlock = options.blockName !== undefined && options.blockName.trim().length > 0;
-  const hasAttribute = options.attributeName !== undefined && options.attributeName.trim().length > 0;
+  const blockName = normalizeOptionalCliString(options.blockName);
+  const attributeName = normalizeOptionalCliString(options.attributeName);
+  const hasBlock = blockName !== undefined;
+  const hasAttribute = attributeName !== undefined;
   if (!hasBlock && !hasAttribute) {
     return;
   }
@@ -2386,8 +2390,8 @@ function resolveBindingTarget(options, namespace) {
     throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
   }
   return {
-    attributeName: assertValidBindingAttributeName(options.attributeName ?? ""),
-    blockSlug: resolveBindingTargetBlockSlug(options.blockName ?? "", namespace)
+    attributeName: assertValidBindingAttributeName(attributeName ?? ""),
+    blockSlug: resolveBindingTargetBlockSlug(blockName ?? "", namespace)
   };
 }
 function formatBindingAttributeTypeMember(attributeName) {
@@ -4367,12 +4371,14 @@ async function runAddRestResourceCommand({
     throw error;
   }
 }
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
 var import_semver = __toESM(require_semver(), 1);
 import fs5 from "fs";
 import { promises as fsp6 } from "fs";
 import path10 from "path";
 import { syncTypeSchemas as syncTypeSchemas2 } from "@wp-typia/block-runtime/metadata-core";
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-types.ts
 var ABILITY_SERVER_GLOB = "/inc/abilities/*.php";
 var ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
 var ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
@@ -4380,17 +4386,8 @@ var ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end";
 var ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start";
 var WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities";
 var WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
-function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
-  if (!existingVersion) {
-    return requiredVersion;
-  }
-  const existingMinimum = import_semver.default.minVersion(existingVersion);
-  const requiredMinimum = import_semver.default.minVersion(requiredVersion);
-  if (!existingMinimum || !requiredMinimum) {
-    return requiredVersion;
-  }
-  return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
-}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-templates.ts
 function toAbilityCategorySlug(workspaceNamespace) {
   const normalizedNamespace = workspaceNamespace.replace(/[^a-z0-9-]+/gu, "-").replace(/-{2,}/gu, "-").replace(/^-|-$/gu, "");
   return `${normalizedNamespace || "workspace"}-workflows`;
@@ -4855,6 +4852,19 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `).concat(`
 `);
 }
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
+function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
+  if (!existingVersion) {
+    return requiredVersion;
+  }
+  const existingMinimum = import_semver.default.minVersion(existingVersion);
+  const requiredMinimum = import_semver.default.minVersion(requiredVersion);
+  if (!existingMinimum || !requiredMinimum) {
+    return requiredVersion;
+  }
+  return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
+}
 function resolveAbilityRegistryPath(projectDir) {
   const abilitiesDir = path10.join(projectDir, "src", "abilities");
   return [path10.join(abilitiesDir, "index.ts"), path10.join(abilitiesDir, "index.js")].find((candidatePath) => fs5.existsSync(candidatePath)) ?? path10.join(abilitiesDir, "index.ts");
@@ -5066,21 +5076,29 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     }
     const sharedEntriesPattern = /(for\s*\(\s*const\s+relativePath\s+of\s+\[)([\s\S]*?)(\]\s*\)\s*\{)/u;
     const match = nextSource.match(sharedEntriesPattern);
-    if (!match || !match[2].includes("src/bindings/index.ts") || !match[2].includes("src/editor-plugins/index.ts")) {
+    if (!match || !/['"]src\/bindings\/index\.(?:ts|js)['"]/u.test(match[2]) || !/['"]src\/editor-plugins\/index\.(?:tsx|ts|js)['"]/u.test(match[2])) {
       throw new Error([
         `ensureAbilityBuildScriptAnchors could not patch ${path10.basename(buildScriptPath)}.`,
         "Missing the expected shared editor entries array in scripts/build-workspace.mjs.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    nextSource = nextSource.replace(sharedEntriesPattern, `$1
-		'src/bindings/index.ts',
-		'src/bindings/index.js',
-		'src/editor-plugins/index.ts',
-		'src/editor-plugins/index.js',
-		'src/abilities/index.ts',
-		'src/abilities/index.js',
-	$3`);
+    nextSource = nextSource.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      const missingAbilityEntries = [
+        "'src/abilities/index.ts'",
+        "'src/abilities/index.js'"
+      ].filter((entry) => !sharedEntries.includes(entry));
+      if (missingAbilityEntries.length === 0) {
+        return fullMatch;
+      }
+      const itemIndent = sharedEntries.match(/\n([ \t]*)['"]/u)?.[1] ?? "\t\t";
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const nextEntries = `${trimmedEntries}${separator}` + missingAbilityEntries.map((entry) => `
+${itemIndent}${entry},`).join("") + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
     return nextSource;
   });
 }
@@ -5109,8 +5127,7 @@ async function ensureAbilityWebpackAnchors(workspace) {
 			entries.push( [ entryName, entryPath ] );
 			break;
 		}
-	}
-$2`);
+	}$2`);
     }
     const sharedEntriesPattern = /for\s*\(\s*const\s+\[\s*entryName\s*,\s*candidates\s*\]\s+of\s+\[([\s\S]*?)\]\s*\)\s*\{/u;
     const match = source.match(sharedEntriesPattern);
@@ -5121,31 +5138,33 @@ $2`);
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    return source.replace(sharedEntriesPattern, `for ( const [ entryName, candidates ] of [
-		[
-			'bindings/index',
-			[ 'src/bindings/index.ts', 'src/bindings/index.js' ],
-		],
-		[
-			'editor-plugins/index',
-			[ 'src/editor-plugins/index.ts', 'src/editor-plugins/index.js' ],
-		],
-		[
-			'abilities/index',
-			[ 'src/abilities/index.ts', 'src/abilities/index.js' ],
-		],
-	] ) {`);
+    return source.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      if (/['"]abilities\/index['"]/u.test(sharedEntries)) {
+        return fullMatch;
+      }
+      const tupleIndent = sharedEntries.match(/\n([ \t]*)\[/u)?.[1] ?? "\t\t";
+      const nestedIndent = `${tupleIndent}	`;
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const abilityTuple = [
+        `${tupleIndent}[`,
+        `${nestedIndent}'abilities/index',`,
+        `${nestedIndent}[ 'src/abilities/index.ts', 'src/abilities/index.js' ],`,
+        `${tupleIndent}],`
+      ].join(`
+`);
+      const nextEntries = `${trimmedEntries}${separator}
+${abilityTuple}` + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
   });
 }
-async function runAddAbilityCommand({
-  abilityName,
-  cwd = process.cwd()
+async function scaffoldAbilityWorkspace({
+  abilitySlug,
+  compatibilityPolicy,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
   const blockConfigPath = path10.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const buildScriptPath = path10.join(workspace.projectDir, "scripts", "build-workspace.mjs");
@@ -5204,18 +5223,37 @@ async function runAddAbilityCommand({
     });
     await writeAbilityRegistry(workspace.projectDir, abilitySlug);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
-      abilityEntries: [buildAbilityConfigEntry(abilitySlug, compatibilityPolicy)]
+      abilityEntries: [
+        buildAbilityConfigEntry(abilitySlug, compatibilityPolicy)
+      ]
     });
-    return {
-      abilitySlug,
-      projectDir: workspace.projectDir
-    };
   } catch (error) {
     await rollbackWorkspaceMutation(mutationSnapshot);
     throw error;
   }
 }
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+async function runAddAbilityCommand({
+  abilityName,
+  cwd = process.cwd()
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
+  await scaffoldAbilityWorkspace({
+    abilitySlug,
+    compatibilityPolicy,
+    workspace
+  });
+  return {
+    abilitySlug,
+    projectDir: workspace.projectDir
+  };
+}
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-scaffold.ts
 import { promises as fsp8 } from "fs";
 import path13 from "path";
 
@@ -6072,7 +6110,7 @@ async function ensureAiFeatureSyncRestAnchors(workspace) {
   });
 }
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-templates.ts
 function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
   const aiFeatureTitle = toTitleCase(aiFeatureSlug);
   const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
@@ -6673,17 +6711,14 @@ add_action( 'admin_notices', '${adminNoticeFunctionName}' );
 add_action( 'rest_api_init', '${registerRoutesFunctionName}' );
 `;
 }
-async function runAddAiFeatureCommand({
-  aiFeatureName,
-  cwd = process.cwd(),
-  namespace
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-scaffold.ts
+async function scaffoldAiFeatureWorkspace({
+  aiFeatureSlug,
+  compatibilityPolicy,
+  namespace,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
-  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
   const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const packageJsonPath = path13.join(workspace.projectDir, "package.json");
@@ -6721,7 +6756,7 @@ async function runAddAiFeatureCommand({
     await fsp8.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
     await fsp8.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
     await fsp8.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
-    await fsp8.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
+    await fsp8.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, namespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
     const pascalCase = toPascalCase(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
@@ -6730,7 +6765,7 @@ async function runAddAiFeatureCommand({
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
       variables: {
-        namespace: resolvedNamespace,
+        namespace,
         pascalCase,
         slugKebabCase: aiFeatureSlug,
         title: toTitleCase(aiFeatureSlug)
@@ -6743,14 +6778,11 @@ async function runAddAiFeatureCommand({
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
       aiFeatureEntries: [
-        buildAiFeatureConfigEntry(aiFeatureSlug, resolvedNamespace)
+        buildAiFeatureConfigEntry(aiFeatureSlug, namespace)
       ],
       transformSource: ensureBlockConfigCanAddRestManifests
     });
     return {
-      aiFeatureSlug,
-      namespace: resolvedNamespace,
-      projectDir: workspace.projectDir,
       warnings: packageScriptChanges.addedProjectToolsDependency ? [
         "Added `@wp-typia/project-tools` to devDependencies for `sync-ai`. If this workspace was already installed, rerun your package manager install command before the first `wp-typia sync ai`."
       ] : []
@@ -6761,6 +6793,32 @@ async function runAddAiFeatureCommand({
   }
 }
 
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+async function runAddAiFeatureCommand({
+  aiFeatureName,
+  cwd = process.cwd(),
+  namespace
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
+  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
+  const scaffoldResult = await scaffoldAiFeatureWorkspace({
+    aiFeatureSlug,
+    compatibilityPolicy,
+    namespace: resolvedNamespace,
+    workspace
+  });
+  return {
+    aiFeatureSlug,
+    namespace: resolvedNamespace,
+    projectDir: workspace.projectDir,
+    warnings: scaffoldResult.warnings
+  };
+}
+
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
 var VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
 var VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
@@ -7242,24 +7300,6 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
   const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
   await fsp9.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
-function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  const stylePath = path14.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
-  if (fs6.existsSync(stylePath)) {
-    throw new Error(`A block style already exists at ${path14.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 = path14.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
-  if (fs6.existsSync(transformPath)) {
-    throw new Error(`A block transform already exists at ${path14.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) {
@@ -7507,4 +7547,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=FE993C1947A36DF464756E2164756E21
+//# debugId=272EBA8B7C96349F64756E2164756E21