cogsbox-shape 0.5.201 → 0.5.202

package/cogsbox-shape-state/dist/example/type-hover-example.d.ts

@@ -0,0 +1 @@
+export declare function Example(): null;

package/cogsbox-shape-state/dist/example/type-hover-example.js

@@ -0,0 +1,38 @@
+/**
+ * Minimal end-to-end example — open and hover inside Example.
+ * Run from cogsbox-shape repo after: pnpm build
+ */
+import { createCogsState } from "cogsbox-state";
+import { createSchemaBox, s, schema } from "cogsbox-shape";
+import { z } from "zod";
+import { createShapePlugin } from "../plugin.js";
+const taskItemSchema = z.object({
+    id: z.number(),
+    title: z.string(),
+    done: z.boolean(),
+});
+const taskManagerSchema = schema({
+    _tableName: "client",
+    tasks: s.clientInput({
+        value: [],
+        schema: z.array(taskItemSchema),
+    }),
+    filter: s.clientInput({
+        value: "all",
+        schema: z.string(),
+    }),
+});
+const demoBox = createSchemaBox({
+    taskManager: taskManagerSchema,
+}, {});
+const shapePlugin = createShapePlugin(demoBox);
+const { useCogsState } = createCogsState({}, { plugins: [shapePlugin] });
+export function Example() {
+    const taskManager = useCogsState("taskManager");
+    // hover ↓
+    const tasks = taskManager.tasks;
+    const filter = taskManager.filter;
+    void tasks;
+    void filter;
+    return null;
+}

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

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

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

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

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

@@ -1,11 +1,12 @@
-type ShapeBoxEntry = {
-    generateDefaults: () => any;
-    stateType?: any;
+/** Minimal shape of a createSchemaBox entry — matches journalSchemaBox.journalTechnical etc. */
+export type ShapeSchemaBoxEntry = {
+    /** Field-key → value map from DeriveStateType (not z.infer on a flattened client object). */
+    stateType: Record<string, unknown>;
+    generateDefaults: () => unknown;
 };
-type InferShapeEntryState<TEntry> = TEntry extends {
-    stateType: infer S;
-} ? S : TEntry extends {
-    generateDefaults: () => infer R;
-} ? R : never;
-export declare function createShapePlugin<const TBox extends Record<string, ShapeBoxEntry>>(box: TBox): import("cogsbox-state").CogsPluginBuilder<"shape", undefined, unknown, unknown, never, {}, false, false, false, false, false, true, { [K in keyof TBox]: InferShapeEntryState<TBox[K]>; }>;
-export {};
+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>>;

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

@@ -1,14 +1,15 @@
 import { createPluginContext } from "cogsbox-state";
 const { createPlugin } = createPluginContext();
+function buildInitialState(box) {
+    const state = {};
+    for (const key of Object.keys(box)) {
+        const entry = box[key];
+        if (!entry)
+            continue;
+        state[key] = entry.generateDefaults();
+    }
+    return state;
+}
 export function createShapePlugin(box) {
-    return createPlugin("shape").initialState(() => {
-        const state = {};
-        for (const key of Object.keys(box)) {
-            const entry = box[key];
-            if (!entry)
-                continue;
-            state[key] = entry.generateDefaults();
-        }
-        return state;
-    });
+    return createPlugin("shape").initialState(() => buildInitialState(box));
 }

package/dist/schema.d.ts

@@ -179,9 +179,28 @@ export type Reference<TGetter extends () => any> = {
     getter: TGetter;
 };
 interface ShapeAPI {
-    clientInput: <const TValue>(value: TValue | ((tools: {
+    clientInput<const TValue, const TSchema extends z.ZodTypeAny>(options: {
+        value: TValue | ((tools: {
+            uuid: () => string;
+        }) => TValue);
+        schema: TSchema | ((base: ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>) => TSchema);
+        clientPk?: boolean | ((val: any) => boolean);
+    }): Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, TSchema, TSchema>;
+    clientInput<const TValue>(options: {
+        value: TValue | ((tools: {
+            uuid: () => string;
+        }) => TValue);
+        schema?: never;
+        clientPk?: boolean | ((val: any) => boolean);
+    }): Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
+    clientInput<const TSchema extends z.ZodTypeAny>(options: {
+        value?: never;
+        schema: TSchema;
+        clientPk?: boolean | ((val: any) => boolean);
+    }): Builder<"clientInput", null, z.ZodUndefined, z.infer<TSchema>, TSchema, TSchema>;
+    clientInput<const TValue>(value: TValue | ((tools: {
         uuid: () => string;
-    }) => TValue)) => Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
+    }) => TValue)): Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
     sqlite: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "sqlite">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
     postgres: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "postgres">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
     mysql: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "mysql">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;

package/dist/schema.js

@@ -49,8 +49,29 @@ function createSqlBuilder(dialect, sqlConfig) {
         validationZod: sqlZodType,
     });
 }
+function isClientInputOptions(value) {
+    return (value !== undefined &&
+        typeof value === "object" &&
+        value !== null &&
+        !isFunction(value) &&
+        !("_def" in value) &&
+        !("parse" in value) &&
+        ("value" in value || "schema" in value || "clientPk" in value));
+}
 export const s = {
-    clientInput: (value) => {
+    clientInput: (...args) => {
+        const first = args[0];
+        if (isClientInputOptions(first)) {
+            return createBuilder({
+                stage: "sql",
+                sqlConfig: null,
+                sqlZod: z.undefined(),
+                initialValue: undefined,
+                clientZod: z.undefined(),
+                validationZod: z.undefined(),
+            }).clientInput(first);
+        }
+        const value = first;
         const sample = isFunction(value) ? value({ uuid }) : value;
         let inferredZodType;
         if (typeof sample === "string") {

package/package.json

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