cogsbox-state 0.5.455 → 0.5.457

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-state",
-  "version": "0.5.455",
+  "version": "0.5.457",
   "description": "React state management library with form controls and server sync",
   "type": "module",
   "main": "./dist/index.js",

package/src/CogsState.tsx

@@ -38,6 +38,7 @@ import { Operation } from 'fast-json-patch';
 import { useInView } from 'react-intersection-observer';
 import * as z3 from 'zod/v3';
 import * as z4 from 'zod/v4';
+import z from 'zod';
 
 type Prettify<T> = T extends any ? { [K in keyof T]: T[K] } : never;
 
@@ -534,15 +535,6 @@ export function addStateOptions<T extends unknown>(
 ) {
   return { initialState: initialState, formElements, validation } as T;
 }
-type UseCogsStateHook<
-  T extends Record<string, any>,
-  apiParams extends Record<string, any> = never,
-> = <StateKey extends keyof TransformedStateType<T>>(
-  stateKey: StateKey,
-  options?: Prettify<
-    OptionsType<TransformedStateType<T>[StateKey]> & { apiParams?: apiParams }
-  >
-) => StateObject<TransformedStateType<T>[StateKey]>;
 
 // Define the type for the options setter using the Transformed state
 type SetCogsOptionsFunc<T extends Record<string, any>> = <
@@ -552,39 +544,35 @@ type SetCogsOptionsFunc<T extends Record<string, any>> = <
   options: OptionsType<TransformedStateType<T>[StateKey]>
 ) => void;
 
-// Define the final API object shape
-type CogsApi<
-  T extends Record<string, any>,
-  apiParams extends Record<string, any> = never,
-> = {
-  useCogsState: UseCogsStateHook<T, apiParams>;
-  setCogsOptions: SetCogsOptionsFunc<T>;
-};
-
-// Minimal change - just add a second parameter to detect sync schema
 export const createCogsState = <State extends Record<StateKeys, unknown>>(
   initialState: State,
   opt?: {
     formElements?: FormsElementsType<State>;
     validation?: ValidationOptionsType;
-    // Add this flag to indicate it's from sync schema
     __fromSyncSchema?: boolean;
     __syncNotifications?: Record<string, Function>;
+    __apiParamsMap?: Record<string, any>; // Add this
   }
 ) => {
-  // Keep ALL your existing code exactly the same
   let newInitialState = initialState;
 
   const [statePart, initialOptionsPart] =
     transformStateFunc<State>(newInitialState);
 
-  // Only addition - store notifications if provided
+  // Store notifications if provided
   if (opt?.__fromSyncSchema && opt?.__syncNotifications) {
     getGlobalStore
       .getState()
       .setInitialStateOptions('__notifications', opt.__syncNotifications);
   }
 
+  // Store apiParams map if provided
+  if (opt?.__fromSyncSchema && opt?.__apiParamsMap) {
+    getGlobalStore
+      .getState()
+      .setInitialStateOptions('__apiParamsMap', opt.__apiParamsMap);
+  }
+
   // ... rest of your existing createCogsState code unchanged ...
 
   Object.keys(statePart).forEach((key) => {
@@ -637,14 +625,20 @@ export const createCogsState = <State extends Record<StateKeys, unknown>>(
     stateKey: StateKey,
     options?: Prettify<OptionsType<(typeof statePart)[StateKey]>>
   ) => {
-    // ... your existing useCogsState implementation ...
     const [componentId] = useState(options?.componentId ?? uuidv4());
+    const apiParamsSchema = opt?.__apiParamsMap?.[stateKey as string];
+
+    // Merge apiParams into options
+    const enhancedOptions = {
+      ...options,
+      apiParamsSchema, // Add the schema here
+    } as any;
+
     setOptions({
       stateKey,
-      options: options as any,
+      options: enhancedOptions,
       initialOptionsPart,
     });
-
     const thiState =
       getGlobalStore.getState().getShadowValue(stateKey as string) ||
       statePart[stateKey as string];
@@ -683,12 +677,38 @@ export const createCogsState = <State extends Record<StateKeys, unknown>>(
 
   return { useCogsState, setCogsOptions } as CogsApi<State>;
 };
+// Fix for UseCogsStateHook to support per-key apiParams
+type UseCogsStateHook<
+  T extends Record<string, any>,
+  TApiParamsMap extends Record<string, any> = Record<string, never>,
+> = <StateKey extends keyof TransformedStateType<T>>(
+  stateKey: StateKey,
+  options?: Prettify<
+    OptionsType<TransformedStateType<T>[StateKey]> & {
+      apiParams?: StateKey extends keyof TApiParamsMap
+        ? TApiParamsMap[StateKey]
+        : never;
+    }
+  >
+) => StateObject<TransformedStateType<T>[StateKey]>;
+
+// Updated CogsApi type
+type CogsApi<
+  T extends Record<string, any>,
+  TApiParamsMap extends Record<string, any> = Record<string, never>,
+> = {
+  useCogsState: UseCogsStateHook<T, TApiParamsMap>;
+  setCogsOptions: SetCogsOptionsFunc<T>;
+};
+
+// Fixed createCogsStateFromSync return type
 export function createCogsStateFromSync<
   TSyncSchema extends {
     schemas: Record<
       string,
       {
         schemas: { defaultValues: any };
+        apiParamsSchema?: any;
         [key: string]: any;
       }
     >;
@@ -701,21 +721,34 @@ export function createCogsStateFromSync<
     [K in keyof TSyncSchema['schemas']]: TSyncSchema['schemas'][K]['schemas']['defaultValues'];
   },
   {
-    [K in keyof TSyncSchema['schemas']]: TSyncSchema['schemas'][K]['apiParams'];
-  }[keyof {
-    [K in keyof TSyncSchema['schemas']]: TSyncSchema['schemas'][K]['apiParams'];
-  }]
+    [K in keyof TSyncSchema['schemas']]: TSyncSchema['schemas'][K]['apiParamsSchema'] extends z.ZodObject<
+      infer P
+    >
+      ? P
+      : never;
+  }
 > {
   const schemas = syncSchema.schemas;
   const initialState: any = {};
+  const apiParamsMap: any = {};
 
-  // Extract defaultValues from each entry
+  // Extract defaultValues AND apiParams from each entry
   for (const key in schemas) {
     const entry = schemas[key];
     initialState[key] = entry?.schemas?.defaultValues || {};
+
+    // Store the apiParamsSchema for each key
+    if (entry?.apiParamsSchema) {
+      apiParamsMap[key] = entry.apiParamsSchema;
+    }
   }
 
-  return createCogsState(initialState);
+  // Pass the sync schema metadata to createCogsState
+  return createCogsState(initialState, {
+    __fromSyncSchema: true,
+    __syncNotifications: syncSchema.notifications,
+    __apiParamsMap: apiParamsMap,
+  }) as any;
 }
 
 const {
@@ -1044,10 +1077,12 @@ export function useCogsStateFn<TStateObject extends unknown>(
     syncUpdate,
     dependencies,
     serverState,
+    apiParamsSchema,
   }: {
     stateKey?: string;
     componentId?: string;
     defaultState?: TStateObject;
+    apiParamsSchema?: z.ZodObject<any>; // Add this type
   } & OptionsType<TStateObject> = {}
 ) {
   const [reactiveForce, forceUpdate] = useState({}); //this is the key to reactivity