@wp-typia/project-tools 0.20.0 → 0.20.1

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

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { syncTypeSchemas } from "@wp-typia/block-runtime/metadata-core";
+import semver from "semver";
 import { appendWorkspaceInventoryEntries, readWorkspaceInventory, } from "./workspace-inventory.js";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { toTitleCase } from "./string-case.js";
@@ -12,14 +13,63 @@ const ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
 const ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
 const ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end";
 const ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start";
-const WP_ABILITIES_SCRIPT_HANDLE = "wp-abilities";
-const WP_CORE_ABILITIES_SCRIPT_HANDLE = "wp-core-abilities";
+const WP_ABILITIES_PACKAGE_VERSION = "^0.10.0";
+const WP_CORE_ABILITIES_PACKAGE_VERSION = "^0.9.0";
+const WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities";
+const WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 function quotePhpString(value) {
     return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
 }
+function findPhpFunctionRange(source, functionName) {
+    const functionPattern = new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\([^)]*\\)\\s*\\{`, "u");
+    const match = functionPattern.exec(source);
+    if (!match) {
+        return null;
+    }
+    const openingBraceIndex = match.index + match[0].length - 1;
+    let depth = 0;
+    for (let index = openingBraceIndex; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === "{") {
+            depth += 1;
+        }
+        else if (character === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                const end = index + 1;
+                return {
+                    end,
+                    source: source.slice(match.index, end),
+                    start: match.index,
+                };
+            }
+        }
+    }
+    return null;
+}
+function replacePhpFunctionDefinition(source, functionName, replacement) {
+    const functionRange = findPhpFunctionRange(source, functionName);
+    if (!functionRange) {
+        return source;
+    }
+    return `${source.slice(0, functionRange.start)}${replacement.trimStart()}${source.slice(functionRange.end)}`;
+}
+function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
+    if (!existingVersion) {
+        return requiredVersion;
+    }
+    const existingMinimum = semver.minVersion(existingVersion);
+    const requiredMinimum = semver.minVersion(requiredVersion);
+    if (!existingMinimum || !requiredMinimum) {
+        return requiredVersion;
+    }
+    return semver.gte(existingMinimum, requiredMinimum)
+        ? existingVersion
+        : requiredVersion;
+}
 function toPascalCaseFromAbilitySlug(abilitySlug) {
     return normalizeBlockSlug(abilitySlug)
         .split("-")
@@ -98,7 +148,14 @@ function buildAbilityDataSource(abilitySlug) {
         .replace(/[^A-Z0-9]+/gu, "_")
         .replace(/_{2,}/gu, "_")
         .replace(/^_|_$/gu, "");
-    return `import abilityConfig from './ability.config.json';
+    return `import {
+\texecuteAbility,
+\tgetAbilities,
+\tgetAbility as getRegisteredAbility,
+} from '@wordpress/abilities';
+import '@wordpress/core-abilities';
+
+import abilityConfig from './ability.config.json';
 
 import type { ${pascalCase}AbilityInput, ${pascalCase}AbilityOutput } from './types';
 
@@ -110,55 +167,56 @@ interface WordPressAbilityDefinition {
 \tname?: string;
 }
 
-interface WordPressAbilitiesClient {
-\texecuteAbility( name: string, input?: unknown ): Promise< unknown >;
-\tgetAbilities( args?: { category?: string } ): WordPressAbilityDefinition[];
-\tgetAbility( name: string ): WordPressAbilityDefinition | undefined;
-}
-
-const ABILITY_CLIENT_UNAVAILABLE_MESSAGE =
-\t'The WordPress abilities client is unavailable on this screen. Ensure the Abilities API and @wordpress/core-abilities integration are loaded before using this scaffold.';
-
 export const ${abilityConstBase}_ABILITY = abilityConfig;
 export const ${abilityConstBase}_ABILITY_CATEGORY = abilityConfig.category;
 export const ${abilityConstBase}_ABILITY_ID = abilityConfig.abilityId;
 export const ${abilityConstBase}_ABILITY_META = abilityConfig.meta;
+const ABILITY_DISCOVERY_POLL_INTERVAL_MS = 50;
+const ABILITY_DISCOVERY_TIMEOUT_MS = 5000;
 
 export type {
 \t${pascalCase}AbilityInput,
 \t${pascalCase}AbilityOutput,
 };
 
-function resolveAbilitiesClient(): WordPressAbilitiesClient {
-\tconst runtime = globalThis as typeof globalThis & {
-\t\twindow?: {
-\t\t\twp?: {
-\t\t\t\tabilities?: WordPressAbilitiesClient;
-\t\t\t};
-\t\t};
-\t};
-\tconst client = runtime.window?.wp?.abilities;
-\tif ( ! client ) {
-\t\tthrow new Error( ABILITY_CLIENT_UNAVAILABLE_MESSAGE );
-\t}
+function sleep( milliseconds: number ): Promise< void > {
+\treturn new Promise( ( resolve ) => {
+\t\tsetTimeout( resolve, milliseconds );
+\t} );
+}
 
-\treturn client;
+async function waitFor${pascalCase}AbilityRegistration(): Promise< void > {
+\tconst deadline = Date.now() + ABILITY_DISCOVERY_TIMEOUT_MS;
+\twhile ( ! getRegisteredAbility( ${abilityConstBase}_ABILITY_ID ) ) {
+\t\tif ( Date.now() >= deadline ) {
+\t\t\treturn;
+\t\t}
+
+\t\tawait sleep( ABILITY_DISCOVERY_POLL_INTERVAL_MS );
+\t}
 }
 
-export function list${pascalCase}CategoryAbilities(): WordPressAbilityDefinition[] {
-\treturn resolveAbilitiesClient().getAbilities( {
+export async function list${pascalCase}CategoryAbilities(): Promise< WordPressAbilityDefinition[] > {
+\tawait waitFor${pascalCase}AbilityRegistration();
+
+\treturn getAbilities( {
 \t\tcategory: ${abilityConstBase}_ABILITY_CATEGORY.slug,
-\t} );
+\t} ) as WordPressAbilityDefinition[];
 }
 
-export function get${pascalCase}Ability():
+export async function get${pascalCase}Ability(): Promise<
 \t| WordPressAbilityDefinition
-\t| undefined {
-\treturn resolveAbilitiesClient().getAbility( ${abilityConstBase}_ABILITY_ID );
+\t| undefined
+> {
+\tawait waitFor${pascalCase}AbilityRegistration();
+
+\treturn getRegisteredAbility( ${abilityConstBase}_ABILITY_ID ) as
+\t\t| WordPressAbilityDefinition
+\t\t| undefined;
 }
 
-export function require${pascalCase}Ability(): WordPressAbilityDefinition {
-\tconst ability = get${pascalCase}Ability();
+export async function require${pascalCase}Ability(): Promise< WordPressAbilityDefinition > {
+\tconst ability = await get${pascalCase}Ability();
 \tif ( ability ) {
 \t\treturn ability;
 \t}
@@ -174,7 +232,9 @@ export function require${pascalCase}Ability(): WordPressAbilityDefinition {
 export async function run${pascalCase}Ability(
 \tinput: ${pascalCase}AbilityInput
 ): Promise< ${pascalCase}AbilityOutput > {
-\treturn ( await resolveAbilitiesClient().executeAbility(
+\tawait waitFor${pascalCase}AbilityRegistration();
+
+\treturn ( await executeAbility(
 \t\t${abilityConstBase}_ABILITY_ID,
 \t\tinput
 \t) ) as ${pascalCase}AbilityOutput;
@@ -186,8 +246,8 @@ function buildAbilityClientSource(abilitySlug) {
     return `/**
  * Re-export the typed ${pascalCase} ability client helpers.
  *
- * The underlying WordPress abilities client is expected to have been hydrated
- * by the site's admin/editor bootstrap before these helpers execute.
+ * The helper methods load the WordPress core abilities integration and wait for
+ * this server-registered ability before reading or executing it.
  */
 export * from './data';
 `;
@@ -559,22 +619,31 @@ function ${enqueueFunctionName}() {
 \t\t? $asset['dependencies']
 \t\t: array();
 
-\tforeach ( array( '${WP_CORE_ABILITIES_SCRIPT_HANDLE}', '${WP_ABILITIES_SCRIPT_HANDLE}' ) as $ability_dependency ) {
-\t\tif (
-\t\t\tfunction_exists( 'wp_script_is' ) &&
-\t\t\twp_script_is( $ability_dependency, 'registered' ) &&
-\t\t\t! in_array( $ability_dependency, $dependencies, true )
-\t\t) {
+\tforeach ( array( '${WP_CORE_ABILITIES_SCRIPT_MODULE_ID}', '${WP_ABILITIES_SCRIPT_MODULE_ID}' ) as $ability_dependency ) {
+\t\t$has_dependency = false;
+\t\tforeach ( $dependencies as $dependency ) {
+\t\t\t$dependency_id = is_array( $dependency ) && isset( $dependency['id'] )
+\t\t\t\t? $dependency['id']
+\t\t\t\t: $dependency;
+\t\t\tif ( $dependency_id === $ability_dependency ) {
+\t\t\t\t$has_dependency = true;
+\t\t\t\tbreak;
+\t\t\t}
+\t\t}
+\t\tif ( ! $has_dependency ) {
 \t\t\t$dependencies[] = $ability_dependency;
 \t\t}
 \t}
 
-\twp_enqueue_script(
+\tif ( ! function_exists( 'wp_enqueue_script_module' ) ) {
+\t\treturn;
+\t}
+
+\twp_enqueue_script_module(
 \t\t'${workspaceBaseName}-abilities',
 \t\tplugins_url( '${ABILITY_EDITOR_SCRIPT}', __FILE__ ),
 \t\t$dependencies,
-\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
-\t\ttrue
+\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path )
 \t);
 }
 `;
@@ -607,6 +676,9 @@ function ${enqueueFunctionName}() {
         if (!hasPhpFunctionDefinition(enqueueFunctionName)) {
             insertPhpSnippet(enqueueFunction);
         }
+        else if (!findPhpFunctionRange(nextSource, enqueueFunctionName)?.source.includes("wp_enqueue_script_module")) {
+            nextSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
+        }
         if (!nextSource.includes(loadHook)) {
             appendPhpSnippet(loadHook);
         }
@@ -626,10 +698,17 @@ async function ensureAbilityPackageScripts(workspace) {
         ...(packageJson.scripts ?? {}),
         "sync-abilities": packageJson.scripts?.["sync-abilities"] ?? "tsx scripts/sync-abilities.ts",
     };
-    if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {})) {
+    const nextDependencies = {
+        ...(packageJson.dependencies ?? {}),
+        [WP_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_ABILITIES_SCRIPT_MODULE_ID], WP_ABILITIES_PACKAGE_VERSION),
+        [WP_CORE_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_CORE_ABILITIES_SCRIPT_MODULE_ID], WP_CORE_ABILITIES_PACKAGE_VERSION),
+    };
+    if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {}) &&
+        JSON.stringify(nextDependencies) === JSON.stringify(packageJson.dependencies ?? {})) {
         return;
     }
     packageJson.scripts = nextScripts;
+    packageJson.dependencies = nextDependencies;
     await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}\n`, "utf8");
 }
 async function ensureAbilitySyncProjectAnchors(workspace) {
@@ -702,6 +781,28 @@ async function ensureAbilityWebpackAnchors(workspace) {
         if (/['"]abilities\/index['"]/u.test(source)) {
             return source;
         }
+        const optionalModuleReturnPattern = /(function\s+getOptionalModuleEntries\s*\(\)\s*\{[\s\S]*?)(\n\treturn Object\.fromEntries\(\s*entries\s*\);\n\})/u;
+        if (optionalModuleReturnPattern.test(source)) {
+            return source.replace(optionalModuleReturnPattern, `$1
+
+\tfor ( const [ entryName, candidates ] of [
+\t\t[
+\t\t\t'abilities/index',
+\t\t\t[ 'src/abilities/index.ts', 'src/abilities/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}
+$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);
         if (!match ||

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

@@ -446,7 +446,6 @@ export async function runAddRestResourceCommand({ cwd = process.cwd(), methods,
     const validatorsFilePath = path.join(restResourceDir, "api-validators.ts");
     const apiFilePath = path.join(restResourceDir, "api.ts");
     const dataFilePath = path.join(restResourceDir, "data.ts");
-    const clientFilePath = path.join(restResourceDir, "api-client.ts");
     const phpFilePath = path.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
     const mutationSnapshot = {
         fileSources: await snapshotWorkspaceFiles([

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

@@ -303,21 +303,24 @@ function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
     const hasServerGlob = source.includes(WORKSPACE_ABILITY_GLOB);
     const hasEditorScript = source.includes(WORKSPACE_ABILITY_EDITOR_SCRIPT);
     const hasEditorAsset = source.includes(WORKSPACE_ABILITY_EDITOR_ASSET);
+    const hasScriptModuleEnqueue = source.includes("wp_enqueue_script_module");
     return createDoctorCheck("Ability bootstrap", hasLoaderHook &&
         hasAdminEnqueueHook &&
         hasEditorEnqueueHook &&
         hasServerGlob &&
         hasEditorScript &&
-        hasEditorAsset
+        hasEditorAsset &&
+        hasScriptModuleEnqueue
         ? "pass"
         : "fail", hasLoaderHook &&
         hasAdminEnqueueHook &&
         hasEditorEnqueueHook &&
         hasServerGlob &&
         hasEditorScript &&
-        hasEditorAsset
-        ? "Ability loader and admin/editor client bootstrap hooks are present"
-        : "Missing ability loader hook or build/abilities script asset references");
+        hasEditorAsset &&
+        hasScriptModuleEnqueue
+        ? "Ability loader and admin/editor script-module bootstrap hooks are present"
+        : "Missing ability loader hook, script-module enqueue, or build/abilities asset references");
 }
 function checkWorkspaceAbilityIndex(projectDir, abilities) {
     const indexRelativePath = [

package/dist/runtime/typia-llm.d.ts

@@ -14,6 +14,8 @@ export interface TypiaLlmEndpointMethodDescriptor {
     description?: string;
     /** Input type used by the generated controller method, or null for no input. */
     inputTypeName: string | null;
+    /** Type names that must be imported when inputTypeName is an inline composite. */
+    inputTypeImportNames?: readonly string[];
     /** HTTP method from the source endpoint manifest. */
     method: EndpointManifestEndpointDefinition['method'];
     /** Stable operation identifier used as the generated method name. */

package/dist/runtime/typia-llm.js

@@ -84,21 +84,36 @@ const TYPESCRIPT_RESERVED_WORDS = new Set([
 function cloneJsonValueIfDefined(value) {
     return value === undefined ? undefined : cloneJsonValue(value);
 }
-function getEndpointInputTypeName(manifest, endpoint) {
+function getContractSourceTypeName(manifest, endpoint, contractName) {
+    const contract = manifest.contracts[contractName];
+    if (!contract) {
+        throw new Error(`Endpoint "${endpoint.operationId}" references missing input contract "${contractName}".`);
+    }
+    return contract.sourceTypeName;
+}
+function getEndpointInputTypeDescriptor(manifest, endpoint) {
     if (endpoint.bodyContract && endpoint.queryContract) {
-        throw new Error(`Endpoint "${endpoint.operationId}" defines both bodyContract and queryContract; typia.llm input mapping is ambiguous.`);
+        const bodyTypeName = getContractSourceTypeName(manifest, endpoint, endpoint.bodyContract);
+        const queryTypeName = getContractSourceTypeName(manifest, endpoint, endpoint.queryContract);
+        return {
+            importTypeNames: [bodyTypeName, queryTypeName],
+            signatureTypeName: `{ body: ${bodyTypeName}; query: ${queryTypeName} }`,
+        };
     }
     const contractName = endpoint.method === 'GET'
         ? endpoint.queryContract ?? null
         : endpoint.bodyContract ?? endpoint.queryContract ?? null;
     if (!contractName) {
-        return null;
-    }
-    const contract = manifest.contracts[contractName];
-    if (!contract) {
-        throw new Error(`Endpoint "${endpoint.operationId}" references missing input contract "${contractName}".`);
+        return {
+            importTypeNames: [],
+            signatureTypeName: null,
+        };
     }
-    return contract.sourceTypeName;
+    const sourceTypeName = getContractSourceTypeName(manifest, endpoint, contractName);
+    return {
+        importTypeNames: [sourceTypeName],
+        signatureTypeName: sourceTypeName,
+    };
 }
 function getEndpointOutputTypeName(manifest, endpoint) {
     const contract = manifest.contracts[endpoint.responseContract];
@@ -157,7 +172,12 @@ function renderTypiaLlmModuleFromMethodDescriptors({ applicationExportName, inte
     const importedTypeNames = new Set([structuredOutputTypeName]);
     for (const method of methods) {
         importedTypeNames.add(method.outputTypeName);
-        if (method.inputTypeName) {
+        if (method.inputTypeImportNames) {
+            for (const inputTypeImportName of method.inputTypeImportNames) {
+                importedTypeNames.add(inputTypeImportName);
+            }
+        }
+        else if (method.inputTypeName) {
             importedTypeNames.add(method.inputTypeName);
         }
     }
@@ -233,11 +253,19 @@ async function reconcileGeneratedTypiaLlmArtifacts(artifacts, check) {
 export function buildTypiaLlmEndpointMethodDescriptors(manifest) {
     return manifest.endpoints.map((endpoint) => {
         const normalizedAuth = normalizeEndpointAuthDefinition(endpoint);
+        const inputTypeDescriptor = getEndpointInputTypeDescriptor(manifest, endpoint);
+        const inputTypeName = inputTypeDescriptor.signatureTypeName;
+        const shouldUseInlineInputImports = inputTypeName !== null &&
+            inputTypeDescriptor.importTypeNames.length > 0 &&
+            inputTypeDescriptor.importTypeNames[0] !== inputTypeName;
         return {
             authIntent: normalizedAuth.auth,
             ...(normalizedAuth.authMode ? { authMode: normalizedAuth.authMode } : {}),
             description: endpoint.summary,
-            inputTypeName: getEndpointInputTypeName(manifest, endpoint),
+            inputTypeName,
+            ...(shouldUseInlineInputImports
+                ? { inputTypeImportNames: inputTypeDescriptor.importTypeNames }
+                : {}),
             method: endpoint.method,
             operationId: endpoint.operationId,
             outputTypeName: getEndpointOutputTypeName(manifest, endpoint),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",