@effect-app/vue-components 0.15.23 → 0.15.24

package/dist/vue-components.es6.js

@@ -1,72 +1,34 @@
-import { defineComponent as _, computed as O, createElementBlock as j, openBlock as M, Fragment as E, renderList as A, renderSlot as F, createVNode as g, mergeProps as h } from "vue";
-import { Order as s, pipe as k, Array as l } from "effect-app";
-import v from "./vue-components.es4.js";
-const R = /* @__PURE__ */ _({
-  __name: "OmegaAutoGen",
+import { defineComponent as a, inject as t, createBlock as n, openBlock as m, mergeProps as p, unref as s, withCtx as i, renderSlot as l, normalizeProps as f, guardReactiveProps as u } from "vue";
+import d from "./vue-components.es7.js";
+import { OmegaFormKey as c } from "./vue-components.es9.js";
+const w = /* @__PURE__ */ a({
+  __name: "OmegaFormInput",
   props: {
-    form: {},
-    pick: {},
-    omit: {},
-    labelMap: { type: Function },
-    filterMap: { type: Function },
-    order: {},
-    sort: {}
+    name: {},
+    label: {},
+    validators: {},
+    options: {},
+    type: {}
   },
-  setup(p) {
-    const m = (e) => (r) => Object.fromEntries(
-      Object.entries(r).map(([t, n]) => [t, e(n, t)])
-    ), u = (e) => (r) => Object.fromEntries(
-      Object.entries(r).filter(([t, n]) => e(n, t))
-    ), a = (e) => (r) => Object.entries(r).reduce(
-      (t, [n, c]) => {
-        const i = e(c, n);
-        return i !== !1 && (t[n] = i), t;
-      },
-      {}
-    ), o = p, f = (e, r) => {
-      const t = r?.indexOf(e) ?? -1;
-      return t === -1 ? Number.MAX_SAFE_INTEGER : t;
-    }, d = s.mapInput(
-      s.number,
-      (e) => f(e.name, o.order || [])
-    ), b = O(
-      () => k(
-        o.form.meta,
-        // include / exclude
-        u(
-          (e, r) => o.pick ? o.pick.includes(r) && !o.omit?.includes(r) : !o.omit?.includes(r)
-        ),
-        (e) => e,
-        // labelMap and adding name
-        m((e, r) => ({
-          name: r,
-          label: o.labelMap?.(r) || r,
-          ...e
-        })),
-        // filterMap
-        o.filterMap ? a((e) => {
-          const r = o.filterMap?.(e.name, e);
-          return r === void 0 || r === !0 ? e : r;
-        }) : (e) => e,
-        // transform to array
-        (e) => Object.values(e),
-        // order
-        l.sort(d),
-        // sort
-        o.sort ? l.sort(o.sort) : (e) => e
-      )
-    );
-    return (e, r) => (M(!0), j(E, null, A(b.value, ({ name: t, label: n, ...c }) => F(e.$slots, "default", {
-      child: { name: t, label: n, ...c }
-    }, () => [
-      g(v, h({
-        form: o.form,
-        name: t,
-        label: n
-      }, { ref_for: !0 }, c), null, 16, ["form", "name", "label"])
-    ])), 256));
+  setup(g) {
+    const o = t(c);
+    if (!o)
+      throw new Error("OmegaFormInput must be used within an OmegaForm context");
+    return (e, b) => (m(), n(d, p(e.$props, {
+      form: s(o),
+      name: e.name,
+      label: e.label,
+      validators: e.validators,
+      options: e.options,
+      type: e.type
+    }), {
+      default: i((r) => [
+        l(e.$slots, "default", f(u(r)))
+      ]),
+      _: 3
+    }, 16, ["form", "name", "label", "validators", "options", "type"]));
   }
 });
 export {
-  R as default
+  w as default
 };

package/dist/vue-components.es7.js

@@ -1,53 +1,52 @@
-import { defineComponent as F, computed as d, onMounted as M, provide as P, createBlock as f, openBlock as m, resolveDynamicComponent as i, withCtx as c, renderSlot as o, createElementBlock as k, normalizeProps as s, guardReactiveProps as l, Fragment as A, renderList as b, mergeProps as B } from "vue";
-const N = /* @__PURE__ */ F({
+import { defineComponent as d, inject as f, computed as r, createBlock as n, openBlock as m, resolveDynamicComponent as c, withCtx as l, createCommentVNode as v, mergeProps as y, renderSlot as g, normalizeProps as h, guardReactiveProps as b } from "vue";
+import { generateInputStandardSchemaFromFieldMeta as C } from "./vue-components.es10.js";
+import F from "./vue-components.es24.js";
+const P = /* @__PURE__ */ d({
   inheritAttrs: !1,
-  __name: "OmegaArray",
+  __name: "OmegaInput",
   props: {
     form: {},
     name: {},
-    defaultItems: {},
-    items: {}
+    validators: {},
+    label: {},
+    options: {},
+    type: {}
   },
-  setup(g) {
-    const t = g, y = t.form.useStore((e) => e.values), u = d(() => {
-      const e = t.name.replace(/\[/g, ".").replace(/\]/g, "");
-      try {
-        return e.split(".").reduce((a, r) => a[r], y.value);
-      } catch {
-        return [];
-      }
-    });
-    M(async () => {
-      t.defaultItems && !u.value && t.form.setFieldValue(t.name, t.defaultItems);
+  setup(s) {
+    const a = s, o = f(
+      "getMetaFromArray",
+      null
+    ), t = r(() => o?.value && o.value(a.name) ? o.value(a.name) : a.form.meta[a.name]), i = r(() => {
+      if (!t.value)
+        throw console.log(a.name, Object.keys(a.form.meta), a.form.meta), new Error("Meta is undefined");
+      return C(t.value);
     });
-    const $ = d(() => (a) => {
-      const r = a.replace(/\[\d+\]/g, "");
-      return t.form.meta[r];
-    });
-    return P("getMetaFromArray", $), (e, a) => (m(), f(i(e.form.Field), { name: e.name }, {
-      default: c(({ field: r, state: p }) => [
-        o(e.$slots, "pre-array", s(l({ field: r, state: p }))),
-        (m(!0), k(A, null, b(u.value, (C, n) => (m(), f(i(e.form.Field), {
-          key: `${e.name}[${Number(n)}]`,
-          name: `${e.name}[${Number(n)}]`
-        }, {
-          default: c(({ field: v, state: h }) => [
-            o(e.$slots, "default", B({ ref_for: !0 }, {
-              subField: v,
-              subState: h,
-              index: Number(n),
-              field: r
-            }))
+    return (e, k) => (m(), n(c(e.form.Field), {
+      name: e.name,
+      validators: {
+        onChange: i.value,
+        ...e.validators
+      }
+    }, {
+      default: l(({ field: p }) => [
+        t.value ? (m(), n(F, y({
+          key: 0,
+          field: p,
+          label: e.label,
+          options: e.options,
+          meta: t.value,
+          type: e.type
+        }, e.$attrs), {
+          default: l((u) => [
+            g(e.$slots, "default", h(b(u)))
           ]),
-          _: 2
-        }, 1032, ["name"]))), 128)),
-        o(e.$slots, "post-array", s(l({ field: r, state: p }))),
-        o(e.$slots, "field", s(l({ field: r })))
+          _: 3
+        }, 16, ["field", "label", "options", "meta", "type"])) : v("", !0)
       ]),
       _: 3
-    }, 8, ["name"]));
+    }, 8, ["name", "validators"]));
   }
 });
 export {
-  N as default
+  P as default
 };

package/dist/vue-components.es9.js

@@ -1,12 +1,12 @@
 import { useForm as j } from "@tanstack/vue-form";
 import { S as E } from "effect-app";
-import { generateMetaFromSchema as O } from "./vue-components.es10.js";
+import { isObject as O } from "./vue-components.es22.js";
 import { computed as v, onUnmounted as P, onMounted as I, onBeforeUnmount as N, provide as R } from "vue";
-import { isObject as A } from "./vue-components.es22.js";
-import D from "./vue-components.es5.js";
+import A from "./vue-components.es6.js";
+import { generateMetaFromSchema as D } from "./vue-components.es10.js";
 const F = Symbol("OmegaForm"), $ = (d, i, o) => {
   if (!d) throw new Error("Schema is required");
-  const S = E.standardSchemaV1(d), { filterItems: b, meta: a } = O(d), n = v(() => {
+  const S = E.standardSchemaV1(d), { filterItems: b, meta: a } = D(d), n = v(() => {
     if (o?.persistency?.id)
       return o.persistency.id;
     const e = window.location.pathname, r = Object.keys(a);
@@ -19,7 +19,7 @@ const F = Symbol("OmegaForm"), $ = (d, i, o) => {
   };
   function m(e, r) {
     for (const s in r)
-      r[s] && A(r[s]) ? (e[s] || (e[s] = {}), m(e[s], r[s])) : e[s] = r[s];
+      r[s] && O(r[s]) ? (e[s] || (e[s] = {}), m(e[s], r[s])) : e[s] = r[s];
     return e;
   }
   const V = v(() => {
@@ -80,9 +80,7 @@ const F = Symbol("OmegaForm"), $ = (d, i, o) => {
       if (Array.isArray(e.keys))
         return p(e.keys);
       if (Array.isArray(e.banKeys)) {
-        const r = Object.keys(a).filter(
-          (s) => e.banKeys?.includes(s)
-        );
+        const r = Object.keys(a).filter((s) => e.banKeys?.includes(s));
         return p(r);
       }
       return l.store.state.values;
@@ -115,7 +113,7 @@ const F = Symbol("OmegaForm"), $ = (d, i, o) => {
     clear: L
   });
   return R(F, h), Object.assign(h, {
-    Input: D,
+    Input: A,
     Field: l.Field
   });
 };

package/package.json

@@ -1,24 +1,27 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "0.15.23",
+  "version": "0.15.24",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
-    "@tanstack/vue-form": "^1.2.4",
-    "effect": "^3.17.6",
+    "@tanstack/vue-form": "1.2.4",
+    "effect": "^3.17.13",
     "intl-messageformat": "^10.7.16",
     "mdi-js": "^1.0.1",
     "primeflex": "^4.0.0",
     "primeicons": "^7.0.0",
-    "primevue": "^4.3.7",
-    "vue": "^3.5.18",
-    "vuetify": "^3.9.4"
+    "primevue": "^4.3.8",
+    "vue": "^3.5.21",
+    "vuetify": "^3.9.7"
   },
   "devDependencies": {
-    "@storybook/vue3": "^9.1.2",
-    "@storybook/vue3-vite": "^9.1.2",
-    "@types/node": "^24.2.0",
-    "@typescript-eslint/eslint-plugin": "8.39.0",
-    "@typescript-eslint/parser": "8.39.0",
+    "@dprint/typescript": "^0.95.11",
+    "@ben_12/eslint-plugin-dprint": "^1.7.4",
+    "dprint": "^0.50.1",
+    "@storybook/vue3": "^9.1.4",
+    "@storybook/vue3-vite": "^9.1.4",
+    "@types/node": "^24.3.1",
+    "@typescript-eslint/eslint-plugin": "8.42.0",
+    "@typescript-eslint/parser": "8.42.0",
     "@vitejs/plugin-vue": "^6.0.1",
     "@vue/eslint-config-prettier": "^10.2.0",
     "@vue/eslint-config-typescript": "^14.6.0",
@@ -27,13 +30,13 @@
     "eslint-plugin-vue": "^10.4.0",
     "jsdom": "^26.1.0",
     "rimraf": "^6.0.1",
-    "sass": "^1.90.0",
-    "storybook": "^9.1.2",
+    "sass": "^1.92.0",
+    "storybook": "^9.1.4",
     "typescript": "~5.9.2",
-    "vite": "^7.1.0",
+    "vite": "^7.1.4",
     "vite-plugin-css-injected-by-js": "^3.5.2",
     "vitepress": "^1.6.4",
-    "vue-tsc": "^2.2.8"
+    "vue-tsc": "^3.0.6"
   },
   "files": [
     "src",
@@ -50,8 +53,8 @@
   "dependencies": {
     "highlight.js": "^11.11.1",
     "vue3-highlightjs": "^1.0.5",
-    "effect-app": "3.2.3",
-    "@effect-app/vue": "2.53.3"
+    "@effect-app/vue": "2.53.4",
+    "effect-app": "3.2.4"
   },
   "scripts": {
     "build": "pnpm build:run",

package/src/components/OmegaForm/InputProps.ts

@@ -1,33 +1,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type {
-  DeepValue,
-  DeepKeys,
-  FieldApi,
-  ValidationError,
-  FormAsyncValidateOrFn,
-  FormValidateOrFn,
-  StandardSchemaV1,
-  FieldValidateOrFn,
-  FieldValidateFn,
-  FieldValidateAsyncFn,
-  FieldAsyncValidateOrFn,
-} from "@tanstack/vue-form"
+import type { DeepKeys, DeepValue, FieldApi, FieldAsyncValidateOrFn, FieldValidateAsyncFn, FieldValidateFn, FieldValidateOrFn, FormAsyncValidateOrFn, FormValidateOrFn, StandardSchemaV1 } from "@tanstack/vue-form"
 
 export type OmegaFieldInternalApi<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> = FieldApi<
-/* in out TParentData*/ From,
-/* in out TName*/ TName,
-/* in out TData*/  DeepValue<From, TName>,
-/* in out TOnMount*/  FieldValidateOrFn<From, TName, DeepValue<From, TName>> | undefined,
-/* in out TOnChange*/  StandardSchemaV1<DeepValue<From, TName>, unknown> | FieldValidateFn<From, TName>,
-/* in out TOnChangeAsync*/  StandardSchemaV1<DeepValue<From, TName>, unknown> | FieldValidateAsyncFn<From, TName>,
-/* in out TOnBlur*/  FieldValidateOrFn<From, TName, DeepValue<From, TName>>,
-/* in out TOnBlurAsync*/  FieldAsyncValidateOrFn<From, TName, DeepValue<From, TName>>,
-/* in out TOnSubmit*/  FieldValidateOrFn<From, TName, DeepValue<From, TName>> | undefined,
-/* in out TOnSubmitAsync*/  FieldAsyncValidateOrFn<From, TName, DeepValue<From, TName>> | undefined,
-/* in out TFormOnMount*/  FormValidateOrFn<From> | undefined,
-/* in out TFormOnChange*/  FormValidateOrFn<From> | undefined,
-// using `any` for now to silence:
-/*
+  /* in out TParentData*/ From,
+  /* in out TName*/ TName,
+  /* in out TData*/ DeepValue<From, TName>,
+  /* in out TOnMount*/ FieldValidateOrFn<From, TName, DeepValue<From, TName>> | undefined,
+  /* in out TOnChange*/ StandardSchemaV1<DeepValue<From, TName>, unknown> | FieldValidateFn<From, TName>,
+  /* in out TOnChangeAsync*/ StandardSchemaV1<DeepValue<From, TName>, unknown> | FieldValidateAsyncFn<From, TName>,
+  /* in out TOnBlur*/ FieldValidateOrFn<From, TName, DeepValue<From, TName>>,
+  /* in out TOnBlurAsync*/ FieldAsyncValidateOrFn<From, TName, DeepValue<From, TName>>,
+  /* in out TOnSubmit*/ FieldValidateOrFn<From, TName, DeepValue<From, TName>> | undefined,
+  /* in out TOnSubmitAsync*/ FieldAsyncValidateOrFn<From, TName, DeepValue<From, TName>> | undefined,
+  /* in out TFormOnMount*/ FormValidateOrFn<From> | undefined,
+  /* in out TFormOnChange*/ FormValidateOrFn<From> | undefined,
+  // using `any` for now to silence:
+  /*
 Type 'FieldApi<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>, FieldValidateOrFn<From, DeepKeys<From>, DeepValue<From, DeepKeys<...>>> | undefined, ... 14 more ..., FormAsyncValidateOrFn<...> | undefined>' is not assignable to type 'OmegaFieldInternalApi<From, any>'.
   The types of 'form.options.defaultState' are incompatible between these types.
     Type 'Partial<FormState<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, ... 4 more ..., FormAsyncValidateOrFn<...> | undefined>> | undefined' is not assignable to type 'Partial<FormState<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From>, ... 4 more ..., FormAsyncValidateOrFn<...> | undefined>> | undefined'.
@@ -36,14 +24,14 @@ Type 'FieldApi<From, DeepKeys<From>, DeepValue<From, DeepKeys<From>>, FieldValid
           Type 'FormValidationErrorMap<undefined, undefined, Record<string, StandardSchemaV1Issue[]>, undefined, undefined, undefined, undefined, undefined> | undefined' is not assignable to type 'FormValidationErrorMap<undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined> | undefined'.
             Type 'FormValidationErrorMap<undefined, undefined, Record<string, StandardSchemaV1Issue[]>, undefined, undefined, undefined, undefined, undefined>' is not assignable to type 'FormValidationErrorMap<undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined>'.
               Type 'Record<string, StandardSchemaV1Issue[]>' is not assignable to type 'undefined'.
-*/
-/* in out TFormOnChangeAsync*/ any, // FormAsyncValidateOrFn<From>, 
-/* in out TFormOnBlur*/  FormValidateOrFn<From> | undefined,
-/* in out TFormOnBlurAsync*/  FormAsyncValidateOrFn<From> | undefined,
-/* in out TFormOnSubmit*/  FormValidateOrFn<From> | undefined,
-/* in out TFormOnSubmitAsync*/  FormAsyncValidateOrFn<From> | undefined,
-/* in out TFormOnServer*/  FormAsyncValidateOrFn<From> | undefined,
-/* in out TParentSubmitMeta*/  FormAsyncValidateOrFn<From> | undefined
+  */
+  /* in out TFormOnChangeAsync*/ any, // FormAsyncValidateOrFn<From>,
+  /* in out TFormOnBlur*/ FormValidateOrFn<From> | undefined,
+  /* in out TFormOnBlurAsync*/ FormAsyncValidateOrFn<From> | undefined,
+  /* in out TFormOnSubmit*/ FormValidateOrFn<From> | undefined,
+  /* in out TFormOnSubmitAsync*/ FormAsyncValidateOrFn<From> | undefined,
+  /* in out TFormOnServer*/ FormAsyncValidateOrFn<From> | undefined,
+  /* in out TParentSubmitMeta*/ FormAsyncValidateOrFn<From> | undefined
 >
 
 export type InputProps<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> = {

package/src/components/OmegaForm/OmegaArray.vue

@@ -1,14 +1,18 @@
 <template>
-  <component :is="form.Field" :name="name">
+  <component
+    :is="form.Field"
+    :name="name"
+  >
     <template #default="{ field, state }">
-      <slot name="pre-array" v-bind="{ field, state }" />
+      <slot
+        name="pre-array"
+        v-bind="{ field, state }"
+      />
       <component
         :is="form.Field"
         v-for="(_, i) of items"
         :key="`${name}[${Number(i)}]`"
-        :name="
-          `${name}[${Number(i)}]` as DeepKeys<From>
-        "
+        :name="`${name}[${Number(i)}]` as DeepKeys<From>"
       >
         <template #default="{ field: subField, state: subState }">
           <slot
@@ -16,14 +20,20 @@
               subField,
               subState,
               index: Number(i),
-              field,
+              field
             }"
           />
         </template>
       </component>
-      <slot name="post-array" v-bind="{ field, state }" />
+      <slot
+        name="post-array"
+        v-bind="{ field, state }"
+      />
       <!-- TODO: legacy slot, remove this slot -->
-      <slot name="field" v-bind="{ field }" />
+      <slot
+        name="field"
+        v-bind="{ field }"
+      />
     </template>
   </component>
 </template>
@@ -31,13 +41,13 @@
   setup
   lang="ts"
   generic="
-    From extends Record<PropertyKey, any>,
-    To extends Record<PropertyKey, any>
-  "
+  From extends Record<PropertyKey, any>,
+  To extends Record<PropertyKey, any>
+"
 >
+import { type DeepKeys, type DeepValue } from "@tanstack/vue-form"
 import { computed, onMounted, provide } from "vue"
 import { type OmegaInputProps } from "./OmegaFormStuff"
-import { type DeepValue, type DeepKeys } from "@tanstack/vue-form"
 
 const props = defineProps<
   Omit<
@@ -51,10 +61,10 @@ const props = defineProps<
 >()
 
 defineOptions({
-  inheritAttrs: false,
+  inheritAttrs: false
 })
 
-const store = props.form.useStore(state => state.values)
+const store = props.form.useStore((state) => state.values)
 const items = computed(() => {
   const normalizedPath = props.name.replace(/\[/g, ".").replace(/\]/g, "")
   try {

package/src/components/OmegaForm/OmegaAutoGen.vue

@@ -1,41 +1,49 @@
 <template>
   <slot
-    v-for="{ name, label, ...attrs } in children"
+    v-for="({ name, label, ...attrs }) in children"
     :child="{ name, label, ...attrs }"
   >
-    <OmegaInput :form="props.form" :name="name" :label="label" v-bind="attrs" />
+    <OmegaInput
+      :form="props.form"
+      :name="name"
+      :label="label"
+      v-bind="attrs"
+    />
   </slot>
 </template>
 
-<script setup lang="ts" generic="From extends Record<PropertyKey, string>, To extends Record<PropertyKey, string>">
+<script
+  setup
+  lang="ts"
+  generic="
+  From extends Record<PropertyKey, string>,
+  To extends Record<PropertyKey, string>
+"
+>
+import { type DeepKeys } from "@tanstack/vue-form"
+import { Array as A, Order, pipe } from "effect-app"
 import { computed } from "vue"
-import {
-  type NestedKeyOf,
-  type MetaRecord,
-  type FormType,
-  type FieldMeta,
-  type OmegaInputProps,
-} from "./OmegaFormStuff"
-import { pipe, Order, Array as A } from "effect-app"
+import { type FieldMeta, type OmegaInputProps } from "./OmegaFormStuff"
 import OmegaInput from "./OmegaInput.vue"
-import { DeepKeys } from "@tanstack/vue-form"
-import { OmegaFormReturn } from "./useOmegaForm"
 
-export type OmegaAutoGenMeta<From extends Record<PropertyKey, string>, To extends Record<PropertyKey, string>> = Omit<OmegaInputProps<From, To>, "form">
+export type OmegaAutoGenMeta<
+  From extends Record<PropertyKey, string>,
+  To extends Record<PropertyKey, string>
+> = Omit<OmegaInputProps<From, To>, "form">
 type NewMeta = OmegaAutoGenMeta<From, To>
 
 const mapObject =
   <K extends string, A, B>(fn: (value: A, key: K) => B) =>
   (obj: Record<K, A>): Record<K, B> =>
     Object.fromEntries(
-      (Object.entries(obj) as [K, A][]).map(([k, v]) => [k, fn(v, k)]),
+      (Object.entries(obj) as [K, A][]).map(([k, v]) => [k, fn(v, k)])
     ) as Record<K, B> // Cast needed for Object.fromEntries
 
 const filterRecord =
   <K extends string, V>(predicate: (value: V, key: K) => boolean) =>
   (obj: Record<K, V>): Record<K, V> =>
     Object.fromEntries(
-      (Object.entries(obj) as [K, V][]).filter(([k, v]) => predicate(v, k)),
+      (Object.entries(obj) as [K, V][]).filter(([k, v]) => predicate(v, k))
     ) as Record<K, V>
 
 const filterMapRecord =
@@ -49,11 +57,11 @@ const filterMapRecord =
         }
         return acc
       },
-      {} as Record<K, B>,
+      {} as Record<K, B>
     )
 
 const props = defineProps<{
-  form: OmegaInputProps<From, To>['form']
+  form: OmegaInputProps<From, To>["form"]
   pick?: DeepKeys<From>[]
   omit?: DeepKeys<From>[]
   labelMap?: (key: DeepKeys<From>) => string | undefined
@@ -69,7 +77,7 @@ const namePosition = (name: DeepKeys<From>, order: DeepKeys<From>[]) => {
 
 const orderBy: Order.Order<NewMeta> = Order.mapInput(
   Order.number,
-  (x: NewMeta) => namePosition(x.name, props.order || []),
+  (x: NewMeta) => namePosition(x.name, props.order || [])
 )
 
 const children = computed<NewMeta[]>(() =>
@@ -79,29 +87,29 @@ const children = computed<NewMeta[]>(() =>
     filterRecord((_, metaKey) =>
       props.pick
         ? props.pick.includes(metaKey) && !props.omit?.includes(metaKey)
-        : !props.omit?.includes(metaKey),
+        : !props.omit?.includes(metaKey)
     ),
-    x => x,
+    (x) => x,
     // labelMap and adding name
     mapObject((metaValue, metaKey) => ({
       name: metaKey,
       label: props.labelMap?.(metaKey) || metaKey,
-      ...metaValue,
+      ...metaValue
     })),
     // filterMap
     props.filterMap
-      ? filterMapRecord(m => {
-          const result = props.filterMap?.(m.name!, m as NewMeta)
-          return result === undefined || result === true ? m : result
-        })
-      : x => x,
+      ? filterMapRecord((m) => {
+        const result = props.filterMap?.(m.name!, m as NewMeta)
+        return result === undefined || result === true ? m : result
+      })
+      : (x) => x,
     // transform to array
-    obj => Object.values(obj) as NewMeta[],
+    (obj) => Object.values(obj) as NewMeta[],
     // order
     A.sort(orderBy),
     // sort
-    props.sort ? A.sort(props.sort) : x => x,
-  ),
+    props.sort ? A.sort(props.sort) : (x) => x
+  )
 )
 
 defineSlots<{