cogsbox-state 0.5.472 → 0.5.474

package/src/utility.ts

@@ -1,5 +1,5 @@
-import type { InitialStateType, TransformedStateType } from './CogsState';
-import { getGlobalStore } from './store';
+import type { TransformedStateType, CogsInitialState } from './CogsState';
+
 export const isObject = (item: any): item is Record<string, any> => {
   return (
     item && typeof item === 'object' && !Array.isArray(item) && item !== null
@@ -318,15 +318,42 @@ export function getArrayLengthDifferencesArray(obj1: any, obj2: any) {
   return convertedDiff;
 }
 
+export function debounce<F extends (...args: any[]) => any>(
+  func: (...args: any[]) => any,
+  wait: number
+): F & { cancel: () => void } {
+  let timeoutID: NodeJS.Timeout | null = null;
+
+  const debounced: any = (...args: Parameters<F>) => {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+
+    timeoutID = setTimeout(() => func(...args), wait);
+  };
+
+  debounced.cancel = () => {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+      timeoutID = null;
+    }
+  };
+
+  return debounced as DebouncedFunction<F>;
+}
+export type DebouncedFunction<F extends (...args: any[]) => any> = F & {
+  cancel: () => void;
+};
+
 export function transformStateFunc<State extends unknown>(initialState: State) {
-  const isInitialStateType = (state: any): state is InitialStateType<State> => {
+  const isInitialStateType = (state: any): state is CogsInitialState<State> => {
     return Object.values(state).some((value) =>
       value?.hasOwnProperty('initialState')
     );
   };
   let initalOptions: GenericObject = {};
   const transformInitialState = (
-    state: InitialStateType<State>
+    state: CogsInitialState<State>
   ): GenericObject | GenericObject[] => {
     const transformedState: GenericObject | GenericObject[] = {};
     Object.entries(state).forEach(([key, value]) => {
@@ -351,30 +378,3 @@ export function transformStateFunc<State extends unknown>(initialState: State) {
     GenericObject,
   ];
 }
-
-export function debounce<F extends (...args: any[]) => any>(
-  func: (...args: any[]) => any,
-  wait: number
-): F & { cancel: () => void } {
-  let timeoutID: NodeJS.Timeout | null = null;
-
-  const debounced: any = (...args: Parameters<F>) => {
-    if (timeoutID) {
-      clearTimeout(timeoutID);
-    }
-
-    timeoutID = setTimeout(() => func(...args), wait);
-  };
-
-  debounced.cancel = () => {
-    if (timeoutID) {
-      clearTimeout(timeoutID);
-      timeoutID = null;
-    }
-  };
-
-  return debounced as DebouncedFunction<F>;
-}
-export type DebouncedFunction<F extends (...args: any[]) => any> = F & {
-  cancel: () => void;
-};

package/src/validation.ts

@@ -0,0 +1,84 @@
+// in utils.ts
+
+import { UpdateTypeDetail } from './CogsState'; // Adjust path as needed
+import { getGlobalStore } from './store';
+import { isDeepEqual } from './utility';
+import { ZodType } from 'zod';
+
+/**
+ * THIS IS THE CORRECTED FUNCTION.
+ */
+export function runValidation(
+  operation: UpdateTypeDetail,
+  trigger: 'onBlur' | 'onChange' | 'programmatic'
+) {
+  const {
+    getInitialOptions,
+    getShadowMetadata,
+    setShadowMetadata,
+    notifyPathSubscribers,
+  } = getGlobalStore.getState();
+  const { stateKey, path, newValue, updateType } = operation;
+
+  if (updateType !== 'update') {
+    return;
+  }
+
+  const validationOptions = getInitialOptions(stateKey)?.validation;
+  if (!validationOptions) return;
+
+  const currentMeta = getShadowMetadata(stateKey, path) || {};
+  const fieldSchema = currentMeta.typeInfo?.schema as ZodType | undefined;
+  const currentStatus = currentMeta.validation?.status;
+
+  let shouldValidate = false;
+  let severity: 'error' | 'warning' = 'error';
+
+  if (trigger === 'onBlur' && validationOptions.onBlur) {
+    shouldValidate = true;
+    severity = validationOptions.onBlur;
+  } else if (trigger === 'onChange' && validationOptions.onChange) {
+    shouldValidate = true;
+    severity = validationOptions.onChange;
+  } else if (trigger === 'onChange' && currentStatus === 'INVALID') {
+    shouldValidate = true;
+    severity = 'warning';
+  } else if (trigger === 'programmatic') {
+    if (validationOptions.onBlur || validationOptions.onChange) {
+      shouldValidate = true;
+
+      severity =
+        validationOptions.onBlur || validationOptions.onChange || 'error';
+    }
+  }
+
+  if (!shouldValidate || !fieldSchema) {
+    return;
+  }
+
+  // The rest of the function is the same.
+  const result = fieldSchema.safeParse(newValue);
+  const newValidationState = {
+    status: result.success ? 'VALID' : 'INVALID',
+    errors: result.success
+      ? []
+      : [
+          {
+            source: 'client',
+            message: result.error.issues[0]?.message || 'Invalid value',
+            severity: severity,
+          },
+        ],
+    lastValidated: Date.now(),
+  };
+
+  if (!isDeepEqual(currentMeta.validation, newValidationState)) {
+    setShadowMetadata(stateKey, path, {
+      ...currentMeta,
+      validation: newValidationState,
+    });
+    notifyPathSubscribers([stateKey, ...path].join('.'), {
+      type: 'VALIDATION_UPDATE',
+    });
+  }
+}