@wp-typia/project-tools 0.19.0 → 0.19.1

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

@@ -1,11 +1,10 @@
 /// <reference path="./external-template-modules.d.ts" />
 import fs from 'node:fs';
-import { promises as fsp } from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { isPlainObject } from './object-utils.js';
 import { toSegmentPascalCase } from './string-case.js';
+import { createManagedTempRoot } from './temp-roots.js';
 import { copyRawDirectory, copyRenderedDirectory } from './template-render.js';
 /**
  * Candidate filenames for official external template config entrypoints.
@@ -15,6 +14,7 @@ export const EXTERNAL_TEMPLATE_ENTRY_CANDIDATES = [
     'index.cjs',
     'index.mjs',
 ];
+export const EXTERNAL_TEMPLATE_TRUST_WARNING = 'External template configs execute trusted JavaScript during scaffolding. Review the template source before using local paths, GitHub repos, or npm packages you do not already trust.';
 const TEMPLATE_WARNING_MESSAGE = 'wp-typia owns package/tooling/sync setup for generated projects, so this external template setting is ignored.';
 function getTemplateWarning(key) {
     return `Ignoring external template config key "${key}": ${TEMPLATE_WARNING_MESSAGE}`;
@@ -53,7 +53,7 @@ async function loadExternalTemplateConfig(sourceDir) {
     if (!isPlainObject(loadedConfig)) {
         throw new Error(`External template config must export an object: ${entryPath}`);
     }
-    const warnings = [];
+    const warnings = [EXTERNAL_TEMPLATE_TRUST_WARNING];
     for (const ignoredKey of [
         'wpScripts',
         'wpEnv',
@@ -174,10 +174,7 @@ export async function renderCreateBlockExternalTemplate(sourceDir, context, requ
     const { config, warnings } = await loadExternalTemplateConfig(sourceDir);
     const { selectedVariant, variantConfig } = getVariantConfig(config, requestedVariant);
     const { folderName, formatHint, templatePath } = resolveConfiguredTemplatePath(config, variantConfig);
-    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-create-block-external-'));
-    const cleanup = async () => {
-        await fsp.rm(tempRoot, { force: true, recursive: true });
-    };
+    const { path: tempRoot, cleanup } = await createManagedTempRoot('wp-typia-create-block-external-');
     try {
         const renderedRoot = path.join(tempRoot, 'rendered');
         const blockDir = resolveSourceSubpath(renderedRoot, folderName);

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

@@ -1,9 +1,27 @@
 import fs from 'node:fs';
 import { promises as fsp } from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { getBuiltInTemplateLayerDirs, isOmittableBuiltInTemplateLayerDir, } from './template-builtins.js';
 import { copyRawDirectory } from './template-render.js';
+import { createManagedTempRoot } from './temp-roots.js';
+async function cleanupSeedRootPair(cleanup, seedCleanup) {
+    let cleanupError;
+    try {
+        await cleanup();
+    }
+    catch (error) {
+        cleanupError = error;
+    }
+    try {
+        await seedCleanup?.();
+    }
+    catch (error) {
+        cleanupError ?? (cleanupError = error);
+    }
+    if (cleanupError !== undefined) {
+        throw cleanupError;
+    }
+}
 function getDefaultCategoryFromBlockJson(blockJson) {
     return typeof blockJson.category === 'string' &&
         blockJson.category.trim().length > 0
@@ -48,10 +66,14 @@ function readTemplatePackageJson(sourceDir) {
             continue;
         }
         try {
-            return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+            return {
+                packageJson: JSON.parse(fs.readFileSync(candidate, 'utf8')),
+                sourcePath: candidate,
+            };
         }
-        catch {
-            continue;
+        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;
@@ -61,10 +83,18 @@ function readTemplatePackageJson(sourceDir) {
  * manifest and return it when present.
  */
 export function getTemplateProjectType(sourceDir) {
-    const packageJson = readTemplatePackageJson(sourceDir);
-    return typeof packageJson?.wpTypia?.projectType === 'string'
-        ? packageJson.wpTypia.projectType
-        : null;
+    const packageJsonEntry = readTemplatePackageJson(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.
@@ -73,7 +103,7 @@ export function getTemplateProjectType(sourceDir) {
  * @returns A cloned seed whose cleanup removes the temp root and original seed.
  */
 export async function normalizeWpTypiaTemplateSeed(seed) {
-    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-template-source-'));
+    const { path: tempRoot, cleanup } = await createManagedTempRoot('wp-typia-template-source-');
     const normalizedDir = path.join(tempRoot, 'template');
     try {
         await copyRawDirectory(seed.blockDir, normalizedDir, {
@@ -92,15 +122,12 @@ export async function normalizeWpTypiaTemplateSeed(seed) {
         }
     }
     catch (error) {
-        await fsp.rm(tempRoot, { force: true, recursive: true });
+        await Promise.allSettled([cleanup(), seed.cleanup?.()]);
         throw error;
     }
     return {
         blockDir: normalizedDir,
-        cleanup: async () => {
-            await fsp.rm(tempRoot, { force: true, recursive: true });
-            await seed.cleanup?.();
-        },
+        cleanup: async () => cleanupSeedRootPair(cleanup, seed.cleanup),
         rootDir: normalizedDir,
         selectedVariant: seed.selectedVariant,
         warnings: seed.warnings,
@@ -296,7 +323,7 @@ async function removeSeedEntryConflicts(templateDir) {
  * @returns A normalized template source rooted in a temporary directory.
  */
 export async function normalizeCreateBlockSubset(seed, context) {
-    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-remote-template-'));
+    const { path: tempRoot, cleanup } = await createManagedTempRoot('wp-typia-remote-template-');
     try {
         const templateDir = path.join(tempRoot, 'template');
         const blockJson = readRemoteBlockJson(seed.blockDir);
@@ -353,17 +380,11 @@ export async function normalizeCreateBlockSubset(seed, context) {
             selectedVariant: seed.selectedVariant ?? null,
             templateDir,
             warnings: seed.warnings ?? [],
-            cleanup: async () => {
-                await fsp.rm(tempRoot, { force: true, recursive: true });
-                if (seed.cleanup) {
-                    await seed.cleanup();
-                }
-            },
+            cleanup: async () => cleanupSeedRootPair(cleanup, seed.cleanup),
         };
     }
     catch (error) {
-        await fsp.rm(tempRoot, { force: true, recursive: true });
-        await seed.cleanup?.();
+        await Promise.allSettled([cleanup(), seed.cleanup?.()]);
         throw error;
     }
 }

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

@@ -1,13 +1,13 @@
 import fs from 'node:fs';
 import { promises as fsp } from 'node:fs';
 import { createRequire } from 'node:module';
-import os from 'node:os';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import semver from 'semver';
 import { x as extractTarball } from 'tar';
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, PROJECT_TOOLS_PACKAGE_ROOT, } from './template-registry.js';
 import { isPlainObject } from './object-utils.js';
+import { createManagedTempRoot } from './temp-roots.js';
 function selectRegistryVersion(metadata, locator) {
     const distTags = isPlainObject(metadata['dist-tags'])
         ? metadata['dist-tags']
@@ -58,10 +58,7 @@ async function fetchNpmTemplateSource(locator) {
     if (typeof tarballUrl !== 'string' || tarballUrl.length === 0) {
         throw new Error(`npm template metadata is missing tarball URL for ${locator.raw}@${resolvedVersion}.`);
     }
-    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-template-source-'));
-    const cleanup = async () => {
-        await fsp.rm(tempRoot, { force: true, recursive: true });
-    };
+    const { path: tempRoot, cleanup } = await createManagedTempRoot('wp-typia-template-source-');
     try {
         const tarballResponse = await fetch(tarballUrl);
         if (!tarballResponse.ok) {
@@ -178,10 +175,7 @@ export async function assertNoSymlinks(sourceDir) {
     }
 }
 async function resolveGitHubTemplateSource(locator) {
-    const remoteRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-template-source-'));
-    const cleanup = async () => {
-        await fsp.rm(remoteRoot, { force: true, recursive: true });
-    };
+    const { path: remoteRoot, cleanup } = await createManagedTempRoot('wp-typia-template-source-');
     const checkoutDir = path.join(remoteRoot, 'source');
     try {
         const args = ['clone', '--depth', '1'];

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

@@ -1,7 +1,6 @@
 import type { ResolvedTemplateSource } from './template-source-contracts.js';
+import type { ScaffoldTemplateVariables } from './scaffold.js';
 export type { GitHubTemplateLocator, NpmTemplateLocator, RemoteTemplateLocator, ResolvedTemplateSource, TemplateSourceFormat, TemplateVariableContext, } from './template-source-contracts.js';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
 export { resolveTemplateSeed } from './template-source-seeds.js';
-export declare function resolveTemplateSource(templateId: string, cwd: string, variables: {
-    [key: string]: string;
-}, variant?: string): Promise<ResolvedTemplateSource>;
+export declare function resolveTemplateSource(templateId: string, cwd: string, variables: ScaffoldTemplateVariables, variant?: string): Promise<ResolvedTemplateSource>;

package/dist/runtime/template-source.js

@@ -4,17 +4,23 @@ import { parseTemplateLocator, } from './template-source-locators.js';
 import { detectTemplateSourceFormat, getTemplateProjectType, getDefaultCategory, 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';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
 export { resolveTemplateSeed } from './template-source-seeds.js';
 export async function resolveTemplateSource(templateId, cwd, variables, variant) {
     if (isBuiltInTemplateId(templateId)) {
+        const variableGroups = getScaffoldTemplateVariableGroups(variables);
         assertBuiltInTemplateVariantAllowed({
             templateId,
             variant,
         });
         return resolveBuiltInTemplateSource(templateId, {
-            persistenceEnabled: variables.compoundPersistenceEnabled === 'true',
-            persistencePolicy: variables.persistencePolicy === 'public' ? 'public' : 'authenticated',
+            persistenceEnabled: variableGroups.compound.enabled &&
+                variableGroups.compound.persistenceEnabled,
+            persistencePolicy: variableGroups.persistence.enabled &&
+                variableGroups.persistence.policy === 'public'
+                ? 'public'
+                : 'authenticated',
         });
     }
     const locator = parseTemplateLocator(templateId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -67,6 +67,11 @@
       "import": "./dist/runtime/schema-core.js",
       "default": "./dist/runtime/schema-core.js"
     },
+    "./temp-roots": {
+      "types": "./dist/runtime/temp-roots.d.ts",
+      "import": "./dist/runtime/temp-roots.js",
+      "default": "./dist/runtime/temp-roots.js"
+    },
     "./workspace-project": {
       "types": "./dist/runtime/workspace-project.d.ts",
       "import": "./dist/runtime/workspace-project.js",