@wp-typia/block-runtime 0.2.3 → 0.3.0

package/dist/validation.js

@@ -1 +1,206 @@
-export { createAttributeUpdater, createNestedAttributeUpdater, formatValidationError, formatValidationErrors, mergeNestedAttributeUpdate, normalizeValidationError, toAttributePatch, toNestedAttributePatch, toValidationResult, toValidationState, } from "@wp-typia/create/runtime/validation";
+import { applyTemplateDefaultsFromManifest } from "./defaults.js";
+import { isPlainObject as isRecord } from "./object-utils.js";
+const UNSAFE_PATH_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);
+function getValueType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    return typeof value;
+}
+function redactValidationErrors(errors) {
+    return errors.map(({ description, expected, path }) => ({
+        description,
+        expected,
+        path,
+    }));
+}
+export function normalizeValidationError(error) {
+    const raw = error !== null && typeof error === "object"
+        ? error
+        : {};
+    return {
+        description: typeof raw.description === "string" ? raw.description : undefined,
+        expected: typeof raw.expected === "string" ? raw.expected : "unknown",
+        path: typeof raw.path === "string" && raw.path.length > 0 ? raw.path : "(root)",
+        value: Object.prototype.hasOwnProperty.call(raw, "value") ? raw.value : undefined,
+    };
+}
+export function toValidationResult(result) {
+    const raw = result !== null && typeof result === "object"
+        ? result
+        : undefined;
+    if (raw?.success === true) {
+        return {
+            data: raw.data,
+            errors: [],
+            isValid: true,
+        };
+    }
+    const rawErrors = Array.isArray(raw?.errors) ? raw.errors : [];
+    return {
+        data: undefined,
+        errors: rawErrors.map(normalizeValidationError),
+        isValid: false,
+    };
+}
+export function formatValidationError(error) {
+    return `${error.path}: ${error.expected} expected, got ${getValueType(error.value)}`;
+}
+export function formatValidationErrors(errors) {
+    return errors.map(formatValidationError);
+}
+export function toValidationState(result) {
+    return {
+        ...result,
+        errorMessages: formatValidationErrors(result.errors),
+    };
+}
+export function createUseTypiaValidationHook({ useMemo, }) {
+    return function useTypiaValidation(value, validator) {
+        return useMemo(() => toValidationState(validator(value)), [value, validator]);
+    };
+}
+export function createScaffoldValidatorToolkit({ assert, clone, finalize, is, manifest, onValidationError = (validation, key) => {
+    console.error(`Validation failed for ${String(key)}:`, redactValidationErrors(validation.errors));
+}, prune, random, validate, }) {
+    const validateAttributes = (value) => toValidationResult(validate(value));
+    const normalizeAttributes = (value) => {
+        const normalized = applyTemplateDefaultsFromManifest(manifest, value);
+        return finalize ? finalize(normalized) : normalized;
+    };
+    const sanitizeAttributes = (value) => assert(normalizeAttributes(value));
+    const validateSanitizedAttributes = (value) => {
+        const normalized = normalizeAttributes(value);
+        try {
+            const data = assert(normalized);
+            return {
+                data,
+                errors: [],
+                isValid: true,
+            };
+        }
+        catch {
+            return validateAttributes(value);
+        }
+    };
+    const createScaffoldAttributeUpdater = (attributes, setAttributes, validator = validateSanitizedAttributes) => createAttributeUpdater(attributes, setAttributes, validator, onValidationError);
+    return {
+        createAttributeUpdater: createScaffoldAttributeUpdater,
+        sanitizeAttributes,
+        validateAttributes,
+        validators: {
+            assert,
+            clone,
+            is,
+            prune,
+            random,
+            validate: validateAttributes,
+        },
+    };
+}
+function toChangedAttributePatch(attributes, nextAttributes) {
+    const patch = {};
+    const keys = new Set([
+        ...Object.keys(attributes),
+        ...Object.keys(nextAttributes),
+    ]);
+    for (const key of keys) {
+        if (!(key in nextAttributes)) {
+            patch[key] = undefined;
+            continue;
+        }
+        if (!Object.is(attributes[key], nextAttributes[key])) {
+            patch[key] = nextAttributes[key];
+        }
+    }
+    return patch;
+}
+function mergeAttributeUpdate(attributes, key, value) {
+    return {
+        ...attributes,
+        [key]: value,
+    };
+}
+function getNestedPathSegments(path) {
+    const segments = path.split(".").filter(Boolean);
+    if (segments.length === 0) {
+        throw new Error("Nested attribute paths must contain at least one segment.");
+    }
+    if (segments.some((segment) => UNSAFE_PATH_SEGMENTS.has(segment))) {
+        throw new Error(`Unsupported nested attribute path: ${path}`);
+    }
+    return segments;
+}
+function updateNestedRecord(current, segments, value) {
+    const [head, ...rest] = segments;
+    if (typeof head !== "string") {
+        return current ?? {};
+    }
+    if (rest.length === 0) {
+        return {
+            ...(current ?? {}),
+            [head]: value,
+        };
+    }
+    const nextCurrent = current && isRecord(current[head]) ? current[head] : undefined;
+    return {
+        ...(current ?? {}),
+        [head]: updateNestedRecord(nextCurrent, rest, value),
+    };
+}
+export function createAttributeUpdater(attributes, setAttributes, validate, onValidationError) {
+    return (key, value) => {
+        const nextAttributes = mergeAttributeUpdate(attributes, key, value);
+        const validation = validate(nextAttributes);
+        if (validation.isValid) {
+            const patch = validation.data && typeof validation.data === "object"
+                ? toChangedAttributePatch(attributes, validation.data)
+                : toAttributePatch(key, value);
+            setAttributes(patch);
+            return true;
+        }
+        onValidationError?.(validation, key);
+        return false;
+    };
+}
+export function mergeNestedAttributeUpdate(attributes, path, value) {
+    return {
+        ...attributes,
+        ...toNestedAttributePatch(attributes, path, value),
+    };
+}
+export function toAttributePatch(key, value) {
+    return {
+        [key]: value,
+    };
+}
+export function toNestedAttributePatch(attributes, path, value) {
+    const [root, ...rest] = getNestedPathSegments(path);
+    if (rest.length === 0) {
+        return toAttributePatch(root, value);
+    }
+    const currentRoot = isRecord(attributes[root])
+        ? attributes[root]
+        : undefined;
+    return {
+        [root]: updateNestedRecord(currentRoot, rest, value),
+    };
+}
+export function createNestedAttributeUpdater(attributes, setAttributes, validate, onValidationError) {
+    return (path, value) => {
+        const nextAttributes = mergeNestedAttributeUpdate(attributes, path, value);
+        const validation = validate(nextAttributes);
+        if (validation.isValid) {
+            const patch = validation.data && typeof validation.data === "object"
+                ? toChangedAttributePatch(attributes, validation.data)
+                : toNestedAttributePatch(attributes, path, value);
+            setAttributes(patch);
+            return true;
+        }
+        onValidationError?.(validation, path);
+        return false;
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wp-typia/block-runtime",
-  "version": "0.2.3",
-  "description": "Prototype block runtime facade for wp-typia generated-project helpers",
+  "version": "0.3.0",
+  "description": "Generated-project runtime and metadata sync helpers for wp-typia",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,6 +11,16 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./blocks": {
+      "types": "./dist/blocks.d.ts",
+      "import": "./dist/blocks.js",
+      "default": "./dist/blocks.js"
+    },
+    "./metadata-core": {
+      "types": "./dist/metadata-core.d.ts",
+      "import": "./dist/metadata-core.js",
+      "default": "./dist/metadata-core.js"
+    },
     "./defaults": {
       "types": "./dist/defaults.d.ts",
       "import": "./dist/defaults.js",
@@ -41,7 +51,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
-    "test:prepare": "bun run --filter @wp-typia/create build && bun run build",
+    "test:prepare": "bun run build",
     "test": "bun run test:prepare && bun test tests",
     "test:coverage": "bun run test:prepare && bun test tests --coverage --coverage-reporter=text --coverage-reporter=lcov --coverage-dir=coverage",
     "typecheck": "tsc -p tsconfig.json --noEmit"
@@ -74,9 +84,10 @@
     }
   },
   "dependencies": {
-    "@wp-typia/create": "^0.10.1"
+    "typescript": "^5.9.2"
   },
   "devDependencies": {
-    "typescript": "^5.9.2"
+    "react": "^19.2.0",
+    "typia": "^12.0.1"
   }
 }