Added taint option to formFieldProxy.

Author: ciscoheat

CHANGELOG.md

@@ -5,12 +5,13 @@ Headlines: Added, Changed, Deprecated, Removed, Fixed, Security
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [1.10.0] - 2023-11-07
 
 ### Added
 
 - Added `arrayProxy`, for proxying arrays and their errors in the form data.
 - Added `FormPathArrays` type, enumerating all arrays in an object as string accessors. Used to access `arrayProxy` in a type-safe manner.
+- `formFieldProxy` now has a `taint` option, in case a modification should not taint the form.
 
 ## [1.9.0] - 2023-10-31
 

src/lib/client/index.ts

@@ -203,24 +203,26 @@ export type TaintOption<T extends AnyZodObject = AnyZodObject> =
   | 'untaint-all'
   | { fields: FormPathLeaves<z.infer<T>> | FormPathLeaves<z.infer<T>>[] };
 
+type SuperFormData<T extends ZodValidation<AnyZodObject>> = {
+  subscribe: Readable<z.infer<UnwrapEffects<T>>>['subscribe'];
+  set(
+    this: void,
+    value: z.infer<UnwrapEffects<T>>,
+    options?: { taint?: TaintOption<UnwrapEffects<T>> }
+  ): void;
+  update(
+    this: void,
+    updater: Updater<z.infer<UnwrapEffects<T>>>,
+    options?: { taint?: TaintOption<UnwrapEffects<T>> }
+  ): void;
+};
+
 export type SuperForm<
   T extends ZodValidation<AnyZodObject>,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   M = App.Superforms.Message extends never ? any : App.Superforms.Message
 > = {
-  form: {
-    subscribe: Readable<z.infer<UnwrapEffects<T>>>['subscribe'];
-    set(
-      this: void,
-      value: z.infer<UnwrapEffects<T>>,
-      options?: { taint?: TaintOption<UnwrapEffects<T>> }
-    ): void;
-    update(
-      this: void,
-      updater: Updater<z.infer<UnwrapEffects<T>>>,
-      options?: { taint?: TaintOption<UnwrapEffects<T>> }
-    ): void;
-  };
+  form: SuperFormData<T>;
   formId: Writable<string | undefined>;
   errors: Writable<SuperValidated<T, M>['errors']> & {
     clear: () => void;

src/lib/client/proxies.ts

@@ -1,4 +1,9 @@
-import { derived, type Updater, type Writable } from 'svelte/store';
+import {
+  derived,
+  type Readable,
+  type Updater,
+  type Writable
+} from 'svelte/store';
 import {
   SuperFormError,
   type InputConstraint,
@@ -39,6 +44,8 @@ const defaultOptions: DefaultOptions = {
   emptyIfZero: true
 };
 
+export type TaintOptions = boolean | 'untaint' | 'untaint-all';
+
 ///// Proxy functions ///////////////////////////////////////////////
 
 export function booleanProxy<
@@ -239,32 +246,35 @@ export function arrayProxy<
 >(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   superForm: SuperForm<T, any>,
-  path: Path
+  path: Path,
+  options?: { taint?: TaintOptions }
 ): {
   path: Path;
   values: Writable<FormPathType<z.infer<UnwrapEffects<T>>, Path>>;
   errors: Writable<string[] | undefined>;
 } {
   return {
     path,
-    values: fieldProxy(superForm.form, path),
+    values: superFieldProxy(superForm, path, options),
     errors: fieldProxy(
       superForm.errors,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       `${path}._errors` as any
     ) as Writable<string[] | undefined>
   };
 }
+
 export function formFieldProxy<
   T extends ZodValidation<AnyZodObject>,
   Path extends FormPathLeaves<z.infer<UnwrapEffects<T>>>
 >(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   superForm: SuperForm<T, any>,
-  path: Path
+  path: Path,
+  options?: { taint?: TaintOptions }
 ): {
   path: Path;
-  value: Writable<FormPathType<z.infer<UnwrapEffects<T>>, Path>>;
+  value: SuperFieldProxy<FormPathType<z.infer<UnwrapEffects<T>>, Path>>;
   errors: Writable<string[] | undefined>;
   constraints: Writable<InputConstraint | undefined>;
   tainted: Writable<boolean | undefined>;
@@ -312,7 +322,7 @@ export function formFieldProxy<
 
   return {
     path,
-    value: fieldProxy(superForm.form, path),
+    value: superFieldProxy(superForm, path, options),
     errors: fieldProxy(superForm.errors, path) as unknown as Writable<
       string[] | undefined
     >,
@@ -324,6 +334,60 @@ export function formFieldProxy<
   };
 }
 
+type SuperFieldProxy<T extends object> = /*Writable<T> &*/ {
+  subscribe: Readable<T>['subscribe'];
+  set(this: void, value: T, options?: { taint?: TaintOptions }): void;
+  update(
+    this: void,
+    updater: Updater<T>,
+    options?: { taint?: TaintOptions }
+  ): void;
+};
+
+function superFieldProxy<
+  T extends ZodValidation<AnyZodObject>,
+  Path extends FormPath<z.infer<T>>
+>(
+  superForm: SuperForm<T>,
+  path: Path,
+  baseOptions?: { taint?: TaintOptions }
+): SuperFieldProxy<FormPathType<z.infer<T>, Path>> {
+  const form = superForm.form;
+  const path2 = splitPath<z.infer<T>>(path);
+
+  const proxy = derived(form, ($form) => {
+    const data = traversePath($form, path2);
+    return data?.value;
+  });
+
+  return {
+    subscribe(...params: Parameters<typeof proxy.subscribe>) {
+      const unsub = proxy.subscribe(...params);
+      return () => unsub();
+    },
+    update(
+      upd: Updater<FormPathType<z.infer<T>, Path>>,
+      options?: { taint?: TaintOptions }
+    ) {
+      form.update((f) => {
+        const output = traversePath(f, path2);
+        if (output) output.parent[output.key] = upd(output.value);
+        return f;
+      }, options ?? baseOptions);
+    },
+    set(
+      value: FormPathType<z.infer<T>, Path>,
+      options?: { taint?: TaintOptions }
+    ) {
+      form.update((f) => {
+        const output = traversePath(f, path2);
+        if (output) output.parent[output.key] = value;
+        return f;
+      }, options ?? baseOptions);
+    }
+  };
+}
+
 export function fieldProxy<T extends object, Path extends FormPath<T>>(
   form: Writable<T>,
   path: Path
@@ -337,30 +401,21 @@ export function fieldProxy<T extends object, Path extends FormPath<T>>(
 
   return {
     subscribe(...params: Parameters<typeof proxy.subscribe>) {
-      //console.log('~ fieldproxy ~ subscribe', path);
       const unsub = proxy.subscribe(...params);
 
-      return () => {
-        //console.log('~ fieldproxy ~ unsubscribe', field);
-        unsub();
-      };
+      return () => unsub();
     },
-    //subscribe: proxy.subscribe,
     update(upd: Updater<FormPathType<T, Path>>) {
-      //console.log('~ fieldStore ~ update value for', path);
       form.update((f) => {
         const output = traversePath(f, path2);
         if (output) output.parent[output.key] = upd(output.value);
-        //else console.log('[update] Not found:', path, 'in', f);
         return f;
       });
     },
     set(value: FormPathType<T, Path>) {
-      //console.log('~ fieldStore ~ set value for', path, value);
       form.update((f) => {
         const output = traversePath(f, path2);
         if (output) output.parent[output.key] = value;
-        //else console.log('[set] Not found:', path, 'in', f);
         return f;
       });
     }

src/routes/tests/array-component/+page.svelte

@@ -10,7 +10,7 @@
     dataType: 'json'
     //validators: schema
   });
-  const { form, errors, message, enhance } = pageForm;
+  const { form, errors, message, enhance, tainted } = pageForm;
 
   const options = [
     { value: 'A', label: 'Aldebaran' },
@@ -20,10 +20,12 @@
 
 <SuperDebug data={{ $form, $errors }} />
 
+{#if $tainted}<h3>FORM IS TAINTED</h3>{/if}
+
 {#if $message}<h4>{$message}</h4>{/if}
 
 <form method="POST" use:enhance>
-  <AutoComplete form={pageForm} field="sub.tags" {options} />
+  <AutoComplete form={pageForm} field="sub.tags" {options} taint={false} />
   <div>
     <button>Submit</button>
   </div>

src/routes/tests/array-component/AutoComplete.svelte

@@ -7,14 +7,15 @@
   import type { z } from 'zod';
   import type { ZodValidation, FormPathArrays } from '$lib';
   import type { SuperForm } from '$lib/client';
-  import { arrayProxy } from '$lib/client/proxies';
+  import { arrayProxy, type TaintOptions } from '$lib/client/proxies';
 
   export let form: SuperForm<ZodValidation<T>, unknown>;
   export let field: FormPathArrays<z.infer<T>>;
   export let options: { value: string; label: string }[];
   export let label = '';
+  export let taint: TaintOptions = true;
 
-  const { values, errors } = arrayProxy(form, field);
+  const { values, errors } = arrayProxy(form, field, { taint });
 </script>
 
 {#if label}<label for={field}>{label}</label>{/if}