@wp-typia/project-tools 0.15.1 → 0.15.3

package/dist/runtime/metadata-projection.js

@@ -1,233 +1,7 @@
-import { cloneJsonValue } from "./json-utils.js";
-import { getWordPressKind, } from "./metadata-model.js";
-export function createBlockJsonAttribute(node, warnings) {
-    const attribute = {
-        type: getWordPressKind(node),
-    };
-    if (node.defaultValue !== undefined) {
-        attribute.default = cloneJsonValue(node.defaultValue);
-    }
-    if (node.enumValues !== null && node.enumValues.length > 0) {
-        attribute.enum = [...node.enumValues];
-    }
-    if (node.wp.source !== null) {
-        attribute.source = node.wp.source;
-    }
-    if (node.wp.selector !== null) {
-        attribute.selector = node.wp.selector;
-    }
-    const reasons = [];
-    if (node.constraints.exclusiveMaximum !== null)
-        reasons.push("exclusiveMaximum");
-    if (node.constraints.exclusiveMinimum !== null)
-        reasons.push("exclusiveMinimum");
-    if (node.constraints.format !== null)
-        reasons.push("format");
-    if (node.constraints.maxLength !== null)
-        reasons.push("maxLength");
-    if (node.constraints.maxItems !== null)
-        reasons.push("maxItems");
-    if (node.constraints.maximum !== null)
-        reasons.push("maximum");
-    if (node.constraints.minLength !== null)
-        reasons.push("minLength");
-    if (node.constraints.minItems !== null)
-        reasons.push("minItems");
-    if (node.constraints.minimum !== null)
-        reasons.push("minimum");
-    if (node.constraints.multipleOf !== null)
-        reasons.push("multipleOf");
-    if (node.constraints.pattern !== null)
-        reasons.push("pattern");
-    if (node.constraints.typeTag !== null)
-        reasons.push("typeTag");
-    if (node.kind === "array" && node.items !== undefined)
-        reasons.push("items");
-    if (node.kind === "object" && node.properties !== undefined)
-        reasons.push("properties");
-    if (node.kind === "union" && node.union !== null)
-        reasons.push("union");
-    if (reasons.length > 0) {
-        warnings.push(`${node.path}: ${reasons.join(", ")}`);
-    }
-    return attribute;
-}
-export function createManifestAttribute(node) {
-    return {
-        typia: {
-            constraints: { ...node.constraints },
-            defaultValue: node.defaultValue === undefined ? null : cloneJsonValue(node.defaultValue),
-            hasDefault: node.defaultValue !== undefined,
-        },
-        ts: {
-            items: node.items ? createManifestAttribute(node.items) : null,
-            kind: node.kind,
-            properties: node.properties
-                ? Object.fromEntries(Object.entries(node.properties).map(([key, property]) => [
-                    key,
-                    createManifestAttribute(property),
-                ]))
-                : null,
-            required: node.required,
-            union: node.union
-                ? {
-                    branches: Object.fromEntries(Object.entries(node.union.branches).map(([key, branch]) => [
-                        key,
-                        createManifestAttribute(branch),
-                    ])),
-                    discriminator: node.union.discriminator,
-                }
-                : null,
-        },
-        wp: {
-            defaultValue: node.defaultValue === undefined ? null : cloneJsonValue(node.defaultValue),
-            enum: node.enumValues ? [...node.enumValues] : null,
-            hasDefault: node.defaultValue !== undefined,
-            ...(node.wp.selector !== null ? { selector: node.wp.selector } : {}),
-            ...(node.wp.source !== null ? { source: node.wp.source } : {}),
-            type: getWordPressKind(node),
-        },
-    };
-}
-export function createManifestDocument(sourceTypeName, attributes) {
-    return {
-        attributes: Object.fromEntries(Object.entries(attributes).map(([key, node]) => [
-            key,
-            createManifestAttribute(node),
-        ])),
-        manifestVersion: 2,
-        sourceType: sourceTypeName,
-    };
-}
-export function validateWordPressExtractionAttributes(attributes) {
-    for (const attribute of Object.values(attributes)) {
-        validateWordPressExtractionAttribute(attribute, true);
-    }
-}
-export function validateWordPressExtractionAttribute(node, isTopLevel = false) {
-    const hasSelector = node.wp.selector !== null;
-    const hasSource = node.wp.source !== null;
-    if (hasSelector || hasSource) {
-        if (!isTopLevel) {
-            throw new Error(`WordPress extraction tags are only supported on top-level block attributes at ${node.path}`);
-        }
-        if (!hasSelector || !hasSource) {
-            throw new Error(`WordPress extraction tags require both Source and Selector at ${node.path}`);
-        }
-        if (node.kind !== "string") {
-            throw new Error(`WordPress extraction tags are only supported on string attributes at ${node.path}`);
-        }
-    }
-    if (node.items !== undefined) {
-        validateWordPressExtractionAttribute(node.items, false);
-    }
-    if (node.properties !== undefined) {
-        for (const property of Object.values(node.properties)) {
-            validateWordPressExtractionAttribute(property, false);
-        }
-    }
-    if (node.union?.branches) {
-        for (const branch of Object.values(node.union.branches)) {
-            validateWordPressExtractionAttribute(branch, false);
-        }
-    }
-}
-export function createExampleValue(node, key) {
-    if (node.defaultValue !== undefined) {
-        return cloneJsonValue(node.defaultValue);
-    }
-    if (node.enumValues !== null && node.enumValues.length > 0) {
-        return cloneJsonValue(node.enumValues[0]);
-    }
-    switch (node.kind) {
-        case "string":
-            return fitStringExampleToConstraints(createFormattedStringExample(node.constraints.format, key), node.constraints);
-        case "number":
-            return createNumericExample(node);
-        case "boolean":
-            return true;
-        case "array":
-            return createArrayExample(node, key);
-        case "object":
-            return Object.fromEntries(Object.entries(node.properties ?? {}).map(([propertyKey, propertyNode]) => [
-                propertyKey,
-                createExampleValue(propertyNode, propertyKey),
-            ]));
-        case "union": {
-            const firstBranch = node.union
-                ? Object.values(node.union.branches)[0]
-                : undefined;
-            if (!firstBranch || firstBranch.kind !== "object") {
-                return {};
-            }
-            return Object.fromEntries(Object.entries(firstBranch.properties ?? {}).map(([propertyKey, propertyNode]) => [
-                propertyKey,
-                createExampleValue(propertyNode, propertyKey),
-            ]));
-        }
-    }
-}
-function createFormattedStringExample(format, key) {
-    switch (format) {
-        case "uuid":
-            return "00000000-0000-4000-8000-000000000000";
-        case "email":
-            return "example@example.com";
-        case "url":
-        case "uri":
-            return "https://example.com";
-        case "ipv4":
-            return "127.0.0.1";
-        case "ipv6":
-            return "::1";
-        case "date-time":
-            return "2024-01-01T00:00:00Z";
-        default:
-            return `Example ${key}`;
-    }
-}
-function fitStringExampleToConstraints(value, constraints) {
-    let nextValue = value;
-    if (constraints.maxLength !== null &&
-        nextValue.length > constraints.maxLength) {
-        nextValue = nextValue.slice(0, constraints.maxLength);
-    }
-    if (constraints.minLength !== null &&
-        nextValue.length < constraints.minLength) {
-        nextValue = nextValue.padEnd(constraints.minLength, "x");
-    }
-    return nextValue;
-}
-function createNumericExample(node) {
-    const { exclusiveMaximum, exclusiveMinimum, maximum, minimum, multipleOf, } = node.constraints;
-    const step = multipleOf && multipleOf !== 0 ? multipleOf : 1;
-    const minCandidate = minimum ?? (exclusiveMinimum !== null ? exclusiveMinimum + step : null);
-    const maxCandidate = maximum ?? (exclusiveMaximum !== null ? exclusiveMaximum - step : null);
-    let candidate = multipleOf && multipleOf !== 0
-        ? minCandidate !== null
-            ? Math.ceil(minCandidate / multipleOf) * multipleOf
-            : maxCandidate !== null
-                ? Math.floor(maxCandidate / multipleOf) * multipleOf
-                : multipleOf
-        : minCandidate ?? maxCandidate ?? 42;
-    if (maxCandidate !== null && candidate > maxCandidate) {
-        candidate =
-            multipleOf && multipleOf !== 0
-                ? Math.floor(maxCandidate / multipleOf) * multipleOf
-                : maxCandidate;
-    }
-    if (minCandidate !== null && candidate < minCandidate) {
-        candidate =
-            multipleOf && multipleOf !== 0
-                ? Math.ceil(minCandidate / multipleOf) * multipleOf
-                : minCandidate;
-    }
-    return candidate;
-}
-function createArrayExample(node, key) {
-    const minimumItems = Math.max(node.constraints.minItems ?? 0, 0);
-    if (minimumItems === 0 || node.items === undefined) {
-        return [];
-    }
-    return Array.from({ length: minimumItems }, (_value, index) => createExampleValue(node.items, `${key}${index + 1}`));
-}
+/**
+ * Re-exports metadata projection 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 * from "@wp-typia/block-runtime/metadata-projection";

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

@@ -3,7 +3,7 @@
  */
 export type UnknownRecord = Record<string, unknown>;
 /**
- * Check whether a value is a plain object record.
+ * Delegate plain-object detection to the shared runtime primitive owner.
  *
  * @param value Runtime value to inspect.
  * @returns `true` when the value is a non-null plain object with an

package/dist/runtime/object-utils.js

@@ -1,14 +1,11 @@
+import { isPlainObject as isSharedPlainObject } from "@wp-typia/api-client/runtime-primitives";
 /**
- * Check whether a value is a plain object record.
+ * Delegate plain-object detection to the shared runtime primitive owner.
  *
  * @param value Runtime value to inspect.
  * @returns `true` when the value is a non-null plain object with an
  * `Object.prototype` or `null` prototype.
  */
 export function isPlainObject(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
+    return isSharedPlainObject(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -26,9 +26,9 @@
     "package.json"
   ],
   "scripts": {
-    "build": "bun run --filter @wp-typia/block-runtime build && rm -rf dist && tsc -p tsconfig.runtime.json",
-    "test": "bun run --filter @wp-typia/block-runtime build && bun run build && bun test tests/*.test.ts",
-    "test:coverage": "bun run --filter @wp-typia/block-runtime build && bun run build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
+    "build": "bun run --filter @wp-typia/api-client build && bun run --filter @wp-typia/block-runtime build && rm -rf dist && tsc -p tsconfig.runtime.json",
+    "test": "bun run build && bun test tests/*.test.ts",
+    "test:coverage": "bun run build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
     "clean": "rm -rf dist",
     "prepack": "bun run build"
   },
@@ -61,10 +61,10 @@
     "bun": ">=1.3.11"
   },
   "dependencies": {
-    "@wp-typia/api-client": "^0.4.0",
-    "@wp-typia/block-runtime": "^0.4.0",
-    "@wp-typia/rest": "^0.3.4",
-    "@wp-typia/block-types": "^0.2.0",
+    "@wp-typia/api-client": "^0.4.2",
+    "@wp-typia/block-runtime": "^0.4.3",
+    "@wp-typia/rest": "^0.3.5",
+    "@wp-typia/block-types": "^0.2.1",
     "mustache": "^4.2.0",
     "npm-package-arg": "^13.0.0",
     "semver": "^7.7.3",

package/templates/_shared/base/src/validator-toolkit.ts.mustache

@@ -1,30 +1,44 @@
-import typia from 'typia';
-
 import type { ManifestDefaultsDocument } from '@wp-typia/block-runtime/defaults';
 import {
 	createScaffoldValidatorToolkit,
 	type ScaffoldValidatorToolkitOptions,
 } from '@wp-typia/block-runtime/validation';
 
-interface TemplateValidatorToolkitOptions< T extends object > {
+interface TemplateValidatorFunctions< T extends object > {
+	assert: ScaffoldValidatorToolkitOptions< T >['assert'];
+	clone: ScaffoldValidatorToolkitOptions< T >['clone'];
+	is: ScaffoldValidatorToolkitOptions< T >['is'];
+	prune: ScaffoldValidatorToolkitOptions< T >['prune'];
+	random: ScaffoldValidatorToolkitOptions< T >['random'];
+	validate: ScaffoldValidatorToolkitOptions< T >['validate'];
+}
+
+interface TemplateValidatorToolkitOptions< T extends object >
+	extends TemplateValidatorFunctions< T > {
 	finalize?: ScaffoldValidatorToolkitOptions< T >['finalize'];
 	manifest: unknown;
 	onValidationError?: ScaffoldValidatorToolkitOptions< T >['onValidationError'];
 }
 
 export function createTemplateValidatorToolkit< T extends object >( {
+	assert,
+	clone,
 	finalize,
+	is,
 	manifest,
 	onValidationError,
+	prune,
+	random,
+	validate,
 }: TemplateValidatorToolkitOptions< T > ) {
 	return createScaffoldValidatorToolkit< T >( {
 		manifest: manifest as ManifestDefaultsDocument,
-		validate: typia.createValidate< T >(),
-		assert: typia.createAssert< T >(),
-		is: typia.createIs< T >(),
-		random: typia.createRandom< T >() as ( ...args: unknown[] ) => T,
-		clone: typia.misc.createClone< T >() as ( value: T ) => T,
-		prune: typia.misc.createPrune< T >(),
+		validate,
+		assert,
+		is,
+		random,
+		clone,
+		prune,
 		finalize,
 		onValidationError,
 	} );

package/templates/_shared/base/webpack.config.js.mustache

@@ -95,5 +95,6 @@ module.exports = async () => {
 		getArtifactEntries,
 		getOptionalModuleEntries: () => optionalModuleEntries,
 		importTypiaWebpackPlugin: () => import("@typia/unplugin/webpack"),
+		projectRoot: process.cwd(),
 	});
 };

package/templates/_shared/compound/core/webpack.config.js.mustache

@@ -137,5 +137,6 @@ module.exports = async () => {
 		importTypiaWebpackPlugin: () => import( '@typia/unplugin/webpack' ),
 		moduleEntriesMode: 'replace',
 		nonModuleEntriesMode: 'replace',
+		projectRoot: process.cwd(),
 	} );
 };

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/validators.ts.mustache

@@ -1,3 +1,4 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type {
 	{{pascalCase}}Attributes,
@@ -7,7 +8,16 @@ import { generateResourceKey } from '@wp-typia/block-runtime/identifiers';
 import { createTemplateValidatorToolkit } from '../../validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
+	assert: typia.createAssert< {{pascalCase}}Attributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}Attributes >() as (
+		value: {{pascalCase}}Attributes,
+	) => {{pascalCase}}Attributes,
+	is: typia.createIs< {{pascalCase}}Attributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}Attributes >(),
+	random: typia.createRandom< {{pascalCase}}Attributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}Attributes,
 	finalize: ( normalized ) => ( {
 		...normalized,
 		resourceKey:
@@ -15,6 +25,7 @@ const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attribu
 				? normalized.resourceKey
 				: generateResourceKey( '{{slugKebabCase}}' ),
 	} ),
+	validate: typia.createValidate< {{pascalCase}}Attributes >(),
 } );
 
 export const validators = scaffoldValidators.validators;

package/templates/_shared/persistence/core/src/validators.ts.mustache

@@ -1,3 +1,4 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type {
 	{{pascalCase}}Attributes,
@@ -7,7 +8,16 @@ import { generateResourceKey } from '@wp-typia/block-runtime/identifiers';
 import { createTemplateValidatorToolkit } from './validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
+	assert: typia.createAssert< {{pascalCase}}Attributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}Attributes >() as (
+		value: {{pascalCase}}Attributes,
+	) => {{pascalCase}}Attributes,
+	is: typia.createIs< {{pascalCase}}Attributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}Attributes >(),
+	random: typia.createRandom< {{pascalCase}}Attributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}Attributes,
 	finalize: ( normalized ) => ( {
 		...normalized,
 		resourceKey:
@@ -15,6 +25,7 @@ const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attribu
 				? normalized.resourceKey
 				: generateResourceKey( '{{slugKebabCase}}' ),
 	} ),
+	validate: typia.createValidate< {{pascalCase}}Attributes >(),
 } );
 
 export const validators = scaffoldValidators.validators;

package/templates/basic/src/validators.ts.mustache

@@ -1,14 +1,25 @@
+import typia from 'typia';
 import currentManifest from "./typia.manifest.json";
 import { {{pascalCase}}Attributes, {{pascalCase}}ValidationResult } from "./types";
 import { generateBlockId } from "@wp-typia/block-runtime/identifiers";
 import { createTemplateValidatorToolkit } from "./validator-toolkit";
 
 const scaffoldValidators = createTemplateValidatorToolkit<{{pascalCase}}Attributes>({
+  assert: typia.createAssert<{{pascalCase}}Attributes>(),
+  clone: typia.misc.createClone<{{pascalCase}}Attributes>() as (
+    value: {{pascalCase}}Attributes,
+  ) => {{pascalCase}}Attributes,
+  is: typia.createIs<{{pascalCase}}Attributes>(),
   manifest: currentManifest,
+  prune: typia.misc.createPrune<{{pascalCase}}Attributes>(),
+  random: typia.createRandom<{{pascalCase}}Attributes>() as (
+    ...args: unknown[]
+  ) => {{pascalCase}}Attributes,
   finalize: (normalized) => ({
     ...normalized,
     id: normalized.id && normalized.id.length > 0 ? normalized.id : generateBlockId(),
   }),
+  validate: typia.createValidate<{{pascalCase}}Attributes>(),
 });
 
 export const validate{{pascalCase}}Attributes =

package/templates/compound/src/blocks/{{slugKebabCase}}/validators.ts.mustache

@@ -1,9 +1,20 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type { {{pascalCase}}Attributes } from './types';
 import { createTemplateValidatorToolkit } from '../../validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
+	assert: typia.createAssert< {{pascalCase}}Attributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}Attributes >() as (
+		value: {{pascalCase}}Attributes,
+	) => {{pascalCase}}Attributes,
+	is: typia.createIs< {{pascalCase}}Attributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}Attributes >(),
+	random: typia.createRandom< {{pascalCase}}Attributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}Attributes,
+	validate: typia.createValidate< {{pascalCase}}Attributes >(),
 } );
 
 export const validate{{pascalCase}}Attributes =

package/templates/compound/src/blocks/{{slugKebabCase}}-item/validators.ts.mustache

@@ -1,9 +1,20 @@
+import typia from 'typia';
 import currentManifest from './typia.manifest.json';
 import type { {{pascalCase}}ItemAttributes } from './types';
 import { createTemplateValidatorToolkit } from '../../validator-toolkit';
 
 const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}ItemAttributes >( {
+	assert: typia.createAssert< {{pascalCase}}ItemAttributes >(),
+	clone: typia.misc.createClone< {{pascalCase}}ItemAttributes >() as (
+		value: {{pascalCase}}ItemAttributes,
+	) => {{pascalCase}}ItemAttributes,
+	is: typia.createIs< {{pascalCase}}ItemAttributes >(),
 	manifest: currentManifest,
+	prune: typia.misc.createPrune< {{pascalCase}}ItemAttributes >(),
+	random: typia.createRandom< {{pascalCase}}ItemAttributes >() as (
+		...args: unknown[]
+	) => {{pascalCase}}ItemAttributes,
+	validate: typia.createValidate< {{pascalCase}}ItemAttributes >(),
 } );
 
 export const validate{{pascalCase}}ItemAttributes =

package/templates/interactivity/src/validators.ts.mustache

@@ -1,10 +1,20 @@
+import typia from 'typia';
 import currentManifest from "./typia.manifest.json";
 import { {{pascalCase}}Attributes, {{pascalCase}}ValidationResult } from "./types";
 import { generateScopedClientId } from "@wp-typia/block-runtime/identifiers";
 import { createTemplateValidatorToolkit } from "./validator-toolkit";
 
 const scaffoldValidators = createTemplateValidatorToolkit<{{pascalCase}}Attributes>({
+  assert: typia.createAssert<{{pascalCase}}Attributes>(),
+  clone: typia.misc.createClone<{{pascalCase}}Attributes>() as (
+    value: {{pascalCase}}Attributes,
+  ) => {{pascalCase}}Attributes,
+  is: typia.createIs<{{pascalCase}}Attributes>(),
   manifest: currentManifest,
+  prune: typia.misc.createPrune<{{pascalCase}}Attributes>(),
+  random: typia.createRandom<{{pascalCase}}Attributes>() as (
+    ...args: unknown[]
+  ) => {{pascalCase}}Attributes,
   finalize: (normalized) => ({
     ...normalized,
     uniqueId:
@@ -12,6 +22,7 @@ const scaffoldValidators = createTemplateValidatorToolkit<{{pascalCase}}Attribut
         ? normalized.uniqueId
         : generateScopedClientId("{{slugKebabCase}}"),
   }),
+  validate: typia.createValidate<{{pascalCase}}Attributes>(),
 });
 
 export const validate{{pascalCase}}Attributes =