cogsbox-shape 0.5.211 → 0.5.213

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

@@ -1,23 +1,11 @@
-import { type ChainMethodContext } from "cogsbox-state";
 import { z } from "zod";
 /** Minimal shape of a createSchemaBox entry — matches journalSchemaBox.journalTechnical etc. */
 export type ShapeRefineInfo = {
     fieldToGroup: Record<string, number[]>;
     groups: {
-        deps: readonly string[] | null;
+        deps: string[] | null;
     }[];
 };
-export type ShapeIssue = {
-    path: string[];
-    message: string;
-    code?: string;
-};
-export type ShapeErrorGroup = {
-    hasErrors: boolean;
-    message: string;
-    issues: ShapeIssue[];
-};
-export type ShapeErrorGroups = Record<string, ShapeErrorGroup>;
 export type ShapeSchemaBoxEntry = {
     /** Field-key → value map from DeriveStateType (not z.infer on a flattened client object). */
     stateType: Record<string, unknown>;
@@ -49,6 +37,7 @@ type FormUpdateParams = {
     path: string[];
     event: {
         activityType: string;
+        details?: Record<string, unknown>;
     };
     getState: () => unknown;
     addZodErrors: (errors: Array<{
@@ -56,26 +45,12 @@ type FormUpdateParams = {
         message: string;
         code?: string;
     }>) => void;
-    clearZodErrors: (paths: string[][]) => void;
-    setErrorGroups?: (parentPath: string[], groups: ShapeErrorGroups) => void;
+    clearZodErrors?: (paths: string[][]) => void;
 };
-type MutableTuple<T> = T extends readonly [...infer TItems] ? TItems : never;
-type ExtractShapeRefineGroupFields<TEntry> = TEntry extends {
-    refineInfo?: {
-        groups: readonly (infer TGroup)[];
-    };
-} ? TGroup extends {
-    deps: infer TDeps;
-} ? TDeps extends readonly string[] ? MutableTuple<TDeps> : never : never : never;
-type ShapeRefineGroupFields<TBox extends ShapeSchemaBox> = [
-    ExtractShapeRefineGroupFields<TBox[keyof TBox]>
-] extends [never] ? string[] : ExtractShapeRefineGroupFields<TBox[keyof TBox]>;
 export declare function wireShapeValidationOptions(box: ShapeSchemaBox, params: TransformStateParams): void;
 /** Cross-field refine errors only — field rules are handled by state via setOptions. */
 export declare function validateShapeRefines(box: ShapeSchemaBox, params: FormUpdateParams): void;
 export declare function createShapePlugin<const TBox extends ShapeSchemaBox>(box: TBox): import("cogsbox-state").CogsPluginBuilder<"shape", {
     logs: boolean | undefined;
-}, unknown, unknown, never, {
-    $errorGroups: import("cogsbox-state").ChainMethodDefinition<(_ctx: ChainMethodContext, ...fields: ShapeRefineGroupFields<TBox>) => ShapeErrorGroup>;
-}, true, false, true, true, false, true, InferShapeBoxState<TBox>>;
+}, unknown, unknown, never, {}, true, false, true, false, false, true, InferShapeBoxState<TBox>>;
 export {};

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

@@ -1,19 +1,8 @@
-import { createPluginContext } from "cogsbox-state";
+import { createPluginContext, getGlobalStore } from "cogsbox-state";
 import { z } from "zod";
-const emptyErrorGroup = {
-    hasErrors: false,
-    message: "",
-    issues: [],
-};
 function pathKey(path) {
     return path.join("\0");
 }
-function errorGroupStorageKey(stateKey, parentPath) {
-    return [stateKey, ...parentPath].join("\0");
-}
-function groupKey(fields) {
-    return fields.join("+");
-}
 function resolveRelatedPaths(blurPath, relatedFields) {
     const parent = blurPath.slice(0, -1);
     return [...relatedFields].map((field) => [...parent, field]);
@@ -25,6 +14,100 @@ function mapZodIssues(issues) {
         code: issue.code,
     }));
 }
+function cloneStateForInputEvent(state, path, value) {
+    if (path.length === 0)
+        return value;
+    if (state === null || typeof state !== "object")
+        return state;
+    const root = Array.isArray(state)
+        ? [...state]
+        : { ...state };
+    let cursor = root;
+    for (let index = 0; index < path.length - 1; index++) {
+        const segment = path[index];
+        if (Array.isArray(cursor)) {
+            const arrayIndex = Number(segment);
+            if (!Number.isInteger(arrayIndex))
+                return root;
+            const next = cursor[arrayIndex];
+            const cloned = next && typeof next === "object"
+                ? Array.isArray(next)
+                    ? [...next]
+                    : { ...next }
+                : {};
+            cursor[arrayIndex] = cloned;
+            cursor = cloned;
+        }
+        else {
+            const next = cursor[segment];
+            const cloned = next && typeof next === "object"
+                ? Array.isArray(next)
+                    ? [...next]
+                    : { ...next }
+                : {};
+            cursor[segment] = cloned;
+            cursor = cloned;
+        }
+    }
+    const leaf = path[path.length - 1];
+    if (Array.isArray(cursor)) {
+        const arrayIndex = Number(leaf);
+        if (Number.isInteger(arrayIndex))
+            cursor[arrayIndex] = value;
+    }
+    else {
+        cursor[leaf] = value;
+    }
+    return root;
+}
+function getStateForValidation(params) {
+    const state = params.getState();
+    if (params.event.activityType !== "input" ||
+        !("details" in params.event) ||
+        !params.event.details ||
+        typeof params.event.details !== "object" ||
+        !("value" in params.event.details)) {
+        return state;
+    }
+    return cloneStateForInputEvent(state, params.path, params.event.details.value);
+}
+function notifyValidationPaths(stateKey, paths) {
+    const store = getGlobalStore.getState();
+    for (const path of paths) {
+        store.notifyPathSubscribers([stateKey, ...path].join("."), {
+            type: "VALIDATION_UPDATE",
+        });
+    }
+}
+function clearValidationPaths(params, paths) {
+    if (paths.length === 0)
+        return;
+    if (params.clearZodErrors) {
+        params.clearZodErrors(paths);
+        notifyValidationPaths(params.stateKey, paths);
+        return;
+    }
+    const store = getGlobalStore.getState();
+    for (const path of paths) {
+        const currentMeta = store.getShadowMetadata(params.stateKey, path) || {};
+        store.setShadowMetadata(params.stateKey, path, {
+            ...currentMeta,
+            validation: {
+                status: "NOT_VALIDATED",
+                errors: [],
+                lastValidated: Date.now(),
+                validatedValue: undefined,
+            },
+        });
+    }
+    notifyValidationPaths(params.stateKey, paths);
+}
+function addValidationIssues(params, issues) {
+    if (issues.length === 0)
+        return;
+    params.addZodErrors(issues);
+    notifyValidationPaths(params.stateKey, issues.map((issue) => issue.path));
+}
 function getRelatedFields(entry, field) {
     const groupIndexes = entry.refineInfo?.fieldToGroup[field];
     if (!groupIndexes?.length)
@@ -43,23 +126,6 @@ function issueMatchesRelatedFields(issue, relatedFields) {
     const leaf = String(issue.path.at(-1) ?? "");
     return relatedFields.has(leaf);
 }
-function buildShapeErrorGroups(entry, groupIndexes, fallbackField, issues) {
-    const groups = {};
-    for (const index of groupIndexes) {
-        const deps = entry.refineInfo?.groups[index]?.deps ?? [fallbackField];
-        const relatedFields = new Set(deps);
-        const mapped = mapZodIssues(issues.filter((issue) => issueMatchesRelatedFields(issue, relatedFields)));
-        groups[groupKey(deps)] =
-            mapped.length > 0
-                ? {
-                    hasErrors: true,
-                    message: mapped[0]?.message ?? "",
-                    issues: mapped,
-                }
-                : emptyErrorGroup;
-    }
-    return groups;
-}
 export function wireShapeValidationOptions(box, params) {
     const entry = box[params.stateKey];
     if (!entry)
@@ -73,8 +139,10 @@ export function wireShapeValidationOptions(box, params) {
 }
 /** Cross-field refine errors only — field rules are handled by state via setOptions. */
 export function validateShapeRefines(box, params) {
-    if (params.event.activityType !== "blur")
+    if (params.event.activityType !== "blur" &&
+        params.event.activityType !== "input") {
         return;
+    }
     const entry = box[params.stateKey];
     const clientSchema = entry?.validators?.client ?? entry?.schemas.client;
     if (!entry || !clientSchema)
@@ -82,29 +150,21 @@ export function validateShapeRefines(box, params) {
     const field = params.path.at(-1);
     if (!field)
         return;
-    const groupIndexes = entry.refineInfo?.fieldToGroup[field];
     const relatedFields = getRelatedFields(entry, field);
     if (!relatedFields)
         return;
     const relatedPaths = resolveRelatedPaths(params.path, relatedFields);
-    const result = clientSchema.safeParse(params.getState());
-    const parentPath = params.path.slice(0, -1);
+    const result = clientSchema.safeParse(getStateForValidation(params));
     if (result.success) {
-        params.setErrorGroups?.(parentPath, buildShapeErrorGroups(entry, groupIndexes ?? [], field, []));
-        params.clearZodErrors(relatedPaths);
+        clearValidationPaths(params, relatedPaths);
         return;
     }
-    params.setErrorGroups?.(parentPath, buildShapeErrorGroups(entry, groupIndexes ?? [], field, result.error.issues));
     const issues = result.error.issues.filter((issue) => issueMatchesRelatedFields(issue, relatedFields));
     const mapped = mapZodIssues(issues);
     const activeKeys = new Set(mapped.map((entry) => pathKey(entry.path)));
     const stalePaths = relatedPaths.filter((targetPath) => !activeKeys.has(pathKey(targetPath)));
-    if (stalePaths.length > 0) {
-        params.clearZodErrors(stalePaths);
-    }
-    if (mapped.length > 0) {
-        params.addZodErrors(mapped);
-    }
+    clearValidationPaths(params, stalePaths);
+    addValidationIssues(params, mapped);
 }
 function buildInitialState(box) {
     const state = {};
@@ -123,30 +183,15 @@ const { createPlugin } = createPluginContext({
     }),
 });
 export function createShapePlugin(box) {
-    const errorGroupsByPath = new Map();
-    const setErrorGroups = (stateKey, parentPath, groups) => {
-        const key = errorGroupStorageKey(stateKey, parentPath);
-        errorGroupsByPath.set(key, {
-            ...errorGroupsByPath.get(key),
-            ...groups,
-        });
-    };
     return createPlugin("shape")
         .initialState(() => buildInitialState(box))
-        .transformState((params) => wireShapeValidationOptions(box, params))
+        .transformState((params) => {
+        wireShapeValidationOptions(box, params);
+    })
         .onFormUpdate((params) => {
         if (params.options?.logs) {
             console.log("[shape]", params.stateKey, params.path, params.event.activityType);
         }
-        validateShapeRefines(box, {
-            ...params,
-            setErrorGroups: (parentPath, groups) => setErrorGroups(params.stateKey, parentPath, groups),
-        });
-    })
-        .methods(({ object }) => ({
-        $errorGroups: object((_ctx, ...fields) => {
-            const key = errorGroupStorageKey(_ctx.stateKey, _ctx.path);
-            return (errorGroupsByPath.get(key)?.[groupKey(fields)] ?? emptyErrorGroup);
-        }),
-    }));
+        validateShapeRefines(box, params);
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.211",
+  "version": "0.5.213",
   "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",