@wp-typia/project-tools 0.15.1 → 0.15.2

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";

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

@@ -1,53 +1,7 @@
-import ts from "typescript";
-import { type AnalysisContext } from "./metadata-analysis.js";
-import { type AttributeNode } from "./metadata-model.js";
 /**
- * Analyze one named source type from a TypeScript module.
- *
- * @param options Metadata analysis options including the project root, source
- * type name, and types file path.
- * @returns The resolved project root plus the parsed root attribute node for
- * the requested source type.
+ * Re-exports metadata parser utilities 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 declare function analyzeSourceType(options: {
-    projectRoot?: string;
-    sourceTypeName: string;
-    typesFile: string;
-}): {
-    projectRoot: string;
-    rootNode: AttributeNode;
-};
-/**
- * Analyze multiple named source types from a TypeScript module.
- *
- * @param options Metadata analysis options including the optional project root
- * and the relative types file path to parse.
- * @param sourceTypeNames Exported type or interface names to resolve from the
- * configured types file.
- * @returns A record keyed by source type name with parsed attribute-node trees
- * for each requested type.
- */
-export declare function analyzeSourceTypes(options: {
-    projectRoot?: string;
-    typesFile: string;
-}, sourceTypeNames: string[]): Record<string, AttributeNode>;
-/**
- * Parse an interface or type alias declaration into one attribute-node tree.
- *
- * @param declaration TypeScript declaration node to parse.
- * @param ctx Shared analysis context used for type resolution and recursion
- * detection.
- * @param pathLabel Human-readable path label for diagnostics.
- * @param required Whether the resulting node should be marked as required.
- * @returns The parsed attribute-node representation for the declaration.
- */
-export declare function parseNamedDeclaration(declaration: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, ctx: AnalysisContext, pathLabel: string, required: boolean): AttributeNode;
-/**
- * Parse one TypeScript type node into the internal metadata model.
- *
- * @param node TypeScript AST node describing the source type shape.
- * @param ctx Shared analysis context used for symbol and type resolution.
- * @param pathLabel Human-readable path label used in parse errors and warnings.
- * @returns The parsed attribute-node representation of the provided type node.
- */
-export declare function parseTypeNode(node: ts.TypeNode, ctx: AnalysisContext, pathLabel: string): AttributeNode;
+export * from "@wp-typia/block-runtime/metadata-parser";