cogsbox-shape 0.5.202 → 0.5.204

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

@@ -1 +1 @@
-export { createShapePlugin, type InferShapeBoxState, type ShapeSchemaBox, type ShapeSchemaBoxEntry, } from "./plugin.js";
+export { createShapePlugin, validateShapeRefines, wireShapeValidationOptions, type InferShapeBoxState, type ShapeRefineInfo, type ShapeSchemaBox, type ShapeSchemaBoxEntry, } from "./plugin.js";

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

@@ -1 +1 @@
-export { createShapePlugin, } from "./plugin.js";
+export { createShapePlugin, validateShapeRefines, wireShapeValidationOptions, } from "./plugin.js";

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

@@ -1,12 +1,51 @@
+import { z } from "zod";
 /** Minimal shape of a createSchemaBox entry — matches journalSchemaBox.journalTechnical etc. */
+export type ShapeRefineInfo = {
+    fieldToGroup: Record<string, number[]>;
+    groups: {
+        deps: string[] | null;
+    }[];
+};
 export type ShapeSchemaBoxEntry = {
     /** Field-key → value map from DeriveStateType (not z.infer on a flattened client object). */
     stateType: Record<string, unknown>;
     generateDefaults: () => unknown;
+    schemas: {
+        client: z.ZodTypeAny;
+    };
+    refineInfo?: ShapeRefineInfo;
 };
 export type ShapeSchemaBox = Record<string, ShapeSchemaBoxEntry>;
 /** Per-box-key state: each entry's field keys stay typed via stateType. */
 export type InferShapeBoxState<TBox extends ShapeSchemaBox> = {
     [K in keyof TBox]: TBox[K]["stateType"];
 };
-export declare function createShapePlugin<const TBox extends ShapeSchemaBox>(box: TBox): import("cogsbox-state").CogsPluginBuilder<"shape", undefined, unknown, unknown, never, {}, false, false, false, false, false, true, InferShapeBoxState<TBox>>;
+type TransformStateParams = {
+    stateKey: string;
+    setOptions: (options: {
+        validation?: {
+            zodSchemaV4?: z.ZodTypeAny;
+            onBlur?: "error" | "warning";
+        };
+    }) => void;
+};
+type FormUpdateParams = {
+    stateKey: string;
+    path: string[];
+    event: {
+        activityType: string;
+    };
+    getState: () => unknown;
+    addZodErrors: (errors: Array<{
+        path: string[];
+        message: string;
+        code?: string;
+    }>) => void;
+};
+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, {}, true, false, true, false, false, true, InferShapeBoxState<TBox>>;
+export {};

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

@@ -1,15 +1,83 @@
 import { createPluginContext } from "cogsbox-state";
-const { createPlugin } = createPluginContext();
+import { z } from "zod";
+function mapZodIssues(issues) {
+    return issues.map((issue) => ({
+        path: issue.path.map(String),
+        message: issue.message,
+        code: issue.code,
+    }));
+}
+function getRelatedFields(entry, field) {
+    const groupIndexes = entry.refineInfo?.fieldToGroup[field];
+    if (!groupIndexes?.length)
+        return null;
+    const related = new Set([field]);
+    for (const index of groupIndexes) {
+        const deps = entry.refineInfo?.groups[index]?.deps;
+        if (!deps)
+            continue;
+        for (const dep of deps)
+            related.add(dep);
+    }
+    return related;
+}
+export function wireShapeValidationOptions(box, params) {
+    const entry = box[params.stateKey];
+    if (!entry)
+        return;
+    params.setOptions({
+        validation: {
+            zodSchemaV4: entry.schemas.client,
+            onBlur: "error",
+        },
+    });
+}
+/** Cross-field refine errors only — field rules are handled by state via setOptions. */
+export function validateShapeRefines(box, params) {
+    if (params.event.activityType !== "blur")
+        return;
+    const entry = box[params.stateKey];
+    const clientSchema = entry?.schemas.client;
+    if (!entry || !clientSchema)
+        return;
+    const field = params.path.at(-1);
+    if (!field)
+        return;
+    const relatedFields = getRelatedFields(entry, field);
+    if (!relatedFields)
+        return;
+    const result = clientSchema.safeParse(params.getState());
+    if (result.success)
+        return;
+    const issues = result.error.issues.filter((issue) => relatedFields.has(String(issue.path[0])));
+    if (issues.length > 0) {
+        params.addZodErrors(mapZodIssues(issues));
+    }
+}
 function buildInitialState(box) {
     const state = {};
     for (const key of Object.keys(box)) {
         const entry = box[key];
         if (!entry)
             continue;
-        state[key] = entry.generateDefaults();
+        state[key] =
+            entry.generateDefaults();
     }
     return state;
 }
+const { createPlugin } = createPluginContext({
+    options: z.object({
+        logs: z.boolean().optional(),
+    }),
+});
 export function createShapePlugin(box) {
-    return createPlugin("shape").initialState(() => buildInitialState(box));
+    return createPlugin("shape")
+        .initialState(() => buildInitialState(box))
+        .transformState((params) => wireShapeValidationOptions(box, params))
+        .onFormUpdate((params) => {
+        if (params.options?.logs) {
+            console.log("[shape]", params.stateKey, params.path, params.event.activityType);
+        }
+        validateShapeRefines(box, params);
+    });
 }

package/package.json

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