@effect-app/vue-components 1.8.2 → 1.8.4

package/dist/types/components/OmegaForm/InputProps.d.ts

@@ -10,7 +10,6 @@ export type InputProps<From extends Record<PropertyKey, any>, TName extends Deep
         min?: number | false;
         errorMessages: string[];
         error: boolean;
-        setRealDirty: () => void;
         label: string;
         type: string;
     };

package/dist/types/components/OmegaForm/OmegaErrorsInternal.vue.d.ts

@@ -3,7 +3,6 @@ import { type OmegaError } from "./OmegaFormStuff";
 type __VLS_Props = {
     errors: readonly OmegaError[];
     generalErrors: (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined;
-    showErrors: boolean;
 };
 declare var __VLS_6: {
     errors: readonly OmegaError[];

package/dist/types/components/OmegaForm/OmegaInput.vue.d.ts

@@ -14,7 +14,6 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends R
             min?: number | false;
             errorMessages: string[];
             error: boolean;
-            setRealDirty: () => void;
             label: string;
             type: string;
         }) => any;

package/dist/types/components/OmegaForm/OmegaInternalInput.vue.d.ts

@@ -1,4 +1,5 @@
 import { type DeepKeys } from "@tanstack/vue-form";
+import { type ComputedRef } from "vue";
 import type { OmegaFieldInternalApi } from "./InputProps";
 import type { FieldValidators, MetaRecord, NestedKeyOf, TypeOverride } from "./OmegaFormStuff";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
@@ -8,6 +9,15 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends
         label: string;
         type?: TypeOverride;
         validators?: FieldValidators<From>;
+        register: (field: ComputedRef<{
+            name: string;
+            label: string;
+            id: string;
+        }>) => void;
+        options?: {
+            title: string;
+            value: string;
+        }[];
     }> & import("vue").PublicProps;
     expose: (exposed: {}) => void;
     attrs: any;
@@ -22,7 +32,6 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends
             min?: number | false;
             errorMessages: string[];
             error: boolean;
-            setRealDirty: () => void;
             label: string;
             type: string;
         }) => any;

package/dist/types/components/OmegaForm/index.d.ts

@@ -1,4 +1,3 @@
-export * as OmegaErrorsContext from "./OmegaErrorsContext";
 export * from "./OmegaFormStuff";
 export { type OmegaConfig, type OmegaFormReturn, useOmegaForm } from "./useOmegaForm";
 export { type InputProps, type MergedInputProps } from "./InputProps";

package/dist/types/components/OmegaForm/useOmegaForm.d.ts

@@ -1,6 +1,6 @@
 import { type DeepKeys, DeepValue, StandardSchemaV1Issue, ValidationError, ValidationErrorMap } from "@tanstack/vue-form";
 import { Effect, Order, S } from "effect-app";
-import { type InjectionKey } from "vue";
+import { ComputedRef, type InjectionKey } from "vue";
 import { MergedInputProps } from "./InputProps";
 import { BaseProps, DefaultTypeProps, type FilterItems, type FormProps, type MetaRecord, type NestedKeyOf, OmegaAutoGenMeta, OmegaError, type OmegaFormApi, OmegaFormState, OmegaInputProps, ShowErrorsOn } from "./OmegaFormStuff";
 type keysRule<T> = {
@@ -44,6 +44,11 @@ export interface OF<From, To> extends OmegaFormApi<From, To> {
     filterItems?: FilterItems;
     clear: () => void;
     i18nNamespace?: string;
+    registerField: (field: ComputedRef<{
+        name: string;
+        label: string;
+        id: string;
+    }>) => void;
     /** @experimental */
     handleSubmitEffect: {
         /**

package/dist/types/components/OmegaForm/useRegisterField.d.ts

@@ -0,0 +1,7 @@
+import { type ComputedRef } from "vue";
+export declare const useRegisterField: (field: ComputedRef<{
+    name: string;
+    label: string;
+    id: string;
+}>) => void;
+export declare const provideRegisterField: () => void;

package/dist/vue-components.es.js

@@ -1,13 +1,12 @@
 import * as o from "./vue-components.es2.js";
-import { getTransformationFrom as f, provideIntl as u, useIntl as l, useIntlKey as i } from "./vue-components.es3.js";
-import { default as x } from "./vue-components.es4.js";
-import { default as g } from "./vue-components.es5.js";
-import { default as y } from "./vue-components.es6.js";
-import * as n from "./vue-components.es7.js";
-import { useOmegaForm as F } from "./vue-components.es8.js";
-import { useOnClose as C, usePreventClose as S } from "./vue-components.es9.js";
-import { createMeta as M, duplicateSchema as j, generateInputStandardSchemaFromFieldMeta as v, generateMetaFromSchema as P, getInputType as T, nullableInput as k } from "./vue-components.es10.js";
-import { createUseFormWithCustomInput as D } from "./vue-components.es11.js";
+import { getTransformationFrom as f, provideIntl as s, useIntl as u, useIntlKey as l } from "./vue-components.es3.js";
+import { default as i } from "./vue-components.es4.js";
+import { default as x } from "./vue-components.es5.js";
+import { default as g } from "./vue-components.es6.js";
+import { useOmegaForm as F } from "./vue-components.es7.js";
+import { useOnClose as h, usePreventClose as S } from "./vue-components.es8.js";
+import { createMeta as C, duplicateSchema as M, generateInputStandardSchemaFromFieldMeta as j, generateMetaFromSchema as v, getInputType as P, nullableInput as T } from "./vue-components.es9.js";
+import { createUseFormWithCustomInput as w } from "./vue-components.es10.js";
 function a(r) {
   for (const e in o)
     if (Object.prototype.hasOwnProperty.call(o, e)) {
@@ -15,25 +14,24 @@ function a(r) {
       t && typeof t == "object" && r.component(e, t);
     }
 }
-const m = { install: a };
+const n = { install: a };
 export {
-  x as Dialog,
-  n as OmegaErrorsContext,
-  g as OmegaInput,
-  y as OmegaVuetifyInput,
-  M as createMeta,
-  D as createUseFormWithCustomInput,
-  m as default,
-  j as duplicateSchema,
-  v as generateInputStandardSchemaFromFieldMeta,
-  P as generateMetaFromSchema,
-  T as getInputType,
+  i as Dialog,
+  x as OmegaInput,
+  g as OmegaVuetifyInput,
+  C as createMeta,
+  w as createUseFormWithCustomInput,
+  n as default,
+  M as duplicateSchema,
+  j as generateInputStandardSchemaFromFieldMeta,
+  v as generateMetaFromSchema,
+  P as getInputType,
   f as getTransformationFrom,
-  k as nullableInput,
-  u as provideIntl,
-  l as useIntl,
-  i as useIntlKey,
+  T as nullableInput,
+  s as provideIntl,
+  u as useIntl,
+  l as useIntlKey,
   F as useOmegaForm,
-  C as useOnClose,
+  h as useOnClose,
   S as usePreventClose
 };

package/dist/vue-components.es10.js

@@ -1,358 +1,29 @@
-import { S as n, Option as c, pipe as q } from "effect-app";
-import { getMetadataFromSchema as U } from "@effect-app/vue/form";
-import { useIntl as _, getTransformationFrom as N } from "./vue-components.es3.js";
-const w = n.NonEmptyArray(n.String), E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === n.Null.ast), g = (e) => !e || !n.AST.isUnion(e) ? !1 : e.types.find((i) => i._tag === "UndefinedKeyword") ? "undefined" : e.types.find((i) => i === n.Null.ast) ? "null" : !1, m = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: p }, o = {}) => {
-  if (t && t._tag === "Transformation")
-    return m({
-      parent: i,
-      meta: e,
-      property: t.from
-    });
-  if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return m({
-      meta: e,
-      propertySignatures: t.propertySignatures
-    });
-  if (p) {
-    for (const r of p) {
-      const l = i ? `${i}.${r.name.toString()}` : r.name.toString(), a = g(r.type), u = !a, A = r.type;
-      if (n.AST.isUnion(r.type)) {
-        const T = r.type.types.filter(
-          (s) => s._tag !== "UndefinedKeyword" && s !== n.Null.ast
-        ).map(N);
-        if (T.some(
-          (s) => "propertySignatures" in s
-        )) {
-          if (!a) {
-            const s = m({
-              parent: l,
-              property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
-            });
-            o[l] = s;
-          }
-          for (const s of T)
-            "propertySignatures" in s && Object.assign(
-              o,
-              m({
-                parent: l,
-                propertySignatures: s.propertySignatures,
-                meta: { required: u, nullableOrUndefined: a }
-              })
-            );
-        } else {
-          const s = T.filter(n.AST.isTupleType);
-          if (s.length > 0) {
-            const f = s[0];
-            if (o[l] = {
-              type: "multiple",
-              members: f.elements,
-              rest: f.rest,
-              required: u,
-              nullableOrUndefined: a
-            }, f.rest && f.rest.length > 0) {
-              const d = f.rest[0];
-              if (d.type._tag === "TypeLiteral" && "propertySignatures" in d.type)
-                for (const y of d.type.propertySignatures) {
-                  const b = `${l}.${y.name.toString()}`, S = m({
-                    parent: b,
-                    property: y.type,
-                    meta: {
-                      required: !g(y.type),
-                      nullableOrUndefined: g(y.type)
-                    }
-                  });
-                  if (S && typeof S == "object" && "type" in S && (o[b] = S, S.type === "multiple" && n.AST.isTupleType(y.type) && y.type.rest && y.type.rest.length > 0)) {
-                    const O = y.type.rest[0];
-                    if (O.type._tag === "TypeLiteral" && "propertySignatures" in O.type)
-                      for (const x of O.type.propertySignatures) {
-                        const M = `${b}.${x.name.toString()}`, v = m({
-                          parent: M,
-                          property: x.type,
-                          meta: {
-                            required: !g(x.type),
-                            nullableOrUndefined: g(x.type)
-                          }
-                        });
-                        v && typeof v == "object" && "type" in v && (o[M] = v);
-                      }
-                  }
-                }
-            }
-          } else {
-            const f = m({
-              parent: l,
-              property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
-            });
-            o[l] = f;
-          }
+import { h as t } from "vue";
+import i from "./vue-components.es5.js";
+import { useOmegaForm as f } from "./vue-components.es7.js";
+const g = (r) => (...e) => {
+  const [o, n, m] = e;
+  return f(
+    o,
+    n,
+    {
+      ...m,
+      input: {
+        name: "WrappedInput",
+        inheritAttrs: !1,
+        setup(p, { attrs: s }) {
+          return () => t(i, {
+            ...p,
+            ...s
+          }, {
+            // Override the default slot that OmegaInternalInput provides
+            default: ({ field: a, ...u }) => t(r, { field: a, inputProps: u })
+          });
         }
-      } else if ("propertySignatures" in A)
-        Object.assign(
-          o,
-          m({
-            parent: l,
-            propertySignatures: A.propertySignatures,
-            meta: { required: u, nullableOrUndefined: a }
-          })
-        );
-      else if (n.AST.isTupleType(r.type))
-        if (r.type.rest.length > 0 && r.type.rest[0].type._tag === "TypeLiteral" && "propertySignatures" in r.type.rest[0].type) {
-          const h = r.type.rest[0].type;
-          if (h._tag === "TypeLiteral" && "propertySignatures" in h)
-            for (const s of h.propertySignatures) {
-              const f = `${l}.${s.name.toString()}`;
-              if (n.AST.isTupleType(s.type) && s.type.rest.length > 0) {
-                const d = s.type.rest[0].type;
-                if (d._tag === "TypeLiteral" && "propertySignatures" in d)
-                  for (const y of d.propertySignatures) {
-                    const b = `${f}.${y.name.toString()}`, S = m({
-                      parent: b,
-                      property: y.type,
-                      meta: {
-                        required: !g(y.type),
-                        nullableOrUndefined: g(y.type)
-                      }
-                    });
-                    o[b] = S;
-                  }
-                else
-                  o[f] = {
-                    type: "multiple",
-                    members: s.type.elements,
-                    rest: s.type.rest,
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
-                  };
-              } else {
-                const d = m({
-                  parent: f,
-                  property: s.type,
-                  meta: {
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
-                  }
-                });
-                o[f] = d;
-              }
-            }
-        } else
-          o[l] = {
-            type: "multiple",
-            members: r.type.elements,
-            rest: r.type.rest,
-            required: u,
-            nullableOrUndefined: a
-          };
-      else {
-        const T = m({
-          parent: l,
-          property: r.type,
-          meta: {
-            // an empty string is valid for a S.String field, so we should not mark it as required
-            // TODO: handle this better via the createMeta minLength parsing
-            required: u && (r.type._tag !== "StringKeyword" || U(r.type).minLength),
-            nullableOrUndefined: a
-          }
-        });
-        o[l] = T;
       }
     }
-    return o;
-  }
-  if (t) {
-    const r = E(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), n.AST.isUnion(t)) {
-      const a = t.types.find(
-        (u) => u._tag !== "UndefinedKeyword" && u !== n.Null.ast
-      );
-      return "propertySignatures" in a ? m({
-        propertySignatures: a.propertySignatures,
-        parent: i,
-        meta: e
-      }) : t.types.every(n.AST.isLiteral) ? {
-        ...e,
-        type: "select",
-        members: t.types.map((u) => u.literal)
-      } : {
-        ...e,
-        ...m({
-          parent: i,
-          meta: e,
-          property: a
-        })
-      };
-    }
-    if (n.AST.isTupleType(t))
-      return {
-        ...e,
-        type: "multiple",
-        members: t.elements,
-        rest: t.rest
-      };
-    const l = n.AST.getAnnotation(
-      t,
-      n.AST.JSONSchemaAnnotationId
-    ).pipe(c.getOrElse(() => ({})));
-    return e = { ...e, ...l }, "from" in t ? m({
-      parent: i,
-      meta: e,
-      property: t.from
-    }) : (e.type = n.AST.getAnnotation(
-      t,
-      n.AST.TitleAnnotationId
-    ).pipe(
-      c.getOrElse(() => "unknown")
-    ), e);
-  }
-  return o;
-}, L = (e) => {
-  const i = e.ast, t = {};
-  if (i._tag === "Transformation" || i._tag === "Refinement")
-    return L(n.make(i.from));
-  if ("propertySignatures" in i) {
-    const p = m({
-      propertySignatures: i.propertySignatures
-    });
-    if (Object.values(p).every((r) => r && "type" in r))
-      return p;
-    const o = (r, l = "") => {
-      for (const a in r) {
-        const u = l ? `${l}.${a}` : a;
-        r[a] && typeof r[a] == "object" && "type" in r[a] ? t[u] = r[a] : r[a] && typeof r[a] == "object" && o(r[a], u);
-      }
-    };
-    o(p);
-  }
-  return t;
-}, P = (e) => n.extend(e, n.Struct({})), F = (e) => {
-  const i = L(e), t = q(
-    e.ast,
-    c.liftPredicate((p) => p._tag === "Refinement" && "filter" in p),
-    c.flatMap((p) => n.AST.getJSONSchemaAnnotation(p)),
-    c.filter((p) => "items" in p),
-    c.filterMap(({ items: p }) => n.decodeUnknownOption(w)(p)),
-    c.zipWith(
-      n.AST.getMessageAnnotation(e.ast),
-      (p, o) => ({
-        items: p,
-        message: o("")
-      })
-    ),
-    c.getOrUndefined
   );
-  return { schema: e, meta: i, filterItems: t };
-}, j = (e) => {
-  const { trans: i } = _();
-  let t;
-  switch (e.type) {
-    case "string":
-      t = n.String.annotations({
-        message: () => i("validation.empty")
-      }), e.format === "email" && (t = n.compose(
-        t,
-        n.Email.annotations({
-          message: () => i("validation.email.invalid")
-        })
-      )), e.required && t.annotations({
-        message: () => i("validation.empty")
-      }), e.maxLength && (t = t.pipe(n.maxLength(e.maxLength)).annotations({
-        message: () => i("validation.string.maxLength", {
-          maxLength: e.maxLength
-        })
-      })), e.minLength && (t = t.pipe(n.minLength(e.minLength)).annotations({
-        message: () => i("validation.string.minLength", {
-          minLength: e.minLength
-        })
-      }));
-      break;
-    case "number":
-      t = n.Number.annotations({
-        message: () => i("validation.empty")
-      }), e.required && t.annotations({
-        message: () => i("validation.empty")
-      }), e.minimum && (t = t.pipe(n.greaterThanOrEqualTo(e.minimum)).annotations({
-        message: () => i("validation.number.min", {
-          minimum: e.minimum,
-          isExclusive: !0
-        })
-      })), e.maximum && (t = t.pipe(n.lessThanOrEqualTo(e.maximum)).annotations({
-        message: () => i("validation.number.max", {
-          maximum: e.maximum,
-          isExclusive: !0
-        })
-      })), e.exclusiveMinimum && (t = t.pipe(n.greaterThan(e.exclusiveMinimum)).annotations({
-        message: () => i("validation.number.min", {
-          minimum: e.exclusiveMinimum,
-          isExclusive: !1
-        })
-      })), e.exclusiveMaximum && (t = t.pipe(n.lessThan(e.exclusiveMaximum)).annotations({
-        message: () => i("validation.number.max", {
-          maximum: e.exclusiveMaximum,
-          isExclusive: !1
-        })
-      }));
-      break;
-    case "select":
-      t = n.Literal(...e.members).annotations({
-        message: () => ({
-          message: i("validation.not_a_valid", {
-            type: "select",
-            message: e.members.join(", ")
-          }),
-          override: !0
-        })
-      });
-      break;
-    case "multiple":
-      t = n.Array(n.String).annotations({
-        message: () => i("validation.not_a_valid", {
-          type: "multiple",
-          message: e.members.join(", ")
-        })
-      });
-      break;
-    case "boolean":
-      t = n.Boolean;
-      break;
-    // todo: switch must be exhaustive or have default case, otherwise falls through with schema undefined.
-    case "unknown":
-      t = n.Unknown;
-      break;
-  }
-  return e.required ? t.pipe(
-    n.annotations({
-      message: () => i("validation.empty")
-    })
-  ) : t = n.NullishOr(t), n.standardSchemaV1(t);
-}, R = (e, i) => n.NullOr(e).pipe(
-  n.transform(n.typeSchema(e), {
-    decode: (t) => t ?? i(),
-    encode: (t) => t
-  })
-), k = [
-  "button",
-  "checkbox",
-  "color",
-  "date",
-  "email",
-  "number",
-  "password",
-  "radio",
-  "range",
-  "search",
-  "submit",
-  "tel",
-  "text",
-  "time",
-  "url"
-], J = (e) => k.includes(e) ? e : "text";
+};
 export {
-  m as createMeta,
-  P as duplicateSchema,
-  j as generateInputStandardSchemaFromFieldMeta,
-  F as generateMetaFromSchema,
-  J as getInputType,
-  R as nullableInput
+  g as createUseFormWithCustomInput
 };

package/dist/vue-components.es11.js

@@ -1,29 +1,4 @@
-import { h as t } from "vue";
-import i from "./vue-components.es5.js";
-import { useOmegaForm as f } from "./vue-components.es8.js";
-const g = (r) => (...e) => {
-  const [o, n, m] = e;
-  return f(
-    o,
-    n,
-    {
-      ...m,
-      input: {
-        name: "WrappedInput",
-        inheritAttrs: !1,
-        setup(p, { attrs: s }) {
-          return () => t(i, {
-            ...p,
-            ...s
-          }, {
-            // Override the default slot that OmegaInternalInput provides
-            default: ({ field: a, ...u }) => t(r, { field: a, inputProps: u })
-          });
-        }
-      }
-    }
-  );
-};
+import f from "./vue-components.es4.js";
 export {
-  g as createUseFormWithCustomInput
+  f as default
 };

package/dist/vue-components.es12.js

@@ -1,4 +1,12 @@
-import f from "./vue-components.es4.js";
+import { Exit as c, Runtime as s } from "effect";
+import { dual as n, isFunction as m } from "./vue-components.es26.js";
+const i = Symbol.for("clone-trait"), u = n(2, (e, t) => i in e ? e[i](t) : Object.setPrototypeOf(t, Object.getPrototypeOf(e)));
+n(2, (e, t) => u(e, { ...e, ...m(t) ? t(e) : t }));
+const b = (e) => new Promise((t, r) => e.addObserver((o) => {
+  c.isSuccess(o) ? t(o.value) : r(s.makeFiberFailure(o.cause));
+}));
 export {
-  f as default
+  u as clone,
+  i as cloneTrait,
+  b as runtimeFiberAsPromise
 };

package/dist/vue-components.es13.js

@@ -1,12 +1,7 @@
-import { Exit as c, Runtime as s } from "effect";
-import { dual as n, isFunction as m } from "./vue-components.es27.js";
-const i = Symbol.for("clone-trait"), u = n(2, (e, t) => i in e ? e[i](t) : Object.setPrototypeOf(t, Object.getPrototypeOf(e)));
-n(2, (e, t) => u(e, { ...e, ...m(t) ? t(e) : t }));
-const b = (e) => new Promise((t, r) => e.addObserver((o) => {
-  c.isSuccess(o) ? t(o.value) : r(s.makeFiberFailure(o.cause));
-}));
+import { isFunction as c } from "./vue-components.es26.js";
+const s = c, t = (o) => typeof o == "object" && o !== null, i = (o) => t(o) || s(o);
 export {
-  u as clone,
-  i as cloneTrait,
-  b as runtimeFiberAsPromise
+  s as isFunction,
+  i as isObject,
+  t as isRecordOrArray
 };

package/dist/vue-components.es14.js

@@ -1,7 +1,56 @@
-import { isFunction as c } from "./vue-components.es27.js";
-const s = c, t = (o) => typeof o == "object" && o !== null, i = (o) => t(o) || s(o);
+import { defineComponent as F, computed as i, onMounted as M, provide as P, createBlock as c, openBlock as s, resolveDynamicComponent as p, withCtx as g, renderSlot as o, createElementBlock as k, normalizeProps as l, guardReactiveProps as u, Fragment as A, renderList as b, mergeProps as B } from "vue";
+const N = /* @__PURE__ */ F({
+  inheritAttrs: !1,
+  __name: "OmegaArray",
+  props: {
+    form: {},
+    name: {},
+    defaultItems: {},
+    items: {}
+  },
+  setup(n) {
+    const a = n, y = a.form.useStore((e) => e.values), d = i(() => {
+      const e = a.name.replace(/\[/g, ".").replace(/\]/g, "");
+      try {
+        return e.split(".").reduce((r, t) => r && r[t], y.value);
+      } catch (r) {
+        return console.error(r), [];
+      }
+    });
+    M(async () => {
+      a.defaultItems && !d.value && a.form.setFieldValue(a.name, a.defaultItems);
+    });
+    const $ = i(() => (r) => {
+      const t = r.replace(/\[\d+\]/g, "");
+      return a.form.meta[t];
+    });
+    return P("getMetaFromArray", $), (e, r) => (s(), c(p(n.form.Field), { name: n.name }, {
+      default: g(({ field: t, state: f }) => [
+        o(e.$slots, "pre-array", l(u({ field: t, state: f }))),
+        (s(!0), k(A, null, b(d.value, (C, m) => (s(), c(p(n.form.Field), {
+          key: `${n.name}[${Number(m)}]`,
+          name: (
+            // eslint-disable-next-line
+            `${n.name}[${Number(m)}]`
+          )
+        }, {
+          default: g(({ field: v, state: h }) => [
+            o(e.$slots, "default", B({ ref_for: !0 }, {
+              subField: v,
+              subState: h,
+              index: Number(m),
+              field: t
+            }))
+          ]),
+          _: 2
+        }, 1032, ["name"]))), 128)),
+        o(e.$slots, "post-array", l(u({ field: t, state: f }))),
+        o(e.$slots, "field", l(u({ field: t })))
+      ]),
+      _: 3
+    }, 8, ["name"]));
+  }
+});
 export {
-  s as isFunction,
-  i as isObject,
-  t as isRecordOrArray
+  N as default
 };