@teamnovu/kit-vue-forms 0.0.1

package/dist/index.mjs

@@ -0,0 +1,414 @@
+var K = Object.defineProperty;
+var W = (t, r, e) => r in t ? K(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e;
+var w = (t, r, e) => W(t, typeof r != "symbol" ? r + "" : r, e);
+import { toValue as $, toRaw as I, computed as d, unref as u, reactive as b, watch as E, toRefs as P, toRef as R, ref as N, isRef as A, getCurrentScope as T, onBeforeUnmount as B } from "vue";
+import "zod";
+function y(t) {
+  const r = $(t), e = I(r);
+  return structuredClone(e);
+}
+function J(t) {
+  return t === "" ? [] : t.split(/\s*\.\s*/).filter(Boolean);
+}
+function m(t, r) {
+  return (Array.isArray(r) ? r : J(r)).reduce(
+    (a, s) => a == null ? void 0 : a[s],
+    t
+  );
+}
+function G(t, r, e) {
+  const a = Array.isArray(r) ? r : J(r);
+  if (a.length === 0)
+    throw new Error("Path cannot be empty");
+  const s = a.at(-1), n = a.slice(0, -1).reduce(
+    (c, v) => c[v],
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    t
+  );
+  n[s] = e;
+}
+const M = (t, r) => d({
+  get() {
+    return m(u(t), u(r));
+  },
+  set(e) {
+    G(u(t), u(r), e);
+  }
+});
+function F(t, r) {
+  return !t && !r ? "" : !t && r ? r : !r && t ? t : `${t}.${r}`;
+}
+function L(t, r) {
+  if (!r)
+    return t;
+  const e = `${r}.`, a = Object.fromEntries(
+    Object.entries(t.propertyErrors).filter(([s]) => s.startsWith(e)).map(
+      ([s, n]) => [s.slice(e.length), n]
+    )
+  );
+  return {
+    general: t.general,
+    // Keep general errors
+    propertyErrors: a
+  };
+}
+function U(t) {
+  const r = b({
+    value: t.value,
+    path: t.path,
+    initialValue: d(() => Object.freeze(y(t.initialValue))),
+    errors: u(t.errors) || [],
+    touched: !1
+  });
+  E(() => u(t.errors), (f) => {
+    r.errors = f || [];
+  });
+  const e = d(() => JSON.stringify(r.value) !== JSON.stringify(r.initialValue)), a = (f) => {
+    r.value = f;
+  }, s = () => {
+    r.touched = !0;
+  }, n = () => {
+  }, c = () => {
+    r.value = y(r.initialValue), r.touched = !1, r.errors = [];
+  }, v = (f) => {
+    r.errors = f;
+  }, o = () => {
+    r.errors = [];
+  }, l = P(r);
+  return {
+    value: l.value,
+    path: l.path,
+    initialValue: l.initialValue,
+    errors: l.errors,
+    touched: l.touched,
+    dirty: e,
+    setValue: a,
+    onBlur: s,
+    onFocus: n,
+    reset: c,
+    setErrors: v,
+    clearErrors: o
+  };
+}
+function Z(t) {
+  const r = {}, e = (c) => {
+    const v = u(c.path);
+    r[v] = c;
+  };
+  return {
+    fields: r,
+    getField: (c) => r[c],
+    getFields: () => Object.values(r),
+    registerField: e,
+    defineField: (c) => {
+      const v = U({
+        ...c,
+        value: M(R(t, "formData"), c.path),
+        initialValue: d(() => m(t.initialData, u(c.path)))
+      });
+      return e(v), v;
+    }
+  };
+}
+function _(t, r) {
+  const e = d(() => JSON.stringify(t.formData) !== JSON.stringify(t.initialData)), a = d(() => r.getFields().some((s) => u(s.touched)));
+  return {
+    isDirty: e,
+    isTouched: a
+  };
+}
+function k(t) {
+  return t.filter(
+    (r, e, a) => a.indexOf(r) === e
+  );
+}
+function x(...t) {
+  return t.slice(1).reduce((r, e) => {
+    if (!r && !e)
+      return;
+    const a = ((e == null ? void 0 : e.length) ?? 0) > 0;
+    if (!r && ((e == null ? void 0 : e.length) ?? 0) > 0)
+      return e;
+    if (!a)
+      return r;
+    const s = (r ?? []).concat(e);
+    return k(s);
+  }, t[0]);
+}
+function q(...t) {
+  return t.map((e) => Object.keys(e)).flat().reduce((e, a) => {
+    const s = t.map((n) => n[a]).filter(Boolean);
+    return {
+      ...e,
+      [a]: x(...s)
+    };
+  }, {});
+}
+function S(...t) {
+  if (!t.length)
+    return {
+      general: [],
+      propertyErrors: {}
+    };
+  const r = t[0];
+  return t.length === 1 ? r : t.slice(1).reduce(
+    (e, a) => ({
+      general: x(e.general, a.general),
+      propertyErrors: q(e.propertyErrors ?? {}, a.propertyErrors ?? {})
+    }),
+    r
+  );
+}
+function j(t) {
+  var a;
+  const r = (((a = t.general) == null ? void 0 : a.length) ?? 0) > 0, e = Object.entries(t.propertyErrors).filter(([, s]) => s == null ? void 0 : s.length).length > 0;
+  return r || e;
+}
+function H(t) {
+  const r = t.issues.filter((a) => a.path.length === 0).map((a) => a.message), e = t.issues.filter((a) => a.path.length > 0).reduce((a, s) => {
+    const n = s.path.join(".");
+    return {
+      ...a,
+      [n]: [...a[n] ?? [], s.message]
+    };
+  }, {});
+  return {
+    general: r,
+    propertyErrors: e
+  };
+}
+const p = {
+  isValid: !0,
+  errors: {
+    general: [],
+    propertyErrors: {}
+  }
+};
+class Q {
+  constructor(r) {
+    this.schema = r;
+  }
+  async validate(r) {
+    if (!this.schema)
+      return p;
+    const e = await this.schema.safeParseAsync(r);
+    if (e.success)
+      return p;
+    const a = H(e.error);
+    return {
+      isValid: !1,
+      errors: {
+        general: a.general ?? [],
+        propertyErrors: a.propertyErrors ?? {}
+      }
+    };
+  }
+}
+class X {
+  constructor(r) {
+    this.validateFn = r;
+  }
+  async validate(r) {
+    if (!this.validateFn)
+      return p;
+    try {
+      const e = await this.validateFn(r);
+      return e.isValid ? p : e;
+    } catch (e) {
+      return {
+        isValid: !1,
+        errors: {
+          general: [e.message || "Validation error"],
+          propertyErrors: {}
+        }
+      };
+    }
+  }
+}
+class Y {
+  constructor(r, e) {
+    w(this, "schemaValidator");
+    w(this, "functionValidator");
+    this.schema = r, this.validateFn = e, this.schemaValidator = new Q(this.schema), this.functionValidator = new X(this.validateFn);
+  }
+  async validate(r) {
+    const [e, a] = await Promise.all([
+      this.schemaValidator.validate(r),
+      this.functionValidator.validate(r)
+    ]);
+    return {
+      isValid: e.isValid && a.isValid,
+      errors: S(e.errors, a.errors)
+    };
+  }
+}
+function O(t) {
+  return d(() => new Y(
+    u(t.schema),
+    u(t.validateFn)
+  ));
+}
+function rr(t, r) {
+  const e = b({
+    validators: N([O(r)]),
+    isValidated: !1,
+    errors: u(r.errors) ?? {
+      general: [],
+      propertyErrors: {}
+    }
+  });
+  E(() => u(r.errors), async () => {
+    const o = await s();
+    n(o.errors);
+  }, { immediate: !0 }), E(
+    [() => e.validators],
+    async (o) => {
+      if (e.isValidated)
+        if (o) {
+          const l = await s();
+          e.errors = l.errors;
+        } else
+          e.errors = p.errors;
+    },
+    { immediate: !0 }
+  ), E(() => t.formData, () => {
+    e.isValidated && c();
+  });
+  const a = (o) => {
+    const l = A(o) ? o : O(o);
+    return e.validators.push(l), T() && B(() => {
+      e.validators = e.validators.filter(
+        (f) => f !== l
+      );
+    }), l;
+  };
+  async function s() {
+    const o = await Promise.all(
+      e.validators.filter((V) => u(V) !== void 0).map((V) => u(V).validate(t.formData))
+    ), l = o.every((V) => V.isValid);
+    let { errors: f } = p;
+    if (!l) {
+      const V = o.map((D) => D.errors);
+      f = S(...V);
+    }
+    return {
+      errors: f,
+      isValid: l
+    };
+  }
+  const n = (o) => {
+    e.errors = S(u(r.errors) ?? p.errors, o);
+  }, c = async () => {
+    const o = await s();
+    return n(o.errors), e.isValidated = !0, {
+      isValid: !j(o.errors),
+      errors: e.errors
+    };
+  }, v = d(() => !j(e.errors));
+  return {
+    ...P(e),
+    validateForm: c,
+    defineValidator: a,
+    isValid: v
+  };
+}
+class tr {
+  constructor(r, e) {
+    this.path = r, this.validator = e;
+  }
+  async validate(r) {
+    const e = m(r, this.path);
+    if (!this.validator)
+      return p;
+    const a = await this.validator.validate(e);
+    return {
+      isValid: a.isValid,
+      errors: {
+        general: a.errors.general || [],
+        propertyErrors: a.errors.propertyErrors ? Object.fromEntries(
+          Object.entries(a.errors.propertyErrors).map(([s, n]) => [
+            F(this.path, s),
+            n
+          ])
+        ) : {}
+      }
+    };
+  }
+}
+function er(t, r, e) {
+  const a = M(t.formData, r), s = d(() => m(t.initialData.value, r)), n = (i) => ({
+    ...i,
+    path: d(() => u(i.path).replace(r + ".", "")),
+    setValue: (h) => {
+      i.setValue(h);
+    }
+  }), c = (i) => {
+    const h = F(r, i), g = t.getField(h);
+    if (g)
+      return n(g);
+  }, v = (i) => {
+    const h = F(r, i.path), g = t.defineField({
+      ...i,
+      path: h
+    });
+    return n(g);
+  }, o = () => t.getFields().filter((i) => {
+    const h = i.path.value;
+    return h.startsWith(r + ".") || h === r;
+  }).map((i) => n(i)), l = () => t.getFields().filter((i) => {
+    const h = i.path.value;
+    return h.startsWith(r + ".") || h === r;
+  }), f = d(() => l().some((i) => i.dirty.value)), V = d(() => l().some((i) => i.touched.value)), D = d(() => t.isValid.value), z = d(() => t.isValidated.value), C = d(() => L(u(t.errors), r));
+  return {
+    formData: a,
+    initialData: s,
+    defineField: v,
+    getField: c,
+    getFields: o,
+    isDirty: f,
+    isTouched: V,
+    isValid: D,
+    isValidated: z,
+    errors: C,
+    defineValidator: (i) => {
+      const h = A(i) ? i : O(i), g = d(
+        () => new tr(r, u(h))
+      );
+      return t.defineValidator(g), h;
+    },
+    reset: () => l().forEach((i) => i.reset()),
+    validateForm: () => t.validateForm(),
+    getSubForm: (i, h) => {
+      const g = F(r, i);
+      return t.getSubForm(
+        g,
+        h
+      );
+    }
+  };
+}
+function ur(t) {
+  const r = d(() => Object.freeze(y(t.initialData))), e = N(y(r)), a = b({
+    initialData: r,
+    formData: e
+  }), s = Z(a), n = rr(a, t), c = _(a, s), v = () => {
+    e.value = y(r), s.getFields().forEach((f) => f.reset());
+  };
+  function o(f, V) {
+    return er(l, f);
+  }
+  const l = {
+    ...s,
+    ...n,
+    ...c,
+    reset: v,
+    getSubForm: o,
+    initialData: R(a, "initialData"),
+    formData: R(a, "formData")
+  };
+  return l;
+}
+export {
+  U as useField,
+  ur as useForm
+};

package/dist/types/form.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from 'vue';
+import { DefineFieldOptions } from '../composables/useFieldRegistry';
+import { SubformOptions } from '../composables/useSubform';
+import { EntityPaths, Paths, PickEntity, PickProps } from './util';
+import { ErrorBag, ValidationErrorMessage, ValidationErrors, ValidationResult, Validator } from './validation';
+import { ValidatorOptions } from '../composables/useValidation';
+export type FormDataDefault = object;
+export interface FormState<T extends FormDataDefault, TIn extends FormDataDefault = T> {
+    formData: T;
+    initialData: TIn;
+}
+export interface FormField<T, P extends string> {
+    value: Ref<T>;
+    path: Ref<P>;
+    initialValue: Readonly<Ref<T>>;
+    errors: Ref<ValidationErrors>;
+    touched: Ref<boolean>;
+    dirty: Ref<boolean>;
+    setValue: (newValue: T) => void;
+    onBlur: () => void;
+    onFocus: () => void;
+    reset: () => void;
+    setErrors: (newErrors: ValidationErrorMessage[]) => void;
+    clearErrors: () => void;
+}
+export interface Form<T extends FormDataDefault> {
+    formData: Ref<T>;
+    initialData: Readonly<Ref<T>>;
+    defineField: <P extends Paths<T>>(options: DefineFieldOptions<PickProps<T, P>, P>) => FormField<PickProps<T, P>, P>;
+    getField: <P extends Paths<T>>(path: P) => FormField<PickProps<T, P>, P> | undefined;
+    getFields: () => FormField<PickProps<T, Paths<T>>, Paths<T>>[];
+    isDirty: Ref<boolean>;
+    isTouched: Ref<boolean>;
+    isValid: Ref<boolean>;
+    isValidated: Ref<boolean>;
+    errors: Ref<ErrorBag>;
+    defineValidator: (options: ValidatorOptions<T> | Ref<Validator<T>>) => Ref<Validator<T> | undefined>;
+    reset: () => void;
+    validateForm: () => Promise<ValidationResult>;
+    getSubForm: <P extends EntityPaths<T>>(path: P, options?: SubformOptions<PickEntity<T, P>>) => Form<PickEntity<T, P>>;
+}

package/dist/types/util.d.ts

@@ -0,0 +1,26 @@
+import { FormDataDefault } from './form';
+/**
+ * Takes a dot-connected path and returns a tuple of its parts.
+ */
+export type SplitPath<TPath extends string> = TPath extends `${infer T1}.${infer T2}` ? [T1, ...SplitPath<T2>] : [TPath];
+/**
+ * Picks the exact type of the Entity at the nested PropertyKeys path.
+ */
+export type PickProps<Entity, PropertyKeys extends string> = PropertyKeys extends `${infer TRoot}.${infer TRest}` ? TRoot extends keyof Entity ? TRest extends string ? Entity[TRoot] extends object ? PickProps<Entity[TRoot], TRest> : never : never : TRoot extends `${number}` ? Entity extends unknown[] ? TRest extends string ? Entity[number] extends object ? PickProps<Entity[number], TRest> : never : never : never : never : PropertyKeys extends keyof Entity ? Entity[PropertyKeys] : PropertyKeys extends `${number}` ? Entity extends unknown[] ? Entity[number] : never : never;
+/**
+ * Resolves to a union of dot-connected paths of all nested properties of T.
+ */
+export type Paths<T, Seen = never> = T extends Seen ? never : T extends Array<infer ArrayType> ? `${number}` | `${number}.${Paths<ArrayType, Seen | T>}` : T extends object ? {
+    [K in keyof T]-?: `${Exclude<K, symbol>}${'' | `.${Paths<T[K], Seen | T>}`}`;
+}[keyof T] : never;
+/**
+ * Removes the last part of a dot-connected path.
+ */
+export type ButLast<T extends string> = T extends `${infer Rest}.${infer Last}` ? ButLast<Last> extends '' ? Rest : `${Rest}.${ButLast<Last>}` : never;
+/**
+ * Combines Paths<T> with ButLast<Paths<T>> to include all paths except the last part.
+ * The & Paths<T> ensures that there are no entity paths that are not also available in Paths<T>.
+ */
+export type EntityPaths<T> = ButLast<Paths<T>> & Paths<T>;
+export type PickEntity<Entity, PropertyKeys extends string> = PropertyKeys extends unknown ? PickProps<Entity, EntityPaths<Entity> & PropertyKeys> & FormDataDefault : never;
+export type RestPath<T extends string, P extends string> = P extends `${T}.${infer Rest}` ? Rest : never;

package/dist/types/validation.d.ts

@@ -0,0 +1,16 @@
+import { FormDataDefault } from './form';
+export type ValidationStrategy = 'onTouch' | 'onFormOpen' | 'none' | 'preSubmit';
+export type ValidationErrorMessage = string;
+export type ValidationErrors = ValidationErrorMessage[] | undefined;
+export interface ErrorBag {
+    general: ValidationErrors;
+    propertyErrors: Record<string, ValidationErrors>;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ErrorBag;
+}
+export interface Validator<T extends FormDataDefault = FormDataDefault> {
+    validate: (data: T) => Promise<ValidationResult>;
+}
+export type ValidationFunction<T> = (data: T) => Promise<ValidationResult>;

package/dist/utils/general.d.ts

@@ -0,0 +1,2 @@
+import { MaybeRefOrGetter } from 'vue';
+export declare function cloneRefValue<T>(ref: MaybeRefOrGetter<T> | MaybeRefOrGetter<Readonly<T>>): T;

package/dist/utils/path.d.ts

@@ -0,0 +1,11 @@
+import { MaybeRef, WritableComputedRef } from 'vue';
+import { Paths, PickProps, SplitPath } from '../types/util';
+import { ErrorBag } from '../types/validation';
+export declare function splitPath(path: string): string[];
+export declare function getNestedValue<T, K extends Paths<T>>(obj: T, path: K | SplitPath<K>): PickProps<T, K>;
+export declare function setNestedValue<T, K extends Paths<T>>(obj: T, path: K | SplitPath<K>, value: PickProps<T, K>): void;
+export declare const getLens: <T, K extends Paths<T>>(formData: MaybeRef<T>, key: MaybeRef<K | SplitPath<K>>) => WritableComputedRef<PickProps<T, K>, PickProps<T, K>>;
+type JoinPath<Base extends string, Sub extends string> = `${Base}${Base extends '' ? '' : Sub extends '' ? '' : '.'}${Sub}`;
+export declare function joinPath<Base extends string, Sub extends string>(basePath: Base, subPath: Sub): JoinPath<Base, Sub>;
+export declare function filterErrorsForPath(errors: ErrorBag, path: string): ErrorBag;
+export {};

package/dist/utils/type-helpers.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};

package/dist/utils/validation.d.ts

@@ -0,0 +1,3 @@
+import { ErrorBag } from '../types/validation';
+export declare function mergeErrors(...errorBags: ErrorBag[]): ErrorBag;
+export declare function hasErrors(errorBag: ErrorBag): boolean;

package/dist/utils/zod.d.ts

@@ -0,0 +1,3 @@
+import { default as z } from 'zod';
+import { ErrorBag } from '../types/validation';
+export declare function flattenError(error: z.ZodError): ErrorBag;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@teamnovu/kit-vue-forms",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "vite build",
+    "watch": "NODE_ENV=development vite build --watch",
+    "lint": "eslint --fix --ignore-pattern 'dist/**' .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui"
+  },
+  "keywords": [
+    "vue",
+    "forms",
+    "validation",
+    "typescript"
+  ],
+  "author": "",
+  "license": "ISC",
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "vue": "^3.0.0",
+    "vitest": "^2.0.0",
+    "@vitest/ui": "^2.0.0",
+    "happy-dom": "^12.0.0"
+  },
+  "dependencies": {
+    "@vueuse/core": "^13.5.0",
+    "zod": "^4"
+  }
+}

package/src/composables/useField.ts

@@ -0,0 +1,74 @@
+import { computed, reactive, toRefs, unref, watch, type MaybeRef, type MaybeRefOrGetter } from 'vue'
+import type { FormField } from '../types/form'
+import type { ValidationErrorMessage, ValidationErrors } from '../types/validation'
+import { cloneRefValue } from '../utils/general'
+
+export interface UseFieldOptions<T, K extends string> {
+  value?: MaybeRef<T>
+  initialValue?: MaybeRefOrGetter<Readonly<T>>
+  type?: MaybeRef<string>
+  required?: MaybeRef<boolean>
+  path: K
+  errors?: MaybeRef<ValidationErrors>
+}
+
+export function useField<T, K extends string>(options: UseFieldOptions<T, K>): FormField<T, K> {
+  const state = reactive({
+    value: options.value,
+    path: options.path,
+    initialValue: computed(() => Object.freeze(cloneRefValue(options.initialValue))),
+    errors: unref(options.errors) || [],
+    touched: false,
+  })
+
+  watch(() => unref(options.errors), (newValue) => {
+    state.errors = newValue || []
+  })
+
+  const dirty = computed(() => {
+    return JSON.stringify(state.value) !== JSON.stringify(state.initialValue)
+  })
+
+  const setValue = (newValue: T): void => {
+    state.value = newValue
+  }
+
+  const onBlur = (): void => {
+    state.touched = true
+  }
+
+  const onFocus = (): void => {
+    // TODO: Implement focus logic if needed
+  }
+
+  const reset = (): void => {
+    state.value = cloneRefValue(state.initialValue)
+    state.touched = false
+    state.errors = []
+  }
+
+  const setErrors = (newErrors: ValidationErrorMessage[]): void => {
+    state.errors = newErrors
+  }
+
+  const clearErrors = (): void => {
+    state.errors = []
+  }
+
+  const refs = toRefs(state)
+
+  return {
+    value: refs.value as FormField<T, K>['value'],
+    path: refs.path as FormField<T, K>['path'],
+    initialValue: refs.initialValue as FormField<T, K>['initialValue'],
+    errors: refs.errors as FormField<T, K>['errors'],
+    touched: refs.touched as FormField<T, K>['touched'],
+    dirty,
+    setValue,
+    onBlur,
+    onFocus,
+    reset,
+    setErrors,
+    clearErrors,
+  }
+}

package/src/composables/useFieldRegistry.ts

@@ -0,0 +1,53 @@
+import { computed, toRef, unref } from 'vue'
+import type { FormDataDefault, FormField, FormState } from '../types/form'
+import type { Paths, PickProps } from '../types/util'
+import { getLens, getNestedValue } from '../utils/path'
+import { useField, type UseFieldOptions } from './useField'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type FieldRegistryCache<T> = Record<Paths<T>, FormField<any, string>>
+
+export type ResolvedFormField<T, K extends Paths<T>> = FormField<PickProps<T, K>, K>
+
+export type DefineFieldOptions<F, K extends string> = Pick<UseFieldOptions<F, K>, 'path' | 'type' | 'required'>
+
+export function useFieldRegistry<T extends FormDataDefault>(
+  formState: FormState<T>,
+) {
+  const fields = {} as FieldRegistryCache<T>
+
+  const registerField = <K extends Paths<T>>(field: ResolvedFormField<T, K>) => {
+    const path = unref(field.path) as Paths<T>
+    fields[path] = field
+  }
+
+  const getField = <K extends Paths<T>>(path: K) => {
+    return fields[path] as ResolvedFormField<T, K> | undefined
+  }
+
+  const getFields = () => {
+    return Object.values(fields) as ResolvedFormField<T, Paths<T>>[]
+  }
+
+  const defineField = <K extends Paths<T>>(options: DefineFieldOptions<PickProps<T, K>, K>) => {
+    const field = useField({
+      ...options,
+      value: getLens(toRef(formState, 'formData'), options.path),
+      initialValue: computed(() => getNestedValue(formState.initialData, unref(options.path))),
+    })
+
+    registerField(field)
+
+    return field
+  }
+
+  return {
+    fields,
+    getField,
+    getFields,
+    registerField,
+    defineField,
+  }
+}
+
+export type FieldRegistry<T extends FormDataDefault> = ReturnType<typeof useFieldRegistry<T>>