@wp-typia/project-tools 0.24.4 → 0.24.6

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

@@ -1,494 +1 @@
-import fs from 'node:fs';
-import { promises as fsp } from 'node:fs';
-import path from 'node:path';
-import { assertExternalTemplateFileSize, getExternalTemplatePackageJsonMaxBytes, } from './external-template-guards.js';
-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';
-import { readJsonFile, readJsonFileSync, safeJsonParse, } from './json-utils.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
-        ? blockJson.category.trim()
-        : 'widgets';
-}
-function readRemoteBlockJson(blockDir) {
-    const sourceRoot = fs.existsSync(path.join(blockDir, 'src'))
-        ? path.join(blockDir, 'src')
-        : blockDir;
-    for (const candidate of [
-        path.join(blockDir, 'block.json'),
-        path.join(sourceRoot, 'block.json'),
-    ]) {
-        if (fs.existsSync(candidate)) {
-            return readJsonFileSync(candidate, {
-                context: 'remote block metadata',
-            });
-        }
-    }
-    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 readJsonFile(candidate, {
-                context: 'remote block metadata',
-            });
-        }
-    }
-    throw new Error(`Unable to locate block.json in ${blockDir}`);
-}
-/**
- * Read a remote block source and return its default block category.
- *
- * @deprecated Since 0.22.10. Use `getDefaultCategoryAsync()` from async
- * template-source paths. Removal target: not currently scheduled; this sync
- * compatibility helper remains available until release notes announce a
- * versioned target.
- *
- * @param sourceDir Block source directory that may contain a block.json file.
- * @returns The declared block category, or "widgets" when detection fails.
- */
-export function getDefaultCategory(sourceDir) {
-    try {
-        const blockJson = readRemoteBlockJson(sourceDir);
-        return getDefaultCategoryFromBlockJson(blockJson);
-    }
-    catch {
-        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'),
-        path.join(sourceDir, 'package.json'),
-    ]) {
-        if (!fs.existsSync(candidate)) {
-            continue;
-        }
-        try {
-            assertExternalTemplateFileSize(candidate, {
-                label: `Template metadata file "${candidate}"`,
-                maxBytes: getExternalTemplatePackageJsonMaxBytes(),
-            });
-            return {
-                packageJson: safeJsonParse(fs.readFileSync(candidate, 'utf8'), {
-                    context: 'template metadata file',
-                    filePath: candidate,
-                }),
-                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;
-}
-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: safeJsonParse(await fsp.readFile(candidate, 'utf8'), {
-                    context: 'template metadata file',
-                    filePath: candidate,
-                }),
-                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.
- *
- * @deprecated Since 0.22.10. Use `getTemplateProjectTypeAsync()` from async
- * template-source paths. Removal target: not currently scheduled; this sync
- * compatibility helper remains available until release notes announce a
- * versioned target.
- */
-export function getTemplateProjectType(sourceDir) {
-    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;
-}
-/**
- * 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.
- *
- * @param seed Seed source whose files should be normalized into a temp root.
- * @returns A cloned seed whose cleanup removes the temp root and original seed.
- */
-export async function normalizeWpTypiaTemplateSeed(seed) {
-    const { path: tempRoot, cleanup } = await createManagedTempRoot('wp-typia-template-source-');
-    const normalizedDir = path.join(tempRoot, 'template');
-    try {
-        await copyRawDirectory(seed.blockDir, normalizedDir, {
-            filter: async (sourcePath, _targetPath, entry) => {
-                const mustacheVariantPath = path.join(path.dirname(sourcePath), `${entry.name}.mustache`);
-                return !(entry.isFile() &&
-                    (entry.name === 'package.json' || entry.name === 'README.md') &&
-                    (await pathExists(mustacheVariantPath)));
-            },
-        });
-        if (seed.assetsDir && (await pathExists(seed.assetsDir))) {
-            await fsp.cp(seed.assetsDir, path.join(normalizedDir, 'assets'), {
-                recursive: true,
-                force: true,
-            });
-        }
-    }
-    catch (error) {
-        await Promise.allSettled([cleanup(), seed.cleanup?.()]);
-        throw error;
-    }
-    return {
-        blockDir: normalizedDir,
-        cleanup: async () => cleanupSeedRootPair(cleanup, seed.cleanup),
-        rootDir: normalizedDir,
-        selectedVariant: seed.selectedVariant,
-        warnings: seed.warnings,
-    };
-}
-function renderTypeScriptLiteral(value) {
-    if (typeof value === 'string') {
-        return JSON.stringify(value);
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-        return String(value);
-    }
-    return 'undefined';
-}
-function renderTagsForAttribute(attribute) {
-    const tags = [];
-    if (typeof attribute.default === 'string' ||
-        typeof attribute.default === 'number' ||
-        typeof attribute.default === 'boolean') {
-        tags.push(`tags.Default<${renderTypeScriptLiteral(attribute.default)}>`);
-    }
-    return tags;
-}
-function renderAttributeBaseType(attributeName, attribute) {
-    if (Array.isArray(attribute.enum) && attribute.enum.length > 0) {
-        return attribute.enum
-            .map((item) => renderTypeScriptLiteral(item))
-            .join(' | ');
-    }
-    switch (attribute.type) {
-        case 'string':
-            return 'string';
-        case 'number':
-            return 'number';
-        case 'boolean':
-            return 'boolean';
-        case 'array':
-            return 'unknown[]';
-        case 'object':
-            return 'Record<string, unknown>';
-        default:
-            if (typeof attributeName === 'string' &&
-                attributeName.toLowerCase().includes('class')) {
-                return 'string';
-            }
-            return 'unknown';
-    }
-}
-function buildRemoteTypesSource(blockJson, context) {
-    const attributes = (blockJson.attributes ?? {});
-    const lines = [
-        'import { tags } from "typia";',
-        '',
-        `export interface ${context.pascalCase}Attributes {`,
-    ];
-    for (const [name, attribute] of Object.entries(attributes)) {
-        const baseType = renderAttributeBaseType(name, attribute);
-        const tagList = renderTagsForAttribute(attribute);
-        const baseTypeWithGrouping = tagList.length > 0 && baseType.includes(' | ')
-            ? `(${baseType})`
-            : baseType;
-        const renderedType = [baseTypeWithGrouping, ...tagList].join(' & ');
-        lines.push(`  ${JSON.stringify(name)}?: ${renderedType};`);
-    }
-    lines.push('}', '');
-    return lines.join('\n');
-}
-function buildRemoteBlockJsonTemplate(blockJson) {
-    const merged = {
-        ...blockJson,
-        description: '{{description}}',
-        name: '{{namespace}}/{{slug}}',
-        textdomain: '{{textDomain}}',
-        title: '{{title}}',
-    };
-    if (!Array.isArray(merged.keywords) || merged.keywords.length === 0) {
-        merged.keywords = ['{{keyword}}', 'typia', 'block'];
-    }
-    return `${JSON.stringify(merged, null, '\t')}\n`;
-}
-async function rewriteBlockJsonImports(directory) {
-    const textExtensions = new Set(['.js', '.jsx', '.ts', '.tsx']);
-    const targetBlockJsonPath = path.join(directory, 'block.json');
-    async function visit(currentPath) {
-        const stats = await fsp.stat(currentPath);
-        if (stats.isDirectory()) {
-            const entries = await fsp.readdir(currentPath);
-            for (const entry of entries) {
-                await visit(path.join(currentPath, entry));
-            }
-            return;
-        }
-        if (!textExtensions.has(path.extname(currentPath))) {
-            return;
-        }
-        const content = await fsp.readFile(currentPath, 'utf8');
-        const relativeSpecifier = path
-            .relative(path.dirname(currentPath), targetBlockJsonPath)
-            .replace(/\\/g, '/');
-        const normalizedSpecifier = relativeSpecifier.startsWith('.')
-            ? relativeSpecifier
-            : `./${relativeSpecifier}`;
-        const next = content.replace(/(['"])\.{1,2}\/[^'"]*block\.json\1/g, `$1${normalizedSpecifier}$1`);
-        if (next !== content) {
-            await fsp.writeFile(currentPath, next, 'utf8');
-        }
-    }
-    await visit(directory);
-}
-async function patchRemotePackageJson(templateDir, needsInteractivity) {
-    const packageJsonPath = path.join(templateDir, 'package.json.mustache');
-    const packageJson = await readJsonFile(packageJsonPath, {
-        context: 'remote package template manifest',
-    });
-    const existingDependencies = { ...(packageJson.dependencies ?? {}) };
-    const existingDevDependencies = { ...(packageJson.devDependencies ?? {}) };
-    delete existingDependencies['@wp-typia/project-tools'];
-    delete existingDevDependencies['@wp-typia/project-tools'];
-    packageJson.devDependencies = {
-        '@wp-typia/block-runtime': '{{blockRuntimePackageVersion}}',
-        '@wp-typia/block-types': '{{blockTypesPackageVersion}}',
-        ...existingDevDependencies,
-    };
-    if (needsInteractivity) {
-        packageJson.dependencies = {
-            ...existingDependencies,
-            '@wordpress/interactivity': '^6.29.0',
-        };
-    }
-    else if (Object.keys(existingDependencies).length > 0) {
-        packageJson.dependencies = existingDependencies;
-    }
-    else {
-        delete packageJson.dependencies;
-    }
-    await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
-}
-async function getSeedSourceRoot(blockDir) {
-    return (await pathExists(path.join(blockDir, 'src')))
-        ? path.join(blockDir, 'src')
-        : blockDir;
-}
-async function findSeedRenderPhp(seed) {
-    for (const candidate of [
-        path.join(seed.blockDir, 'render.php'),
-        path.join(seed.rootDir, 'render.php'),
-    ]) {
-        if (await pathExists(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-async function removeSeedEntryConflicts(templateDir) {
-    for (const filename of [
-        'block.json',
-        'block.json.mustache',
-        'edit.js',
-        'edit.jsx',
-        'edit.ts',
-        'edit.tsx',
-        'edit.tsx.mustache',
-        'hooks.ts',
-        'hooks.ts.mustache',
-        'index.js',
-        'index.jsx',
-        'index.ts',
-        'index.tsx',
-        'index.tsx.mustache',
-        'save.js',
-        'save.jsx',
-        'save.ts',
-        'save.tsx',
-        'save.tsx.mustache',
-        'style.css',
-        'style.scss',
-        'style.scss.mustache',
-        'types.ts',
-        'types.ts.mustache',
-        'validators.ts',
-        'validators.ts.mustache',
-        'view.js',
-        'view.jsx',
-        'view.ts',
-        'view.tsx',
-    ]) {
-        await fsp.rm(path.join(templateDir, 'src', filename), { force: true });
-    }
-}
-/**
- * Convert a create-block subset seed into a normalized wp-typia template source.
- *
- * @param seed Seed source produced from a remote create-block subset.
- * @param context Template variable context used for generated artifacts.
- * @returns A normalized template source rooted in a temporary directory.
- */
-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 = await readRemoteBlockJsonAsync(seed.blockDir);
-        const sourceRoot = await getSeedSourceRoot(seed.blockDir);
-        await fsp.mkdir(templateDir, { recursive: true });
-        for (const layerDir of getBuiltInTemplateLayerDirs('basic')) {
-            if (!(await pathExists(layerDir))) {
-                if (isOmittableBuiltInTemplateLayerDir('basic', layerDir)) {
-                    continue;
-                }
-                throw new Error(`Built-in template layer is missing: ${layerDir}`);
-            }
-            await fsp.cp(layerDir, templateDir, {
-                recursive: true,
-                force: true,
-            });
-        }
-        await removeSeedEntryConflicts(templateDir);
-        await fsp.cp(sourceRoot, path.join(templateDir, 'src'), {
-            recursive: true,
-            force: true,
-        });
-        const remoteRenderPath = await findSeedRenderPhp(seed);
-        if (remoteRenderPath) {
-            await fsp.copyFile(remoteRenderPath, path.join(templateDir, 'render.php'));
-        }
-        if (seed.assetsDir && (await pathExists(seed.assetsDir))) {
-            await fsp.cp(seed.assetsDir, path.join(templateDir, 'assets'), {
-                recursive: true,
-                force: true,
-            });
-        }
-        await fsp.writeFile(path.join(templateDir, 'src', 'types.ts'), buildRemoteTypesSource(blockJson, context), 'utf8');
-        await fsp.writeFile(path.join(templateDir, 'src', 'block.json'), buildRemoteBlockJsonTemplate(blockJson), 'utf8');
-        await rewriteBlockJsonImports(path.join(templateDir, 'src'));
-        const needsInteractivity = typeof blockJson.viewScriptModule === 'string' ||
-            typeof blockJson.viewScript === 'string' ||
-            (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',
-            defaultCategory: getDefaultCategoryFromBlockJson(blockJson),
-            description: 'A wp-typia scaffold normalized from a create-block subset source',
-            features: [
-                'Remote source',
-                'create-block adapter',
-                'Typia metadata pipeline',
-            ],
-            format: 'create-block-subset',
-            selectedVariant: seed.selectedVariant ?? null,
-            templateDir,
-            warnings: seed.warnings ?? [],
-            cleanup: async () => cleanupSeedRootPair(cleanup, seed.cleanup),
-        };
-    }
-    catch (error) {
-        await Promise.allSettled([cleanup(), seed.cleanup?.()]);
-        throw error;
-    }
-}
+export * from "./templates/template-source-remote.js";

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

@@ -1,25 +1 @@
-import type { RemoteTemplateLocator, SeedSource } from './template-source-contracts.js';
-/**
- * Synchronously identify the bundled workspace template seed.
- *
- * This remains sync-only for compatibility callers. Async template resolution
- * paths should use `isOfficialWorkspaceTemplateSeedAsync()`.
- */
-export declare function isOfficialWorkspaceTemplateSeed(seed: SeedSource): boolean;
-/**
- * Asynchronously identify the bundled workspace template seed.
- *
- * @param seed Seed source to inspect.
- * @returns Whether the seed resolves to the official workspace template package.
- */
-export declare function isOfficialWorkspaceTemplateSeedAsync(seed: SeedSource): Promise<boolean>;
-export declare function assertNoSymlinks(sourceDir: string): Promise<void>;
-/**
- * Resolves a template locator into a local seed source directory.
- *
- * @param locator Remote template locator describing a local path, GitHub source, or npm package.
- * @param cwd Current working directory used to resolve local template paths.
- * @returns A local seed source containing the resolved root and block directory, plus optional cleanup.
- * @throws When the locator is invalid, the source cannot be fetched, or filesystem validation fails.
- */
-export declare function resolveTemplateSeed(locator: RemoteTemplateLocator, cwd: string): Promise<SeedSource>;
+export * from "./templates/template-source-seeds.js";