@teamnovu/kit-vue-forms 0.1.14 → 0.1.16

package/src/utils/path.ts

@@ -1,94 +1,129 @@
-import { computed, isRef, unref, type MaybeRef } from 'vue'
-import type { Paths, PickProps, SplitPath } from '../types/util'
-import type { ErrorBag, ValidationErrors } from '../types/validation'
+import { computed, isRef, unref, type MaybeRef } from "vue";
+import type { Paths, PickProps, SplitPath } from "../types/util";
+import type { ErrorBag, ValidationErrors } from "../types/validation";
+import type { FormField } from "../types/form";
 
 export function splitPath(path: string): string[] {
-  if (path === '') {
-    return []
+  if (path === "") {
+    return [];
   }
-  return path.split(/\s*\.\s*/).filter(Boolean)
+  return path.split(/\s*\.\s*/).filter(Boolean);
 }
 
-export function getNestedValue<T, K extends Paths<T>>(obj: T, path: K | SplitPath<K>) {
-  const splittedPath = Array.isArray(path) ? path : splitPath(path)
+export function existsPath<T, K extends Paths<T>>(
+  obj: T,
+  path: K | SplitPath<K>,
+): boolean {
+  const splittedPath = Array.isArray(path) ? path : splitPath(path) as SplitPath<K>;
+  return !!getNestedValue(obj, splittedPath.slice(0, -1) as SplitPath<K>);
+}
+
+export function existsFieldPath<T, K extends Paths<T>>(field: FormField<T, K>) {
+  return existsPath(field.data.value, field.path.value)
+}
+
+export function getNestedValue<T, K extends Paths<T>>(
+  obj: T,
+  path: K | SplitPath<K>,
+) {
+  const splittedPath = Array.isArray(path) ? path : splitPath(path);
   return splittedPath.reduce(
     (current, key) => current?.[key],
     obj as Record<string, never>,
-  ) as PickProps<T, K>
+  ) as PickProps<T, K>;
 }
 
-export function setNestedValue<T, K extends Paths<T>>(obj: MaybeRef<T>, path: K | SplitPath<K>, value: PickProps<T, K>): void {
-  const keys = Array.isArray(path) ? path : splitPath(path)
+export function setNestedValue<T, K extends Paths<T>>(
+  obj: MaybeRef<T>,
+  path: K | SplitPath<K>,
+  value: PickProps<T, K>,
+): void {
+  const keys = Array.isArray(path) ? path : splitPath(path);
 
-  const lastKey = keys.at(-1)!
+  const lastKey = keys.at(-1)!;
 
   if (!lastKey) {
     if (!isRef(obj)) {
       // We cannot do anything here as we have nothing we can assign to
-      return
+      return;
     }
 
-    obj.value = value
+    obj.value = value;
   } else {
-    const target = keys
-      .slice(0, -1)
-      .reduce(
-        (current, key) => current?.[key],
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        unref(obj) as Record<string, any>,
-      )
-
-    target[lastKey] = value
+    const target = keys.slice(0, -1).reduce(
+      (current, key) => {
+        if (current?.[key] === undefined) {
+          // Create the nested object if it doesn't exist
+          current[key] = {};
+        }
+        return current?.[key];
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      unref(obj) as Record<string, any>,
+    );
+
+    target[lastKey] = value;
   }
 }
 
-export const getLens = <T, K extends Paths<T>>(data: MaybeRef<T>, key: MaybeRef<K | SplitPath<K>>) => {
+export const getLens = <T, K extends Paths<T>>(
+  data: MaybeRef<T>,
+  key: MaybeRef<K | SplitPath<K>>,
+) => {
   return computed({
     get() {
-      return getNestedValue(unref(data), unref(key))
+      return getNestedValue(unref(data), unref(key));
     },
     set(value: PickProps<T, K>) {
-      setNestedValue(data, unref(key), value)
+      setNestedValue(data, unref(key), value);
     },
-  })
-}
+  });
+};
 
-type JoinPath<Base extends string, Sub extends string> = `${Base}${Base extends '' ? '' : Sub extends '' ? '' : '.'}${Sub}`
-export function joinPath<Base extends string, Sub extends string>(basePath: Base, subPath: Sub): JoinPath<Base, Sub> {
+type JoinPath<
+  Base extends string,
+  Sub extends string,
+> = `${Base}${Base extends "" ? "" : Sub extends "" ? "" : "."}${Sub}`;
+export function joinPath<Base extends string, Sub extends string>(
+  basePath: Base,
+  subPath: Sub,
+): JoinPath<Base, Sub> {
   if (!basePath && !subPath) {
-    return '' as JoinPath<Base, Sub>
+    return "" as JoinPath<Base, Sub>;
   }
 
   if (!basePath && subPath) {
-    return subPath as JoinPath<Base, Sub>
+    return subPath as JoinPath<Base, Sub>;
   }
 
   if (!subPath && basePath) {
-    return basePath as JoinPath<Base, Sub>
+    return basePath as JoinPath<Base, Sub>;
   }
 
-  return `${basePath}.${subPath}` as JoinPath<Base, Sub>
+  return `${basePath}.${subPath}` as JoinPath<Base, Sub>;
 }
 
 export function filterErrorsForPath(errors: ErrorBag, path: string): ErrorBag {
   // Handle empty path - return all errors
   if (!path) {
-    return errors
+    return errors;
   }
 
-  const pathPrefix = `${path}.`
-  const filteredPropertyErrors: Record<string, ValidationErrors> = Object.fromEntries(
-    Object.entries(errors.propertyErrors)
-      .filter(([errorPath]) => {
-        return errorPath.startsWith(pathPrefix)
-      })
-      .map(
-        ([errorPath, errorMessages]) => [errorPath.slice(pathPrefix.length), errorMessages],
-      ),
-  )
+  const pathPrefix = `${path}.`;
+  const filteredPropertyErrors: Record<string, ValidationErrors> =
+    Object.fromEntries(
+      Object.entries(errors.propertyErrors)
+        .filter(([errorPath]) => {
+          return errorPath.startsWith(pathPrefix);
+        })
+        .map(([errorPath, errorMessages]) => [
+          errorPath.slice(pathPrefix.length),
+          errorMessages,
+        ]),
+    );
 
   return {
     general: errors.general, // Keep general errors
     propertyErrors: filteredPropertyErrors,
-  }
+  };
 }

package/tests/subform.test.ts

@@ -1031,6 +1031,23 @@ describe('Subform Implementation', () => {
         expect(result.isValid).toBe(false)
         expect(result.errors.general).toContain('Data is undefined')
       })
+
+      it('can create subforms on non-existent paths', async () => {
+        const form = useForm<{
+          test: string[]
+          nonExistentPath?: { name: string }
+        }>({
+          initialData: { test: ['item1', 'item2'] },
+        })
+
+        const subform = form.getSubForm('nonExistentPath')
+
+        const nameField = subform.defineField({ path: 'name' })
+
+        nameField.setData('Test Name')
+
+        expect(nameField.data.value).toEqual('Test Name')
+      })
     })
 
     describe('Path Edge Cases', () => {

package/tests/useField.test.ts

@@ -207,4 +207,21 @@ describe('useField', () => {
     expect(field.initialValue.value).toBe('bar')
     expect(field.data.value).toBe('modified')
   })
+
+  it('it should reset errors on a field on blur', () => {
+    const errors = ref(['Initial error'])
+
+    const field = useField({
+      initialValue: 'foo',
+      value: 'foo',
+      path: 'name',
+      errors,
+    })
+
+    expect(field.errors.value).toEqual(['Initial error'])
+
+    field.onBlur()
+
+    expect(field.errors.value).toEqual([])
+  })
 })