@wp-typia/project-tools 0.15.1 → 0.15.3

package/dist/runtime/cli-add.js

@@ -643,8 +643,103 @@ async function renderWorkspacePersistenceServerModule(projectDir, variables) {
     const templateDir = buildServerTemplateRoot(variables.persistencePolicy);
     await copyInterpolatedDirectory(templateDir, targetDir, variables);
 }
-async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir, variables) {
+const COMPOUND_SHARED_SUPPORT_FILES = ["hooks.ts", "validator-toolkit.ts"];
+const LEGACY_ASSERT_PATTERN = /assert:\s*typia\.createAssert</u;
+const LEGACY_MANIFEST_PATTERN = /\r?\n[ \t]*manifest:\s*currentManifest,/u;
+const LEGACY_TOOLKIT_CALL_PATTERN = /createTemplateValidatorToolkit<\s*(?<typeName>[A-Za-z0-9_]+)\s*>\s*\(\s*\{/u;
+const LEGACY_VALIDATOR_TOOLKIT_IMPORT_PATTERN = /from\s*["']\.\.\/\.\.\/validator-toolkit["']/u;
+const COMPATIBLE_COMPOUND_TOOLKIT_PATTERNS = [
+    /interface\s+TemplateValidatorFunctions\s*<\s*T\s+extends\s+object\s*>\s*\{/u,
+    /\bassert\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']assert["']\s*\]/u,
+    /\bclone\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']clone["']\s*\]/u,
+    /\bis\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']is["']\s*\]/u,
+    /\bprune\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']prune["']\s*\]/u,
+    /\brandom\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']random["']\s*\]/u,
+    /\bvalidate\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']validate["']\s*\]/u,
+    /createTemplateValidatorToolkit\s*<\s*T\s+extends\s+object\s*>\s*\(\s*\{/u,
+];
+function shouldRefreshCompoundValidatorToolkit(source) {
+    return (source === null ||
+        !COMPATIBLE_COMPOUND_TOOLKIT_PATTERNS.every((pattern) => pattern.test(source)));
+}
+function isLegacyCompoundValidatorSource(source) {
+    return (typeof source === "string" &&
+        LEGACY_VALIDATOR_TOOLKIT_IMPORT_PATTERN.test(source) &&
+        !LEGACY_ASSERT_PATTERN.test(source));
+}
+function upgradeLegacyCompoundValidatorSource(source) {
+    const typeNameMatch = source.match(LEGACY_TOOLKIT_CALL_PATTERN);
+    const typeName = typeNameMatch?.groups?.typeName;
+    if (!typeName) {
+        throw new Error("Unable to upgrade a legacy compound validator without a generated type import.");
+    }
+    let nextSource = source;
+    if (!nextSource.includes("import typia from 'typia';")) {
+        nextSource = `import typia from 'typia';\n${nextSource}`;
+    }
+    nextSource = nextSource.replace(LEGACY_TOOLKIT_CALL_PATTERN, [
+        `createTemplateValidatorToolkit< ${typeName} >( {`,
+        `\tassert: typia.createAssert< ${typeName} >(),`,
+        `\tclone: typia.misc.createClone< ${typeName} >() as (`,
+        `\t\tvalue: ${typeName},`,
+        `\t) => ${typeName},`,
+        `\tis: typia.createIs< ${typeName} >(),`,
+    ].join("\n") + "\n");
+    const replacedManifest = nextSource.replace(LEGACY_MANIFEST_PATTERN, [
+        "",
+        "\tmanifest: currentManifest,",
+        `\tprune: typia.misc.createPrune< ${typeName} >(),`,
+        `\trandom: typia.createRandom< ${typeName} >() as (`,
+        "\t\t...args: unknown[]",
+        `\t) => ${typeName},`,
+        `\tvalidate: typia.createValidate< ${typeName} >(),`,
+    ].join("\n"));
+    if (replacedManifest === nextSource) {
+        throw new Error("Unable to upgrade legacy compound validator: manifest anchor not found.");
+    }
+    return replacedManifest;
+}
+async function collectLegacyCompoundValidatorPaths(projectDir) {
+    const blocksDir = path.join(projectDir, "src", "blocks");
+    if (!fs.existsSync(blocksDir)) {
+        return [];
+    }
+    const blockEntries = await fsp.readdir(blocksDir, { withFileTypes: true });
+    const validatorPaths = await Promise.all(blockEntries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+        const validatorPath = path.join(blocksDir, entry.name, "validators.ts");
+        const validatorSource = await readOptionalFile(validatorPath);
+        return isLegacyCompoundValidatorSource(validatorSource) ? validatorPath : null;
+    }));
+    return validatorPaths.filter((validatorPath) => validatorPath !== null);
+}
+async function ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths) {
+    for (const fileName of COMPOUND_SHARED_SUPPORT_FILES) {
+        const sourcePath = path.join(tempProjectDir, "src", fileName);
+        if (!fs.existsSync(sourcePath)) {
+            continue;
+        }
+        const targetPath = path.join(projectDir, "src", fileName);
+        const currentSource = await readOptionalFile(targetPath);
+        if (fileName === "validator-toolkit.ts"
+            ? shouldRefreshCompoundValidatorToolkit(currentSource)
+            : currentSource === null) {
+            await fsp.mkdir(path.dirname(targetPath), { recursive: true });
+            await fsp.copyFile(sourcePath, targetPath);
+        }
+    }
+    for (const validatorPath of legacyValidatorPaths) {
+        const currentSource = await readOptionalFile(validatorPath);
+        if (!isLegacyCompoundValidatorSource(currentSource)) {
+            continue;
+        }
+        await fsp.writeFile(validatorPath, upgradeLegacyCompoundValidatorSource(currentSource), "utf8");
+    }
+}
+async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir, variables, legacyValidatorPaths = []) {
     if (templateId === "compound") {
+        await ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths);
         await copyTempDirectory(path.join(tempProjectDir, "src", "blocks", variables.slugKebabCase), path.join(projectDir, "src", "blocks", variables.slugKebabCase));
         await copyTempDirectory(path.join(tempProjectDir, "src", "blocks", `${variables.slugKebabCase}-item`), path.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`));
         if (variables.compoundPersistenceEnabled === "true") {
@@ -809,6 +904,12 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
         const blockPhpPrefix = buildWorkspacePhpPrefix(workspace.workspace.phpPrefix, normalizedSlug);
         const migrationConfigSource = await readOptionalFile(migrationConfigPath);
         const migrationConfig = migrationConfigSource === null ? null : parseMigrationConfig(migrationConfigSource);
+        const compoundSupportPaths = resolvedTemplateId === "compound"
+            ? COMPOUND_SHARED_SUPPORT_FILES.map((fileName) => path.join(workspace.projectDir, "src", fileName))
+            : [];
+        const legacyCompoundValidatorPaths = resolvedTemplateId === "compound"
+            ? await collectLegacyCompoundValidatorPaths(workspace.projectDir)
+            : [];
         const result = await scaffoldProject({
             answers: {
                 ...defaults,
@@ -829,14 +930,19 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
         });
         assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
         const mutationSnapshot = {
-            fileSources: await snapshotWorkspaceFiles([blockConfigPath, migrationConfigPath]),
+            fileSources: await snapshotWorkspaceFiles([
+                blockConfigPath,
+                migrationConfigPath,
+                ...compoundSupportPaths,
+                ...legacyCompoundValidatorPaths,
+            ]),
             snapshotDirs: migrationConfig === null
                 ? []
                 : buildMigrationBlocks(resolvedTemplateId, result.variables).map((block) => path.join(workspace.projectDir, ...migrationConfig.snapshotDir.split("/"), migrationConfig.currentMigrationVersion, block.key)),
             targetPaths: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables),
         };
         try {
-            await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables);
+            await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables, legacyCompoundValidatorPaths);
             await addCollectionImportsForTemplate(workspace.projectDir, resolvedTemplateId, result.variables);
             await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" ||
                 (resolvedTemplateId === "compound" &&

package/dist/runtime/json-utils.d.ts

@@ -1,10 +1,7 @@
 /**
- * Create a deep clone of a JSON-serializable value.
- *
- * @param value JSON-compatible data to clone.
- * @returns A deep-cloned copy created with `JSON.parse(JSON.stringify(...))`.
- *
- * Values that are not JSON-serializable, such as functions, `undefined`,
- * `BigInt`, class instances, and `Date` objects, are not preserved faithfully.
+ * Re-exports JSON cloning helpers from `@wp-typia/block-runtime`.
+ * This adapter keeps the existing project-tools module path stable while the
+ * runtime implementation now lives in block-runtime.
+ * @module
  */
-export declare function cloneJsonValue<T>(value: T): T;
+export * from "@wp-typia/block-runtime/json-utils";

package/dist/runtime/json-utils.js

@@ -1,12 +1,7 @@
 /**
- * Create a deep clone of a JSON-serializable value.
- *
- * @param value JSON-compatible data to clone.
- * @returns A deep-cloned copy created with `JSON.parse(JSON.stringify(...))`.
- *
- * Values that are not JSON-serializable, such as functions, `undefined`,
- * `BigInt`, class instances, and `Date` objects, are not preserved faithfully.
+ * Re-exports JSON cloning helpers from `@wp-typia/block-runtime`.
+ * This adapter keeps the existing project-tools module path stable while the
+ * runtime implementation now lives in block-runtime.
+ * @module
  */
-export function cloneJsonValue(value) {
-    return JSON.parse(JSON.stringify(value));
-}
+export * from "@wp-typia/block-runtime/json-utils";

package/dist/runtime/metadata-analysis.d.ts

@@ -1,11 +1,7 @@
-import ts from "typescript";
-export interface AnalysisContext {
-    allowedExternalPackages: Set<string>;
-    checker: ts.TypeChecker;
-    packageNameCache: Map<string, string | null>;
-    projectRoot: string;
-    program: ts.Program;
-    recursionGuard: Set<string>;
-}
-export declare function getTaggedSyncBlockMetadataFailureCode(error: Error): "typescript-diagnostic" | undefined;
-export declare function createAnalysisContext(projectRoot: string, typesFilePath: string): AnalysisContext;
+/**
+ * Re-exports metadata analysis helpers from `@wp-typia/block-runtime`.
+ * This adapter preserves the public project-tools module path while sharing
+ * the runtime implementation with block-runtime.
+ * @module
+ */
+export * from "@wp-typia/block-runtime/metadata-analysis";

package/dist/runtime/metadata-analysis.js

@@ -1,285 +1,7 @@
-import { createHash } from "node:crypto";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-class LruCache {
-    constructor(maxEntries) {
-        this.maxEntries = maxEntries;
-        this.entries = new Map();
-    }
-    get(key) {
-        const value = this.entries.get(key);
-        if (value === undefined) {
-            return undefined;
-        }
-        this.entries.delete(key);
-        this.entries.set(key, value);
-        return value;
-    }
-    set(key, value) {
-        if (this.entries.has(key)) {
-            this.entries.delete(key);
-        }
-        this.entries.set(key, value);
-        if (this.entries.size <= this.maxEntries) {
-            return;
-        }
-        const oldestKey = this.entries.keys().next().value;
-        if (oldestKey !== undefined) {
-            this.entries.delete(oldestKey);
-        }
-    }
-}
-const DEFAULT_ALLOWED_EXTERNAL_PACKAGES = ["@wp-typia/block-types"];
-const ANALYSIS_PROGRAM_CACHE_MAX_ENTRIES = 20;
-const TYPESCRIPT_LIB_DIRECTORY = path.dirname(ts.getDefaultLibFilePath({}));
-const RUNTIME_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
-const SYNC_BLOCK_METADATA_FAILURE_CODE = Symbol("sync-block-metadata-failure-code");
-const analysisProgramCache = new LruCache(ANALYSIS_PROGRAM_CACHE_MAX_ENTRIES);
-function tagMetadataDiagnosticError(error) {
-    error[SYNC_BLOCK_METADATA_FAILURE_CODE] = "typescript-diagnostic";
-    return error;
-}
-export function getTaggedSyncBlockMetadataFailureCode(error) {
-    return error[SYNC_BLOCK_METADATA_FAILURE_CODE];
-}
-function isProjectLocalSourceFile(filePath, projectRoot) {
-    if (filePath.startsWith(TYPESCRIPT_LIB_DIRECTORY)) {
-        return false;
-    }
-    if (filePath.includes(`${path.sep}node_modules${path.sep}`)) {
-        return false;
-    }
-    return !path.relative(projectRoot, filePath).startsWith("..");
-}
-function collectSourceFileModuleSpecifiers(sourceFile) {
-    const moduleSpecifiers = [];
-    for (const statement of sourceFile.statements) {
-        if ((ts.isImportDeclaration(statement) ||
-            ts.isExportDeclaration(statement)) &&
-            statement.moduleSpecifier &&
-            ts.isStringLiteralLike(statement.moduleSpecifier)) {
-            moduleSpecifiers.push(statement.moduleSpecifier.text);
-        }
-    }
-    ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportTypeNode(node) &&
-            ts.isLiteralTypeNode(node.argument) &&
-            ts.isStringLiteral(node.argument.literal)) {
-            moduleSpecifiers.push(node.argument.literal.text);
-        }
-    });
-    return moduleSpecifiers;
-}
-function collectReferencedLocalSourceFiles(program, entryFilePath, compilerOptions, projectRoot) {
-    const visited = new Set();
-    const queue = [entryFilePath];
-    while (queue.length > 0) {
-        const filePath = queue.pop();
-        if (filePath === undefined ||
-            visited.has(filePath) ||
-            !isProjectLocalSourceFile(filePath, projectRoot)) {
-            continue;
-        }
-        visited.add(filePath);
-        const sourceFile = program.getSourceFile(filePath);
-        if (sourceFile === undefined) {
-            continue;
-        }
-        for (const moduleSpecifier of collectSourceFileModuleSpecifiers(sourceFile)) {
-            const resolved = ts.resolveModuleName(moduleSpecifier, filePath, compilerOptions, ts.sys).resolvedModule;
-            const resolvedFileName = resolved?.resolvedFileName;
-            if (resolvedFileName &&
-                isProjectLocalSourceFile(resolvedFileName, projectRoot)) {
-                queue.push(resolvedFileName);
-            }
-        }
-    }
-    return visited;
-}
-function stableSerializeAnalysisValue(value) {
-    if (value === undefined) {
-        return '"__undefined__"';
-    }
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((entry) => stableSerializeAnalysisValue(entry)).join(",")}]`;
-    }
-    return `{${Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, entry]) => `${JSON.stringify(key)}:${stableSerializeAnalysisValue(entry)}`)
-        .join(",")}}`;
-}
-function buildAnalysisProgramStructureKey(projectRoot, typesFilePath, { compilerOptions, configPath, rootNames, typiaTagsAugmentationPath, }) {
-    return stableSerializeAnalysisValue({
-        compilerOptions,
-        configPath,
-        projectRoot,
-        rootNames: [...rootNames].sort(),
-        typiaTagsAugmentationPath,
-        typesFilePath,
-    });
-}
-function createAnalysisProgramContentFingerprint(filePaths, onMissingFile = "throw") {
-    const hash = createHash("sha1");
-    const fingerprintPaths = [...new Set(filePaths)].sort();
-    for (const filePath of fingerprintPaths) {
-        const fileContents = ts.sys.readFile(filePath);
-        if (fileContents === undefined) {
-            if (onMissingFile === "return-null") {
-                return null;
-            }
-            if (onMissingFile === "hash-missing") {
-                hash.update(filePath);
-                hash.update("\0");
-                hash.update("__missing__");
-                hash.update("\0");
-                continue;
-            }
-            throw new Error(`Unable to read metadata analysis dependency: ${filePath}`);
-        }
-        hash.update(filePath);
-        hash.update("\0");
-        hash.update(fileContents);
-        hash.update("\0");
-    }
-    return hash.digest("hex");
-}
-function getAnalysisProgramDependencyPaths(program, configPath) {
-    const sourceFilePaths = program
-        .getSourceFiles()
-        .map((sourceFile) => sourceFile.fileName)
-        .filter((filePath) => !filePath.startsWith(TYPESCRIPT_LIB_DIRECTORY));
-    const dependencyPaths = new Set(sourceFilePaths);
-    for (const filePath of sourceFilePaths) {
-        let currentDir = path.dirname(filePath);
-        while (true) {
-            dependencyPaths.add(path.join(currentDir, "package.json"));
-            const parentDir = path.dirname(currentDir);
-            if (parentDir === currentDir) {
-                break;
-            }
-            currentDir = parentDir;
-        }
-    }
-    if (configPath) {
-        dependencyPaths.add(configPath);
-    }
-    return [...dependencyPaths].sort();
-}
-function resolveAnalysisProgramInputs(projectRoot, typesFilePath) {
-    const configPath = ts.findConfigFile(projectRoot, ts.sys.fileExists, "tsconfig.json");
-    const compilerOptions = {
-        allowJs: false,
-        esModuleInterop: true,
-        module: ts.ModuleKind.NodeNext,
-        moduleResolution: ts.ModuleResolutionKind.NodeNext,
-        resolveJsonModule: true,
-        skipLibCheck: true,
-        target: ts.ScriptTarget.ES2022,
-    };
-    let rootNames = [typesFilePath];
-    const typiaTagsAugmentationPath = resolveTypiaTagsAugmentationPath();
-    if (configPath !== undefined) {
-        const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-        if (configFile.error) {
-            throw formatDiagnosticError(configFile.error);
-        }
-        const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath), compilerOptions, configPath);
-        if (parsed.errors.length > 0) {
-            throw formatDiagnosticError(parsed.errors[0]);
-        }
-        rootNames = parsed.fileNames.includes(typesFilePath)
-            ? parsed.fileNames
-            : [...parsed.fileNames, typesFilePath];
-        if (typiaTagsAugmentationPath &&
-            !rootNames.includes(typiaTagsAugmentationPath)) {
-            rootNames = [...rootNames, typiaTagsAugmentationPath];
-        }
-        Object.assign(compilerOptions, parsed.options);
-    }
-    else if (typiaTagsAugmentationPath) {
-        rootNames = [...rootNames, typiaTagsAugmentationPath];
-    }
-    const structureKey = buildAnalysisProgramStructureKey(projectRoot, typesFilePath, {
-        compilerOptions,
-        configPath: configPath ?? null,
-        rootNames,
-        typiaTagsAugmentationPath,
-    });
-    return {
-        compilerOptions,
-        configPath: configPath ?? null,
-        rootNames,
-        structureKey,
-        typiaTagsAugmentationPath,
-    };
-}
-export function createAnalysisContext(projectRoot, typesFilePath) {
-    const analysisInputs = resolveAnalysisProgramInputs(projectRoot, typesFilePath);
-    const cachedAnalysis = analysisProgramCache.get(analysisInputs.structureKey);
-    if (cachedAnalysis) {
-        const currentDependencyFingerprint = createAnalysisProgramContentFingerprint(cachedAnalysis.dependencyPaths, "hash-missing");
-        if (currentDependencyFingerprint !== null &&
-            currentDependencyFingerprint === cachedAnalysis.dependencyFingerprint) {
-            return {
-                allowedExternalPackages: new Set(DEFAULT_ALLOWED_EXTERNAL_PACKAGES),
-                checker: cachedAnalysis.checker,
-                packageNameCache: new Map(),
-                projectRoot,
-                program: cachedAnalysis.program,
-                recursionGuard: new Set(),
-            };
-        }
-    }
-    const program = ts.createProgram({
-        oldProgram: cachedAnalysis?.program,
-        options: analysisInputs.compilerOptions,
-        rootNames: analysisInputs.rootNames,
-    });
-    const diagnostics = ts.getPreEmitDiagnostics(program);
-    const localSourceFiles = collectReferencedLocalSourceFiles(program, typesFilePath, analysisInputs.compilerOptions, projectRoot);
-    const blockingDiagnostic = diagnostics.find((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error &&
-        diagnostic.file !== undefined &&
-        localSourceFiles.has(diagnostic.file.fileName));
-    if (blockingDiagnostic) {
-        throw formatDiagnosticError(blockingDiagnostic);
-    }
-    const checker = program.getTypeChecker();
-    const dependencyPaths = getAnalysisProgramDependencyPaths(program, analysisInputs.configPath);
-    const dependencyFingerprint = createAnalysisProgramContentFingerprint(dependencyPaths, "hash-missing");
-    if (dependencyFingerprint === null) {
-        throw new Error("Unable to fingerprint metadata analysis dependencies.");
-    }
-    analysisProgramCache.set(analysisInputs.structureKey, {
-        checker,
-        dependencyFingerprint,
-        dependencyPaths,
-        program,
-    });
-    return {
-        allowedExternalPackages: new Set(DEFAULT_ALLOWED_EXTERNAL_PACKAGES),
-        checker,
-        packageNameCache: new Map(),
-        projectRoot,
-        program,
-        recursionGuard: new Set(),
-    };
-}
-function resolveTypiaTagsAugmentationPath() {
-    const candidates = [
-        path.join(RUNTIME_DIRECTORY, "typia-tags.d.ts"),
-        path.join(RUNTIME_DIRECTORY, "typia-tags.ts"),
-    ];
-    for (const candidate of candidates) {
-        if (ts.sys.fileExists(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function formatDiagnosticError(diagnostic) {
-    return tagMetadataDiagnosticError(new Error(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")));
-}
+/**
+ * Re-exports metadata analysis helpers from `@wp-typia/block-runtime`.
+ * This adapter preserves the public project-tools module path while sharing
+ * the runtime implementation with block-runtime.
+ * @module
+ */
+export * from "@wp-typia/block-runtime/metadata-analysis";

package/dist/runtime/metadata-model.d.ts

@@ -1,84 +1,7 @@
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-export type AttributeKind = "string" | "number" | "boolean" | "array" | "object" | "union";
-export type WordPressAttributeKind = "string" | "number" | "boolean" | "array" | "object";
-export type WordPressAttributeSource = "html" | "text" | "rich-text";
-export interface AttributeConstraints {
-    exclusiveMaximum: number | null;
-    exclusiveMinimum: number | null;
-    format: string | null;
-    maxLength: number | null;
-    maxItems: number | null;
-    maximum: number | null;
-    minLength: number | null;
-    minItems: number | null;
-    minimum: number | null;
-    multipleOf: number | null;
-    pattern: string | null;
-    typeTag: string | null;
-}
-export interface AttributeNode {
-    constraints: AttributeConstraints;
-    defaultValue?: JsonValue;
-    enumValues: Array<string | number | boolean> | null;
-    items?: AttributeNode;
-    kind: AttributeKind;
-    path: string;
-    properties?: Record<string, AttributeNode>;
-    required: boolean;
-    union?: AttributeUnion | null;
-    wp: {
-        selector: string | null;
-        source: WordPressAttributeSource | null;
-    };
-}
-export interface AttributeUnion {
-    branches: Record<string, AttributeNode>;
-    discriminator: string;
-}
-export interface BlockJsonAttribute {
-    default?: JsonValue;
-    enum?: Array<string | number | boolean>;
-    selector?: string;
-    source?: WordPressAttributeSource;
-    type: WordPressAttributeKind;
-}
-export interface ManifestAttribute {
-    typia: {
-        constraints: AttributeConstraints;
-        defaultValue: JsonValue | null;
-        hasDefault: boolean;
-    };
-    ts: {
-        items: ManifestAttribute | null;
-        kind: AttributeKind;
-        properties: Record<string, ManifestAttribute> | null;
-        required: boolean;
-        union: ManifestUnion | null;
-    };
-    wp: {
-        defaultValue: JsonValue | null;
-        enum: Array<string | number | boolean> | null;
-        hasDefault: boolean;
-        selector?: string | null;
-        source?: WordPressAttributeSource | null;
-        type: WordPressAttributeKind;
-    };
-}
-export interface ManifestUnion {
-    branches: Record<string, ManifestAttribute>;
-    discriminator: string;
-}
-export interface ManifestDocument {
-    attributes: Record<string, ManifestAttribute>;
-    manifestVersion: 2;
-    sourceType: string;
-}
-export declare function defaultAttributeConstraints(): AttributeConstraints;
-export declare function getWordPressKind(node: AttributeNode): WordPressAttributeKind;
-export declare function baseNode(kind: AttributeKind, pathLabel: string): AttributeNode;
-export declare function withRequired(node: AttributeNode, required: boolean): AttributeNode;
-export declare function cloneUnion(union: AttributeUnion): AttributeUnion;
-export declare function cloneProperties(properties: Record<string, AttributeNode>): Record<string, AttributeNode>;
+/**
+ * Re-exports the metadata model types and helpers from `@wp-typia/block-runtime`.
+ * This adapter keeps the public project-tools runtime path stable while the
+ * implementation is consolidated in block-runtime.
+ * @module
+ */
+export * from "@wp-typia/block-runtime/metadata-model";

package/dist/runtime/metadata-model.js

@@ -1,59 +1,7 @@
-export function defaultAttributeConstraints() {
-    return {
-        exclusiveMaximum: null,
-        exclusiveMinimum: null,
-        format: null,
-        maxLength: null,
-        maxItems: null,
-        maximum: null,
-        minLength: null,
-        minItems: null,
-        minimum: null,
-        multipleOf: null,
-        pattern: null,
-        typeTag: null,
-    };
-}
-export function getWordPressKind(node) {
-    return node.kind === "union" ? "object" : node.kind;
-}
-export function baseNode(kind, pathLabel) {
-    return {
-        constraints: defaultAttributeConstraints(),
-        enumValues: null,
-        kind,
-        path: pathLabel,
-        required: true,
-        union: null,
-        wp: {
-            selector: null,
-            source: null,
-        },
-    };
-}
-export function withRequired(node, required) {
-    return {
-        ...node,
-        items: node.items
-            ? withRequired(node.items, node.items.required)
-            : undefined,
-        properties: node.properties ? cloneProperties(node.properties) : undefined,
-        required,
-        union: node.union ? cloneUnion(node.union) : null,
-    };
-}
-export function cloneUnion(union) {
-    return {
-        branches: Object.fromEntries(Object.entries(union.branches).map(([key, branch]) => [
-            key,
-            withRequired(branch, branch.required),
-        ])),
-        discriminator: union.discriminator,
-    };
-}
-export function cloneProperties(properties) {
-    return Object.fromEntries(Object.entries(properties).map(([key, node]) => [
-        key,
-        withRequired(node, node.required),
-    ]));
-}
+/**
+ * Re-exports the metadata model types and helpers from `@wp-typia/block-runtime`.
+ * This adapter keeps the public project-tools runtime path stable while the
+ * implementation is consolidated in block-runtime.
+ * @module
+ */
+export * from "@wp-typia/block-runtime/metadata-model";