tainted wasn't updated correctly for array data.

added more taint options to form store.

Author: ciscoheat

CHANGELOG.md

@@ -17,12 +17,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- `tainted` wasn't updated correctly for array data.
 - `dataType: 'json'` now handles large (+1Mb) payloads.
 
 ### Added
 
 - Added `validate` to `superForm`, which can be used to validate any field, at any time.
-- The option `{ taint: boolean }` has been added to `form.set` and `form.update`.
+- The option `{ taint: boolean | 'untaint' | 'untaint-all' }` has been added to `form.set` and `form.update`.
 - The `resetForm` option can now take an `async () => boolean` function to determine whether the form should be resetted or not.
 
 ## [0.7.1] - 2023-04-17

src/compare.test.ts

@@ -325,28 +325,58 @@ describe('Proxies', () => {
   });
 });
 
-test('Compare paths', () => {
-  const obj1 = {
-    name: 'Obj1',
-    tags: [{ name: 'tag1' }, { name: 'tag2' }],
-    deep: {
-      test: true
-    }
-  };
+describe('Path comparisons', () => {
+  test('Basic path comparison', () => {
+    const obj1 = {
+      name: 'Obj1',
+      tags: [{ name: 'tag1' }, { name: 'tag2' }],
+      deep: {
+        test: true
+      }
+    };
 
-  const obj2 = {
-    name: 'Obj2',
-    tags: [{ name: 'tag1' }, { name: 'tag4' }]
-  };
+    const obj2 = {
+      name: 'Obj2',
+      tags: [{ name: 'tag1' }, { name: 'tag4' }]
+    };
+
+    //expect(comparePaths(obj1, obj1)).toStrictEqual([]);
+    //expect(comparePaths(obj1, structuredClone(obj1))).toStrictEqual([]);
+
+    expect(comparePaths(obj1, obj2)).toStrictEqual([
+      ['name'],
+      ['tags', '1', 'name'],
+      ['deep', 'test']
+    ]);
+  });
+
+  test('Paths with empty arrays', () => {
+    const obj1 = {
+      flavours: [],
+      scoops: 1
+    };
 
-  //expect(comparePaths(obj1, obj1)).toStrictEqual([]);
-  //expect(comparePaths(obj1, structuredClone(obj1))).toStrictEqual([]);
+    const obj2 = {
+      flavours: [],
+      scoops: 1
+    };
+
+    expect(comparePaths(obj1, obj2)).toStrictEqual([]);
+  });
 
-  expect(comparePaths(obj1, obj2)).toStrictEqual([
-    ['name'],
-    ['tags', '1', 'name'],
-    ['deep', 'test']
-  ]);
+  test('Paths with arrays', () => {
+    const obj1 = {
+      flavours: [],
+      scoops: 1
+    };
+
+    const obj2 = {
+      flavours: ['Mint choc chip'],
+      scoops: 1
+    };
+
+    expect(comparePaths(obj1, obj2)).toStrictEqual([['flavours', '0']]);
+  });
 });
 
 test('Set paths', () => {

src/lib/client/index.ts

@@ -202,15 +202,34 @@ type SuperFormEventList<T extends AnyZodObject, M> = {
   >[];
 };
 
+type ValidateOptions<V> = Partial<{
+  value: V;
+  update: boolean;
+  errors: string | string[];
+}>;
+
+type Validate<
+  T extends AnyZodObject,
+  P extends FieldPath<z.infer<T>>, // = FieldPath<z.infer<T>>,
+  Path extends keyof z.infer<T> | P // = keyof z.infer<T> | P
+> = (
+  path: Path,
+  opts?: ValidateOptions<unknown>
+) => Promise<string[] | undefined>;
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type SuperForm<T extends ZodValidation<AnyZodObject>, M = any> = {
   form: {
     subscribe: Readable<z.infer<T>>['subscribe'];
-    set(this: void, value: z.infer<T>, options?: { taint?: boolean }): void;
+    set(
+      this: void,
+      value: z.infer<T>,
+      options?: { taint?: boolean | 'untaint' | 'untaint-all' }
+    ): void;
     update(
       this: void,
       updater: Updater<z.infer<T>>,
-      options?: { taint?: boolean }
+      options?: { taint?: boolean | 'untaint' | 'untaint-all' }
     ): void;
   };
   formId: Writable<string | undefined>;
@@ -242,13 +261,11 @@ export type SuperForm<T extends ZodValidation<AnyZodObject>, M = any> = {
   capture: () => SuperFormSnapshot<UnwrapEffects<T>, M>;
   restore: (snapshot: SuperFormSnapshot<UnwrapEffects<T>, M>) => void;
 
-  validate: (
-    path: keyof z.infer<T> | FieldPath<z.infer<T>>,
-    opts?: {
-      value?: unknown;
-      update?: boolean;
-    }
-  ) => Promise<string[] | undefined>;
+  validate: Validate<
+    UnwrapEffects<T>,
+    FieldPath<z.infer<UnwrapEffects<T>>>,
+    keyof z.infer<UnwrapEffects<T>> | FieldPath<z.infer<UnwrapEffects<T>>>
+  >;
 };
 
 /**
@@ -402,27 +419,23 @@ export function superForm<
     subscribe: _formData.subscribe,
     set: (
       value: Parameters<typeof _formData.set>[0],
-      options: { taint?: boolean } = {}
+      options: { taint?: boolean | 'untaint' | 'untaint-all' } = {}
     ) => {
-      if (options.taint !== false && !get(Submitting) && taintedFormState) {
-        checkTainted(value, taintedFormState);
-      }
+      //if (!get(Submitting)) {
+      checkTainted(value, taintedFormState, options.taint ?? true);
+      //}
       taintedFormState = clone(value);
       return _formData.set(value);
     },
     update: (
       updater: Parameters<typeof _formData.update>[0],
-      options: { taint?: boolean } = {}
+      options: { taint?: boolean | 'untaint' | 'untaint-all' } = {}
     ) => {
       return _formData.update((value) => {
         const output = updater(value);
-        if (
-          options.taint !== false &&
-          !get(Submitting) &&
-          taintedFormState
-        ) {
-          checkTainted(output, taintedFormState);
-        }
+        //if (!get(Submitting)) {
+        checkTainted(output, taintedFormState, options.taint ?? true);
+        //}
         taintedFormState = clone(value);
         return output;
       });
@@ -431,17 +444,29 @@ export function superForm<
 
   const LastChanges = writable<string[][]>([]);
 
-  function checkTainted(newObj: unknown, compareAgainst: unknown) {
+  function checkTainted(
+    newObj: unknown,
+    compareAgainst: unknown,
+    options: boolean | 'untaint' | 'untaint-all'
+  ) {
+    if (options === false) {
+      return;
+    } else if (options === 'untaint-all') {
+      Tainted.set(undefined);
+      return;
+    }
+
     const paths = comparePaths(newObj, compareAgainst);
-    //console.log('🚀 ~ file: index.ts:449 ~ checkTainted ~ paths:', paths);
 
-    LastChanges.set(paths);
+    if (options === true) {
+      LastChanges.set(paths);
+    }
 
     if (paths.length) {
       Tainted.update((tainted) => {
         //console.log('Update tainted:', paths, newObj, compareAgainst);
         if (!tainted) tainted = {};
-        setPaths(tainted, paths, true);
+        setPaths(tainted, paths, options === true ? true : undefined);
         return tainted;
       });
     }
@@ -734,20 +759,14 @@ export function superForm<
       rebind(snapshot, snapshot.tainted ?? true);
     },
 
-    validate: (
-      path: keyof z.infer<T> | FieldPath<z.infer<T>>,
-      opts: {
-        value?: unknown;
-        update?: boolean;
-      } = {}
-    ) => {
+    validate: (path, opts) => {
       return validateField(
         (Array.isArray(path) ? path : [path]) as string[],
         options.validators,
-        get(Form),
-        opts.update === false ? undefined : Errors,
         options.defaultValidator,
-        opts.value
+        get(Form),
+        Errors,
+        opts
       );
     },
     enhance: (el: HTMLFormElement, events?: SuperFormEvents<T2, M>) => {
@@ -817,25 +836,25 @@ function shouldSyncFlash<T extends AnyZodObject, M>(
 async function validateField<T extends AnyZodObject, M>(
   path: string[],
   validators: FormOptions<T, M>['validators'],
-  data: z.infer<T>,
-  errors: SuperForm<T, M>['errors'] | undefined,
   defaultValidator: FormOptions<T, M>['defaultValidator'],
-  value?: unknown
+  data: z.infer<T>,
+  errors: SuperForm<T, M>['errors'],
+  options: ValidateOptions<unknown> = {}
 ): Promise<string[] | undefined> {
   function setError(errorMsgs: null | undefined | string | string[]) {
     if (typeof errorMsgs === 'string') errorMsgs = [errorMsgs];
 
-    if (errors) {
+    if (options.update !== false) {
       errors.update((errors) => {
         const error = traversePath(
           errors,
           path as FieldPath<typeof errors>,
-          (data) => {
-            if (data.value === undefined) {
-              data.parent[data.key] = {};
-              return data.parent[data.key];
+          (node) => {
+            if (node.value === undefined) {
+              node.parent[node.key] = {};
+              return node.parent[node.key];
             } else {
-              return data.value;
+              return node.value;
             }
           }
         );
@@ -859,16 +878,21 @@ async function validateField<T extends AnyZodObject, M>(
     return undefined;
   }
 
+  let value = options.value;
+
   if (value === undefined) {
     const dataToValidate = traversePath(
       data,
       path as FieldPath<typeof data>
     );
 
-    if (!dataToValidate)
+    if (!dataToValidate) {
       throw new SuperFormError('Validation data not found: ' + path);
-    else value = dataToValidate.value;
+    }
+
+    value = dataToValidate.value;
   }
+  //console.log('🚀 ~ file: index.ts:871 ~ validate:', path, value);
 
   if (typeof validators !== 'object') {
     return defaultValidate();
@@ -910,7 +934,7 @@ async function validateField<T extends AnyZodObject, M>(
 
     if (!result.success) {
       const msgs = mapErrors<T>(result.error.format());
-      return setError(msgs._errors);
+      return setError(options.errors ?? msgs._errors);
     } else {
       return setError(undefined);
     }
@@ -932,7 +956,7 @@ async function validateField<T extends AnyZodObject, M>(
       return defaultValidate();
     } else {
       const result = validator.value(value);
-      return setError(result);
+      return setError(result ? options.errors ?? result : result);
     }
   }
 }
@@ -983,9 +1007,9 @@ function formEnhance<T extends AnyZodObject, M>(
       validateField(
         change,
         options.validators,
+        options.defaultValidator,
         get(data),
-        errors,
-        options.defaultValidator
+        errors
       );
     }
   }
@@ -1015,9 +1039,9 @@ function formEnhance<T extends AnyZodObject, M>(
         validateField(
           change,
           options.validators,
+          options.defaultValidator,
           get(data),
-          errors,
-          options.defaultValidator
+          errors
         );
       }
     }

src/lib/entity.ts

@@ -214,28 +214,42 @@ export async function traversePathsAsync<
  * Compare two objects and return the differences as paths.
  */
 export function comparePaths(newObj: unknown, oldObj: unknown) {
-  const diffPaths: string[][] = [];
-  traversePaths(newObj as object, (data) => {
+  const diffPaths = new Map<string, string[]>();
+
+  function checkPath(data: FullPathData, compareTo: object) {
     if (data.isLeaf) {
-      const exists = traversePath(
-        oldObj as object,
-        data.path as FieldPath<object>
-      );
+      const exists = traversePath(compareTo, data.path as FieldPath<object>);
+
+      /*
+      console.log('----------- Compare ------------ ');
+      console.log(data);
+      console.log('with');
+      console.log(exists);
+      */
+
       if (!exists) {
-        diffPaths.push(data.path);
+        diffPaths.set(data.path.join(' '), data.path);
       } else if (
         data.value instanceof Date &&
         exists.value instanceof Date &&
         data.value.getTime() != exists.value.getTime()
       ) {
-        diffPaths.push(data.path);
+        diffPaths.set(data.path.join(' '), data.path);
       } else if (data.value !== exists.value) {
-        diffPaths.push(data.path);
+        diffPaths.set(data.path.join(' '), data.path);
       }
     }
-  });
+  }
+
+  traversePaths(newObj as object, (data) =>
+    checkPath(data, oldObj as object)
+  );
+
+  traversePaths(oldObj as object, (data) =>
+    checkPath(data, newObj as object)
+  );
 
-  return diffPaths;
+  return Array.from(diffPaths.values());
 }
 
 export function setPaths(