cogsbox-shape 0.5.217 → 0.5.219

package/cogsbox-shape-state/dist/plugin.d.ts

@@ -68,6 +68,8 @@ type ShapeKeyValidationParams = {
     path: string[];
     keys?: readonly string[];
     getState?: () => unknown;
+    /** When true (default), writes filtered issues to shadow validation metadata. */
+    persist?: boolean;
 };
 export declare function wireShapeValidationOptions(box: ShapeSchemaBox, params: TransformStateParams): void;
 /** Cross-field refine errors only — field rules are handled by state via setOptions. */

package/cogsbox-shape-state/dist/plugin.js

@@ -117,30 +117,79 @@ function addValidationIssues(params, issues) {
     params.addZodErrors(issues);
     notifyValidationPaths(params.stateKey, issues.map((issue) => issue.path));
 }
-function setValidationIssues(stateKey, issues) {
-    if (issues.length === 0)
-        return;
+function createShadowValidationBridge(stateKey) {
     const store = getGlobalStore.getState();
-    for (const issue of issues) {
-        const currentMeta = store.getShadowMetadata(stateKey, issue.path) || {};
-        store.setShadowMetadata(stateKey, issue.path, {
-            ...currentMeta,
-            validation: {
-                status: "INVALID",
-                errors: [
-                    {
-                        source: "client",
-                        message: issue.message,
-                        severity: "error",
-                        code: issue.code,
+    return {
+        stateKey,
+        getState: () => store.getShadowValue(stateKey, []),
+        addZodErrors: (issues) => {
+            for (const error of issues) {
+                const errorPath = error.path;
+                const currentMeta = store.getShadowMetadata(stateKey, errorPath) || {};
+                store.setShadowMetadata(stateKey, errorPath, {
+                    ...currentMeta,
+                    validation: {
+                        status: "INVALID",
+                        errors: [
+                            {
+                                source: "client",
+                                message: error.message,
+                                severity: "error",
+                                code: error.code,
+                            },
+                        ],
+                        lastValidated: Date.now(),
+                        validatedValue: undefined,
                     },
-                ],
-                lastValidated: Date.now(),
-                validatedValue: store.getShadowValue(stateKey, issue.path),
-            },
-        });
+                });
+            }
+        },
+        clearZodErrors: (paths) => {
+            for (const path of paths) {
+                const currentMeta = store.getShadowMetadata(stateKey, path) || {};
+                store.setShadowMetadata(stateKey, path, {
+                    ...currentMeta,
+                    validation: {
+                        status: "NOT_VALIDATED",
+                        errors: [],
+                        lastValidated: Date.now(),
+                        validatedValue: undefined,
+                    },
+                });
+            }
+        },
+    };
+}
+function notifyStateComponents(stateKey) {
+    const store = getGlobalStore.getState();
+    const stateEntry = store.getShadowMetadata(stateKey, []);
+    if (!stateEntry?.components)
+        return;
+    const updates = new Set();
+    stateEntry.components.forEach((component) => {
+        const reactiveTypes = component
+            ? Array.isArray(component.reactiveType)
+                ? component.reactiveType
+                : [component.reactiveType || "component"]
+            : null;
+        if (!reactiveTypes?.includes("none")) {
+            updates.add(() => component.forceUpdate());
+        }
+    });
+    queueMicrotask(() => {
+        updates.forEach((update) => update());
+    });
+}
+function persistValidateGroupResults(params, keys, mapped) {
+    const validationParams = createShadowValidationBridge(params.stateKey);
+    const keyPaths = keys.map((key) => [...params.path, key]);
+    const activeKeys = new Set(mapped.map((issue) => pathKey(issue.path)));
+    const stalePaths = keyPaths.filter((targetPath) => !activeKeys.has(pathKey(targetPath)));
+    clearValidationPaths(validationParams, stalePaths);
+    if (mapped.length > 0) {
+        addValidationIssues(validationParams, mapped);
     }
-    notifyValidationPaths(stateKey, issues.map((issue) => issue.path));
+    notifyStateComponents(params.stateKey);
 }
 function issueMatchesSelectedKeys(issue, parentPath, selectedKeys) {
     const issuePath = issue.path.map(String);
@@ -285,20 +334,14 @@ export function validateShapeKeys(box, params) {
     const clientSchema = entry?.validators?.client ?? entry?.schemas.client;
     if (!entry || !clientSchema)
         return { success: true, results: [] };
-    const store = getGlobalStore.getState();
-    const rootState = params.getState?.() ?? store.getShadowValue(params.stateKey, []);
+    const rootState = params.getState?.() ?? getGlobalStore.getState().getShadowValue(params.stateKey, []);
     const result = clientSchema.safeParse(rootState);
     const selectedKeys = params.keys ? new Set(params.keys) : null;
-    const targetPaths = params.keys?.map((key) => [...params.path, key]) ??
-        (result.success
-            ? []
-            : mapZodIssues(result.error.issues).map((issue) => issue.path));
+    const shouldPersist = params.persist !== false && !!params.keys?.length;
     if (result.success) {
-        clearValidationPaths({
-            stateKey: params.stateKey,
-            getState: () => rootState,
-            addZodErrors: () => { },
-        }, targetPaths);
+        if (shouldPersist) {
+            persistValidateGroupResults(params, params.keys, []);
+        }
         return {
             success: true,
             results: params.keys?.map((key) => ({
@@ -313,14 +356,9 @@ export function validateShapeKeys(box, params) {
         ? result.error.issues.filter((issue) => issueMatchesSelectedKeys(issue, params.path, selectedKeys))
         : result.error.issues;
     const mapped = mapZodIssues(issues);
-    const activeKeys = new Set(mapped.map((issue) => pathKey(issue.path)));
-    const stalePaths = targetPaths.filter((targetPath) => !activeKeys.has(pathKey(targetPath)));
-    clearValidationPaths({
-        stateKey: params.stateKey,
-        getState: () => rootState,
-        addZodErrors: () => { },
-    }, stalePaths);
-    setValidationIssues(params.stateKey, mapped);
+    if (shouldPersist) {
+        persistValidateGroupResults(params, params.keys, mapped);
+    }
     return {
         success: mapped.length === 0,
         results: params.keys?.map((key) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.217",
+  "version": "0.5.219",
   "description": "A TypeScript library for creating type-safe database schemas with Zod validation, SQL type definitions, and automatic client/server transformations. Unifies client, server, and database types through a single schema definition, with built-in support for relationships and serialization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",