@wp-typia/project-tools 0.22.4 → 0.22.6

package/dist/runtime/template-source-normalization.js

@@ -1,12 +1,12 @@
 /// <reference path="./external-template-modules.d.ts" />
-import fs from 'node:fs';
 import path from 'node:path';
 import { loadExternalTemplateLayerManifest } from './template-layers.js';
 import { getPackageVersions } from './package-versions.js';
-import { getExternalTemplateEntry } from './template-source-external.js';
-import { getTemplateProjectType } from './template-source-remote.js';
+import { findExternalTemplateEntry } from './template-source-external.js';
+import { getTemplateProjectTypeAsync } from './template-source-remote.js';
+import { pathExists } from './fs-async.js';
 export { renderCreateBlockExternalTemplate } from './template-source-external.js';
-export { getTemplateProjectType, getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
+export { getTemplateProjectType, getTemplateProjectTypeAsync, getDefaultCategory, getDefaultCategoryAsync, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
 export function getTemplateVariableContext(variables) {
     const { apiClientPackageVersion, blockRuntimePackageVersion, blockTypesPackageVersion, projectToolsPackageVersion, restPackageVersion, } = getPackageVersions();
     return {
@@ -27,29 +27,29 @@ export function getTemplateVariableContext(variables) {
     };
 }
 export async function detectTemplateSourceFormat(sourceDir) {
-    if (fs.existsSync(path.join(sourceDir, 'package.json.mustache'))) {
+    if (await pathExists(path.join(sourceDir, 'package.json.mustache'))) {
         return 'wp-typia';
     }
     if (await loadExternalTemplateLayerManifest(sourceDir)) {
         throw new Error(`Template source at ${sourceDir} is an external layer package. External layers currently compose only through built-in scaffolds via the runtime API, not as standalone template ids.`);
     }
-    if (getExternalTemplateEntry(sourceDir)) {
+    if (await findExternalTemplateEntry(sourceDir)) {
         return 'create-block-external';
     }
-    if (getTemplateProjectType(sourceDir) !== null) {
+    if ((await getTemplateProjectTypeAsync(sourceDir)) !== null) {
         return 'wp-typia';
     }
-    const sourceRoot = fs.existsSync(path.join(sourceDir, 'src'))
+    const sourceRoot = await pathExists(path.join(sourceDir, 'src'))
         ? path.join(sourceDir, 'src')
         : sourceDir;
     const blockJsonCandidates = [
         path.join(sourceDir, 'block.json'),
         path.join(sourceRoot, 'block.json'),
     ];
-    const hasBlockJson = blockJsonCandidates.some((candidate) => fs.existsSync(candidate));
-    const hasIndexFile = ['index.js', 'index.jsx', 'index.ts', 'index.tsx'].some((filename) => fs.existsSync(path.join(sourceRoot, filename)));
-    const hasEditFile = ['edit.js', 'edit.jsx', 'edit.ts', 'edit.tsx'].some((filename) => fs.existsSync(path.join(sourceRoot, filename)));
-    const hasSaveFile = ['save.js', 'save.jsx', 'save.ts', 'save.tsx'].some((filename) => fs.existsSync(path.join(sourceRoot, filename)));
+    const hasBlockJson = (await Promise.all(blockJsonCandidates.map((candidate) => pathExists(candidate)))).some(Boolean);
+    const hasIndexFile = (await Promise.all(['index.js', 'index.jsx', 'index.ts', 'index.tsx'].map((filename) => pathExists(path.join(sourceRoot, filename))))).some(Boolean);
+    const hasEditFile = (await Promise.all(['edit.js', 'edit.jsx', 'edit.ts', 'edit.tsx'].map((filename) => pathExists(path.join(sourceRoot, filename))))).some(Boolean);
+    const hasSaveFile = (await Promise.all(['save.js', 'save.jsx', 'save.ts', 'save.tsx'].map((filename) => pathExists(path.join(sourceRoot, filename))))).some(Boolean);
     if (hasBlockJson && hasIndexFile && hasEditFile && hasSaveFile) {
         return 'create-block-subset';
     }

package/dist/runtime/template-source-remote.d.ts

@@ -6,11 +6,25 @@ import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from
  * @returns The declared block category, or "widgets" when detection fails.
  */
 export declare function getDefaultCategory(sourceDir: string): string;
+/**
+ * Read a remote block source and return its default block category asynchronously.
+ *
+ * @param sourceDir Block source directory that may contain a block.json file.
+ * @returns The declared block category, or "widgets" when detection fails.
+ */
+export declare function getDefaultCategoryAsync(sourceDir: string): Promise<string>;
 /**
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
  */
 export declare function getTemplateProjectType(sourceDir: string): string | null;
+/**
+ * Read `wpTypia.projectType` from template metadata asynchronously.
+ *
+ * @param sourceDir Template source directory to inspect.
+ * @returns The project type when present, otherwise `null`.
+ */
+export declare function getTemplateProjectTypeAsync(sourceDir: string): Promise<string | null>;
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *

package/dist/runtime/template-source-remote.js

@@ -5,6 +5,7 @@ import { assertExternalTemplateFileSize, getExternalTemplatePackageJsonMaxBytes,
 import { getBuiltInTemplateLayerDirs, isOmittableBuiltInTemplateLayerDir, } from './template-builtins.js';
 import { copyRawDirectory } from './template-render.js';
 import { createManagedTempRoot } from './temp-roots.js';
+import { pathExists } from './fs-async.js';
 async function cleanupSeedRootPair(cleanup, seedCleanup) {
     let cleanupError;
     try {
@@ -43,6 +44,18 @@ function readRemoteBlockJson(blockDir) {
     }
     throw new Error(`Unable to locate block.json in ${blockDir}`);
 }
+async function readRemoteBlockJsonAsync(blockDir) {
+    const sourceRoot = await getSeedSourceRoot(blockDir);
+    for (const candidate of [
+        path.join(blockDir, 'block.json'),
+        path.join(sourceRoot, 'block.json'),
+    ]) {
+        if (await pathExists(candidate)) {
+            return JSON.parse(await fsp.readFile(candidate, 'utf8'));
+        }
+    }
+    throw new Error(`Unable to locate block.json in ${blockDir}`);
+}
 /**
  * Read a remote block source and return its default block category.
  *
@@ -58,6 +71,21 @@ export function getDefaultCategory(sourceDir) {
         return 'widgets';
     }
 }
+/**
+ * Read a remote block source and return its default block category asynchronously.
+ *
+ * @param sourceDir Block source directory that may contain a block.json file.
+ * @returns The declared block category, or "widgets" when detection fails.
+ */
+export async function getDefaultCategoryAsync(sourceDir) {
+    try {
+        const blockJson = await readRemoteBlockJsonAsync(sourceDir);
+        return getDefaultCategoryFromBlockJson(blockJson);
+    }
+    catch {
+        return 'widgets';
+    }
+}
 function readTemplatePackageJson(sourceDir) {
     for (const candidate of [
         path.join(sourceDir, 'package.json.mustache'),
@@ -83,6 +111,31 @@ function readTemplatePackageJson(sourceDir) {
     }
     return null;
 }
+async function readTemplatePackageJsonAsync(sourceDir) {
+    for (const candidate of [
+        path.join(sourceDir, 'package.json.mustache'),
+        path.join(sourceDir, 'package.json'),
+    ]) {
+        if (!(await pathExists(candidate))) {
+            continue;
+        }
+        try {
+            assertExternalTemplateFileSize(candidate, {
+                label: `Template metadata file "${candidate}"`,
+                maxBytes: getExternalTemplatePackageJsonMaxBytes(),
+            });
+            return {
+                packageJson: JSON.parse(await fsp.readFile(candidate, 'utf8')),
+                sourcePath: candidate,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown parse failure';
+            throw new Error(`Failed to parse template metadata file "${candidate}": ${message}`);
+        }
+    }
+    return null;
+}
 /**
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
@@ -101,6 +154,26 @@ export function getTemplateProjectType(sourceDir) {
     }
     return projectType;
 }
+/**
+ * Read `wpTypia.projectType` from template metadata asynchronously.
+ *
+ * @param sourceDir Template source directory to inspect.
+ * @returns The project type when present, otherwise `null`.
+ */
+export async function getTemplateProjectTypeAsync(sourceDir) {
+    const packageJsonEntry = await readTemplatePackageJsonAsync(sourceDir);
+    if (!packageJsonEntry) {
+        return null;
+    }
+    const projectType = packageJsonEntry.packageJson.wpTypia?.projectType;
+    if (projectType === undefined) {
+        return null;
+    }
+    if (typeof projectType !== 'string' || projectType.trim().length === 0) {
+        throw new Error(`Template metadata file "${packageJsonEntry.sourcePath}" defines wpTypia.projectType, but it must be a non-empty string.`);
+    }
+    return projectType;
+}
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *
@@ -119,7 +192,7 @@ export async function normalizeWpTypiaTemplateSeed(seed) {
                     fs.existsSync(mustacheVariantPath));
             },
         });
-        if (seed.assetsDir && fs.existsSync(seed.assetsDir)) {
+        if (seed.assetsDir && (await pathExists(seed.assetsDir))) {
             await fsp.cp(seed.assetsDir, path.join(normalizedDir, 'assets'), {
                 recursive: true,
                 force: true,
@@ -268,17 +341,17 @@ async function patchRemotePackageJson(templateDir, needsInteractivity) {
     }
     await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
 }
-function getSeedSourceRoot(blockDir) {
-    return fs.existsSync(path.join(blockDir, 'src'))
+async function getSeedSourceRoot(blockDir) {
+    return (await pathExists(path.join(blockDir, 'src')))
         ? path.join(blockDir, 'src')
         : blockDir;
 }
-function findSeedRenderPhp(seed) {
+async function findSeedRenderPhp(seed) {
     for (const candidate of [
         path.join(seed.blockDir, 'render.php'),
         path.join(seed.rootDir, 'render.php'),
     ]) {
-        if (fs.existsSync(candidate)) {
+        if (await pathExists(candidate)) {
             return candidate;
         }
     }
@@ -331,11 +404,11 @@ export async function normalizeCreateBlockSubset(seed, context) {
     const { path: tempRoot, cleanup } = await createManagedTempRoot('wp-typia-remote-template-');
     try {
         const templateDir = path.join(tempRoot, 'template');
-        const blockJson = readRemoteBlockJson(seed.blockDir);
-        const sourceRoot = getSeedSourceRoot(seed.blockDir);
+        const blockJson = await readRemoteBlockJsonAsync(seed.blockDir);
+        const sourceRoot = await getSeedSourceRoot(seed.blockDir);
         await fsp.mkdir(templateDir, { recursive: true });
         for (const layerDir of getBuiltInTemplateLayerDirs('basic')) {
-            if (!fs.existsSync(layerDir)) {
+            if (!(await pathExists(layerDir))) {
                 if (isOmittableBuiltInTemplateLayerDir('basic', layerDir)) {
                     continue;
                 }
@@ -351,11 +424,11 @@ export async function normalizeCreateBlockSubset(seed, context) {
             recursive: true,
             force: true,
         });
-        const remoteRenderPath = findSeedRenderPhp(seed);
+        const remoteRenderPath = await findSeedRenderPhp(seed);
         if (remoteRenderPath) {
             await fsp.copyFile(remoteRenderPath, path.join(templateDir, 'render.php'));
         }
-        if (seed.assetsDir && fs.existsSync(seed.assetsDir)) {
+        if (seed.assetsDir && (await pathExists(seed.assetsDir))) {
             await fsp.cp(seed.assetsDir, path.join(templateDir, 'assets'), {
                 recursive: true,
                 force: true,
@@ -366,11 +439,14 @@ export async function normalizeCreateBlockSubset(seed, context) {
         await rewriteBlockJsonImports(path.join(templateDir, 'src'));
         const needsInteractivity = typeof blockJson.viewScriptModule === 'string' ||
             typeof blockJson.viewScript === 'string' ||
-            fs.existsSync(path.join(templateDir, 'src', 'view.js')) ||
-            fs.existsSync(path.join(templateDir, 'src', 'view.ts')) ||
-            fs.existsSync(path.join(templateDir, 'src', 'view.tsx')) ||
-            fs.existsSync(path.join(templateDir, 'src', 'interactivity.js')) ||
-            fs.existsSync(path.join(templateDir, 'src', 'interactivity.ts'));
+            (await Promise.all([
+                'view.js',
+                'view.jsx',
+                'view.ts',
+                'view.tsx',
+                'interactivity.js',
+                'interactivity.ts',
+            ].map((filename) => pathExists(path.join(templateDir, 'src', filename))))).some(Boolean);
         await patchRemotePackageJson(templateDir, needsInteractivity);
         return {
             id: 'remote:create-block-subset',

package/dist/runtime/template-source.js

@@ -1,7 +1,7 @@
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from './template-registry.js';
 import { resolveBuiltInTemplateSource } from './template-builtins.js';
 import { parseTemplateLocator, } from './template-source-locators.js';
-import { detectTemplateSourceFormat, getTemplateProjectType, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
+import { detectTemplateSourceFormat, getTemplateProjectTypeAsync, getDefaultCategoryAsync, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
 import { isOfficialWorkspaceTemplateSeed, resolveTemplateSeed, } from './template-source-seeds.js';
 import { assertBuiltInTemplateVariantAllowed, } from './cli-validation.js';
 import { getScaffoldTemplateVariableGroups } from './scaffold-template-variable-groups.js';
@@ -36,10 +36,10 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
             }
             normalizedSeed = await normalizeWpTypiaTemplateSeed(seed);
-            const supportsMigrationUi = getTemplateProjectType(seed.blockDir) === 'workspace';
+            const supportsMigrationUi = (await getTemplateProjectTypeAsync(seed.blockDir)) === 'workspace';
             return {
                 id: templateId,
-                defaultCategory: getDefaultCategory(seed.blockDir),
+                defaultCategory: await getDefaultCategoryAsync(seed.blockDir),
                 description: 'A remote wp-typia template source',
                 features: ['Remote source', 'wp-typia format'],
                 format,
@@ -62,28 +62,38 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 (await detectTemplateSourceFormat(normalizedSeed.blockDir));
             if (renderedFormat === 'wp-typia') {
                 const normalized = await normalizeWpTypiaTemplateSeed(normalizedSeed);
-                const supportsMigrationUi = getTemplateProjectType(normalizedSeed.blockDir) === 'workspace';
-                return {
-                    cleanup: async () => {
-                        await normalized.cleanup?.();
-                        await seed.cleanup?.();
-                    },
-                    defaultCategory: getDefaultCategory(normalizedSeed.blockDir),
-                    description: 'A wp-typia scaffold normalized from an official external template config',
-                    features: [
-                        'Remote source',
-                        'official external template',
-                        'wp-typia format',
-                        ...(supportsMigrationUi ? ['workspace-capable scaffold'] : []),
-                    ],
-                    format,
-                    id: 'remote:create-block-external',
-                    isOfficialWorkspaceTemplate,
-                    selectedVariant: normalizedSeed.selectedVariant ?? null,
-                    supportsMigrationUi,
-                    templateDir: normalized.blockDir,
-                    warnings: normalizedSeed.warnings ?? [],
-                };
+                try {
+                    const [projectType, defaultCategory] = await Promise.all([
+                        getTemplateProjectTypeAsync(normalizedSeed.blockDir),
+                        getDefaultCategoryAsync(normalizedSeed.blockDir),
+                    ]);
+                    const supportsMigrationUi = projectType === 'workspace';
+                    return {
+                        cleanup: async () => {
+                            await normalized.cleanup?.();
+                            await seed.cleanup?.();
+                        },
+                        defaultCategory,
+                        description: 'A wp-typia scaffold normalized from an official external template config',
+                        features: [
+                            'Remote source',
+                            'official external template',
+                            'wp-typia format',
+                            ...(supportsMigrationUi ? ['workspace-capable scaffold'] : []),
+                        ],
+                        format,
+                        id: 'remote:create-block-external',
+                        isOfficialWorkspaceTemplate,
+                        selectedVariant: normalizedSeed.selectedVariant ?? null,
+                        supportsMigrationUi,
+                        templateDir: normalized.blockDir,
+                        warnings: normalizedSeed.warnings ?? [],
+                    };
+                }
+                catch (error) {
+                    await normalized.cleanup?.();
+                    throw error;
+                }
             }
             const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
             return {

package/dist/runtime/typia-llm.js

@@ -164,6 +164,13 @@ function collectOpenApiSeenReferences(schema, seenReferences) {
     }
     return new Set([...seenReferences, reference]);
 }
+/**
+ * Copy constraint-oriented JSON Schema keywords from `source` into `target`.
+ *
+ * This helper intentionally mutates and returns `target` so nested OpenAPI
+ * constraint restoration can preserve the projected typia.llm schema shape.
+ * Callers that need immutable behavior should clone the target before calling.
+ */
 function mergeJsonSchemaConstraintProperties(document, target, source, seenReferences = new Set()) {
     const nextSeenReferences = collectOpenApiSeenReferences(source, seenReferences);
     const resolvedSource = resolveOpenApiSchemaObject(document, source, seenReferences);

package/dist/runtime/version-floor.js

@@ -46,10 +46,16 @@ export function compareVersionFloors(left, right) {
  * @returns The higher defined floor, or undefined when neither value exists.
  */
 export function pickHigherVersionFloor(current, candidate) {
-    if (!candidate) {
+    if (current !== undefined) {
+        parseVersionFloorParts(current);
+    }
+    if (candidate !== undefined) {
+        parseVersionFloorParts(candidate);
+    }
+    if (candidate === undefined) {
         return current;
     }
-    if (!current) {
+    if (current === undefined) {
         return candidate;
     }
     return compareVersionFloors(current, candidate) >= 0 ? current : candidate;

package/dist/runtime/workspace-inventory.d.ts

@@ -156,6 +156,20 @@ export declare const ADMIN_VIEW_CONFIG_ENTRY_MARKER = "\t// wp-typia add admin-v
  * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
  */
 export declare const EDITOR_PLUGIN_CONFIG_ENTRY_MARKER = "\t// wp-typia add editor-plugin entries";
+type WorkspaceInventoryUpdateOptions = {
+    abilityEntries?: string[];
+    adminViewEntries?: string[];
+    aiFeatureEntries?: string[];
+    blockEntries?: string[];
+    blockStyleEntries?: string[];
+    blockTransformEntries?: string[];
+    bindingSourceEntries?: string[];
+    editorPluginEntries?: string[];
+    patternEntries?: string[];
+    restResourceEntries?: string[];
+    transformSource?: (source: string) => string;
+    variationEntries?: string[];
+};
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *
@@ -199,20 +213,7 @@ export declare function getWorkspaceBlockSelectOptions(projectDir: string): Arra
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export declare function updateWorkspaceInventorySource(source: string, { blockEntries, blockStyleEntries, blockTransformEntries, bindingSourceEntries, abilityEntries, adminViewEntries, aiFeatureEntries, editorPluginEntries, patternEntries, restResourceEntries, variationEntries, transformSource, }?: {
-    abilityEntries?: string[];
-    adminViewEntries?: string[];
-    aiFeatureEntries?: string[];
-    blockEntries?: string[];
-    blockStyleEntries?: string[];
-    blockTransformEntries?: string[];
-    bindingSourceEntries?: string[];
-    editorPluginEntries?: string[];
-    patternEntries?: string[];
-    restResourceEntries?: string[];
-    transformSource?: (source: string) => string;
-    variationEntries?: string[];
-}): string;
+export declare function updateWorkspaceInventorySource(source: string, options?: WorkspaceInventoryUpdateOptions): string;
 /**
  * Append new entries to the canonical workspace inventory file on disk.
  *
@@ -222,3 +223,4 @@ export declare function updateWorkspaceInventorySource(source: string, { blockEn
  * @returns Resolves once `scripts/block-config.ts` has been updated if needed.
  */
 export declare function appendWorkspaceInventoryEntries(projectDir: string, options: Parameters<typeof updateWorkspaceInventorySource>[1]): Promise<void>;
+export {};