@effect-app/vue-components 4.0.0-beta.3 → 4.0.0-beta.30

package/dist/vue-components.es12.js

@@ -1,358 +1,418 @@
-import { isUnion as k, isUndefined as q, isDeclaration as C, isObjects as c, isNull as V, isArrays as $, isLiteral as B, isString as J, isNumber as G, isBoolean as R } from "./vue-components.es16.js";
-import { Array as H, String as N, Literal as K, Union as _, makeFilter as x, toStandardSchemaV1 as Q, Null as I, make as W, Unknown as j, Boolean as X, Int as Y, Number as Z, Undefined as ee } from "./vue-components.es17.js";
-import { useIntl as te, getTransformationFrom as E } from "./vue-components.es3.js";
-import { isObject as ne } from "./vue-components.es18.js";
-const ie = (e) => k(e) ? e.types.find((n) => q(n) || n === I.ast) : !1, g = (e) => !e || !k(e) ? !1 : e.types.find((n) => q(n)) ? "undefined" : e.types.find((n) => n === I.ast) ? "null" : !1, F = (e) => {
-  const n = [];
-  for (const t of e)
-    if (k(t)) {
-      const i = F(t.types);
-      n.push(...i);
+import { S as i, Effect as P, Option as w } from "effect-app";
+import { useIntl as I, getTransformationFrom as q } from "./vue-components.es3.js";
+import { isObject as G } from "./vue-components.es16.js";
+const E = /* @__PURE__ */ new Set(), K = () => globalThis.process?.env?.NODE_ENV !== "production", S = (e) => {
+  let t = q(e);
+  for (; i.AST.isDeclaration(t) && t.typeParameters.length > 0; )
+    t = q(t.typeParameters[0]);
+  return t;
+}, j = (e) => i.AST.isUndefined(e) || i.AST.isNull(e), _ = (e) => i.AST.isUnion(e) && e.types.length === 1 && i.AST.isLiteral(e.types[0]) ? e.types[0] : e, B = (e) => i.AST.isUnion(e) ? e.types.find((t) => j(t)) : !1, g = (e) => !e || !i.AST.isUnion(e) ? !1 : e.types.find((t) => i.AST.isUndefined(t)) ? "undefined" : e.types.find((t) => i.AST.isNull(t)) ? "null" : !1, U = (e) => {
+  const t = [];
+  for (const n of e)
+    if (i.AST.isUnion(n)) {
+      const r = U(n.types);
+      t.push(...r);
     } else
-      n.push(t);
-  return n;
-}, m = ({ meta: e = {}, parent: n = "", property: t, propertySignatures: i }, r = {}) => {
-  if (t && C(t)) {
-    const s = t.annotations?.title ?? "";
-    if (s !== "Int" && s !== "int")
-      return m({
-        parent: n,
-        meta: e,
-        property: t
-      });
-  }
-  if (t && c(t))
-    return m({
+      t.push(n);
+  return t;
+}, F = (e) => U(e).map(S).filter((t) => !j(t)), C = (e) => {
+  const t = i.AST.resolve(e)?.jsonSchema;
+  return t && typeof t == "object" ? t : {};
+}, D = (e) => {
+  if (e?.transformation?.decode?.run)
+    try {
+      const t = P.runSync(e.transformation.decode.run(w.none()));
+      return w.isSome(t) ? t.value : void 0;
+    } catch {
+      return;
+    }
+}, A = (e) => {
+  const t = e.context?.defaultValue?.[0], n = D(t);
+  if (n !== void 0) return n;
+  const r = e.encoding?.[0];
+  if (r && e.context?.isOptional)
+    return D(r);
+}, R = (e) => (e.checks ?? []).flatMap((n) => {
+  if (n._tag === "FilterGroup")
+    return n.checks.flatMap((a) => {
+      const s = a.annotations?.meta;
+      return s && typeof s == "object" ? [s] : [];
+    });
+  const r = n.annotations?.meta;
+  return r && typeof r == "object" ? [r] : [];
+}), $ = (e) => {
+  const t = {
+    description: i.AST.resolveDescription(e)
+  }, n = R(e);
+  if (i.AST.isString(e)) {
+    t.type = "string";
+    for (const r of n)
+      switch (r._tag) {
+        case "isMinLength":
+          t.minLength = r.minLength;
+          break;
+        case "isMaxLength":
+          t.maxLength = r.maxLength;
+          break;
+      }
+    i.AST.resolveTitle(e) === "Email" && (t.format = "email");
+  } else if (i.AST.isNumber(e)) {
+    t.type = "number";
+    for (const r of n)
+      switch (r._tag) {
+        case "isInt":
+          t.refinement = "int";
+          break;
+        case "isGreaterThanOrEqualTo":
+          t.minimum = r.minimum;
+          break;
+        case "isLessThanOrEqualTo":
+          t.maximum = r.maximum;
+          break;
+        case "isBetween":
+          t.minimum = r.minimum, t.maximum = r.maximum;
+          break;
+        case "isGreaterThan":
+          t.exclusiveMinimum = r.exclusiveMinimum;
+          break;
+        case "isLessThan":
+          t.exclusiveMaximum = r.exclusiveMaximum;
+          break;
+      }
+  } else i.AST.isBoolean(e) ? t.type = "boolean" : i.AST.isDeclaration(e) && e.annotations?.typeConstructor?._tag === "Date" ? t.type = "date" : t.type = "unknown";
+  return t;
+}, y = ({ meta: e = {}, parent: t = "", property: n, propertySignatures: r }, a = {}) => {
+  if (n && (n = S(n)), n && i.AST.isObjects(n))
+    return y({
       meta: e,
-      propertySignatures: t.propertySignatures
+      propertySignatures: n.propertySignatures
     });
-  if (i) {
-    for (const s of i) {
-      const o = n ? `${n}.${s.name.toString()}` : s.name.toString(), l = g(s.type), f = s.type.annotations?.title ?? "", a = f === "Int" || f === "int";
-      let p;
-      e._isNullableDiscriminatedUnion && s.name.toString() === "_tag" || e.required === !1 ? p = !1 : p = !l;
-      const v = s.type;
-      if (k(s.type)) {
-        const b = F(s.type.types).filter(
-          (u) => !q(u) && !V(u)
-        ).map(E);
-        if (b.some(
-          (u) => c(u)
-        )) {
-          if (!l) {
-            const u = m({
-              parent: o,
+  if (r) {
+    for (const s of r) {
+      const l = t ? `${t}.${s.name.toString()}` : s.name.toString(), o = g(s.type);
+      let m;
+      e._isNullableDiscriminatedUnion && s.name.toString() === "_tag" || e.required === !1 ? m = !1 : m = !o;
+      const c = S(s.type);
+      if (i.AST.isUnion(s.type)) {
+        const u = F(s.type.types);
+        if (u.some(i.AST.isObjects)) {
+          if (!o) {
+            const f = y({
+              parent: l,
               property: s.type,
-              meta: { required: p, nullableOrUndefined: l }
+              meta: { required: m, nullableOrUndefined: o }
             });
-            r[o] = u;
+            a[l] = f;
           }
-          for (const u of b)
-            if (c(u)) {
-              const y = l && b.length > 1;
-              Object.assign(
-                r,
-                m({
-                  parent: o,
-                  propertySignatures: u.propertySignatures,
-                  meta: y ? { _isNullableDiscriminatedUnion: !0 } : {}
-                })
-              );
+          for (const f of u)
+            if (i.AST.isObjects(f)) {
+              const p = o && u.length > 1, h = y({
+                parent: l,
+                propertySignatures: f.propertySignatures,
+                meta: p ? { _isNullableDiscriminatedUnion: !0 } : {}
+              });
+              for (const [d, T] of Object.entries(h)) {
+                const b = a[d];
+                b && b.type === "select" && T?.type === "select" ? b.members = [
+                  ...b.members,
+                  ...T.members.filter(
+                    (x) => !b.members.includes(x)
+                  )
+                ] : a[d] = T;
+              }
             }
         } else {
-          const u = b.filter($);
-          if (u.length > 0) {
-            const y = u[0];
-            if (r[o] = {
+          const f = u.filter(i.AST.isArrays);
+          if (f.length > 0) {
+            const p = f[0];
+            if (a[l] = {
               type: "multiple",
-              members: y.elements,
-              rest: y.rest,
-              required: p,
-              nullableOrUndefined: l
-            }, y.rest && y.rest.length > 0) {
-              const S = y.rest[0];
-              if (c(S))
-                for (const d of S.propertySignatures) {
-                  const O = `${o}.${d.name.toString()}`, h = m({
-                    parent: O,
+              members: p.elements,
+              rest: p.rest,
+              required: m,
+              nullableOrUndefined: o
+            }, p.rest && p.rest.length > 0) {
+              const h = S(p.rest[0]);
+              if (i.AST.isObjects(h))
+                for (const d of h.propertySignatures) {
+                  const T = `${l}.${d.name.toString()}`, b = y({
+                    parent: T,
                     property: d.type,
                     meta: {
                       required: !g(d.type),
                       nullableOrUndefined: g(d.type)
                     }
                   });
-                  if (h && typeof h == "object" && "type" in h && (r[O] = h, h.type === "multiple" && $(d.type) && d.type.rest && d.type.rest.length > 0)) {
-                    const P = d.type.rest[0];
-                    if (c(P))
-                      for (const T of P.propertySignatures) {
-                        const D = `${O}.${T.name.toString()}`, w = m({
-                          parent: D,
-                          property: T.type,
+                  if (b && typeof b == "object" && "type" in b && (a[T] = b, b.type === "multiple" && i.AST.isArrays(d.type) && d.type.rest && d.type.rest.length > 0)) {
+                    const x = S(d.type.rest[0]);
+                    if (i.AST.isObjects(x))
+                      for (const O of x.propertySignatures) {
+                        const N = `${T}.${O.name.toString()}`, k = y({
+                          parent: N,
+                          property: O.type,
                           meta: {
-                            required: !g(T.type),
-                            nullableOrUndefined: g(T.type)
+                            required: !g(O.type),
+                            nullableOrUndefined: g(O.type)
                           }
                         });
-                        w && typeof w == "object" && "type" in w && (r[D] = w);
+                        k && typeof k == "object" && "type" in k && (a[N] = k);
                       }
                   }
                 }
             }
           } else {
-            const y = m({
-              parent: o,
+            const p = y({
+              parent: l,
               property: s.type,
-              meta: { required: p, nullableOrUndefined: l }
+              meta: { required: m, nullableOrUndefined: o }
             });
-            r[o] = y;
+            a[l] = p;
           }
         }
-      } else {
-        const M = E(v);
-        if (c(M))
-          Object.assign(
-            r,
-            m({
-              parent: o,
-              propertySignatures: M.propertySignatures,
-              meta: { required: p, nullableOrUndefined: l }
-            })
-          );
-        else if ($(s.type))
-          if (s.type.rest.length > 0 && c(s.type.rest[0])) {
-            const L = s.type.rest[0];
-            if (c(L))
-              for (const u of L.propertySignatures) {
-                const y = `${o}.${u.name.toString()}`;
-                if ($(u.type) && u.type.rest.length > 0) {
-                  const S = u.type.rest[0];
-                  if (c(S))
-                    for (const d of S.propertySignatures) {
-                      const O = `${y}.${d.name.toString()}`, h = m({
-                        parent: O,
-                        property: d.type,
-                        meta: {
-                          required: !g(d.type),
-                          nullableOrUndefined: g(d.type)
-                        }
-                      });
-                      r[O] = h;
-                    }
-                  else
-                    r[y] = {
-                      type: "multiple",
-                      members: u.type.elements,
-                      rest: u.type.rest,
-                      required: !g(u.type),
-                      nullableOrUndefined: g(u.type)
-                    };
-                } else {
-                  const S = m({
-                    parent: y,
-                    property: u.type,
-                    meta: {
-                      required: !g(u.type),
-                      nullableOrUndefined: g(u.type)
-                    }
-                  });
-                  r[y] = S;
-                }
+      } else if (i.AST.isObjects(c))
+        Object.assign(
+          a,
+          y({
+            parent: l,
+            propertySignatures: c.propertySignatures,
+            meta: { required: m, nullableOrUndefined: o }
+          })
+        );
+      else if (i.AST.isArrays(s.type))
+        if (s.type.rest.length > 0 && i.AST.isObjects(S(s.type.rest[0]))) {
+          const v = S(s.type.rest[0]);
+          if (i.AST.isObjects(v))
+            for (const f of v.propertySignatures) {
+              const p = `${l}.${f.name.toString()}`;
+              if (i.AST.isArrays(f.type) && f.type.rest.length > 0) {
+                const h = S(f.type.rest[0]);
+                if (i.AST.isObjects(h))
+                  for (const d of h.propertySignatures) {
+                    const T = `${p}.${d.name.toString()}`, b = y({
+                      parent: T,
+                      property: d.type,
+                      meta: {
+                        required: !g(d.type),
+                        nullableOrUndefined: g(d.type)
+                      }
+                    });
+                    a[T] = b;
+                  }
+                else
+                  a[p] = {
+                    type: "multiple",
+                    members: f.type.elements,
+                    rest: f.type.rest,
+                    required: !g(f.type),
+                    nullableOrUndefined: g(f.type)
+                  };
+              } else {
+                const h = y({
+                  parent: p,
+                  property: f.type,
+                  meta: {
+                    required: !g(f.type),
+                    nullableOrUndefined: g(f.type)
+                  }
+                });
+                a[p] = h;
               }
-          } else
-            r[o] = {
-              type: "multiple",
-              members: s.type.elements,
-              rest: s.type.rest,
-              required: p,
-              nullableOrUndefined: l
-            };
-        else {
-          const b = m({
-            parent: o,
-            property: s.type,
-            meta: {
-              required: p,
-              nullableOrUndefined: l,
-              ...a && { refinement: "int" }
             }
-          });
-          r[o] = b;
-        }
+        } else
+          a[l] = {
+            type: "multiple",
+            members: s.type.elements,
+            rest: s.type.rest,
+            required: m,
+            nullableOrUndefined: o
+          };
+      else {
+        const u = y({
+          parent: l,
+          property: s.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: m && (!i.AST.isString(c) || !!$(s.type).minLength),
+            nullableOrUndefined: o
+          }
+        });
+        a[l] = u;
       }
     }
-    return r;
+    return a;
   }
-  if (t) {
-    const s = ie(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !s), k(t)) {
-      const f = F(t.types), a = f.find(
-        (p) => !q(p) && !V(p)
-      );
-      return c(a) ? m({
-        propertySignatures: a.propertySignatures,
-        parent: n,
-        meta: e
-      }) : f.every(B) ? {
+  if (n) {
+    const s = B(n);
+    if (n = S(n), Object.hasOwnProperty.call(e, "required") || (e.required = !s), i.AST.isUnion(n)) {
+      const l = U(n.types).map(S), o = l.filter((u) => !j(u));
+      if (o.length === 1 && i.AST.isLiteral(o[0]) && typeof o[0].literal == "boolean")
+        return y({ parent: t, meta: e, property: o[0] });
+      const m = o[0];
+      if (i.AST.isObjects(m))
+        return y({
+          propertySignatures: m.propertySignatures,
+          parent: t,
+          meta: e
+        });
+      const c = l.map(_);
+      return c.every((u) => j(u) || i.AST.isLiteral(u)) ? {
         ...e,
         type: "select",
-        members: f.map((p) => p.literal)
+        members: c.filter(i.AST.isLiteral).map((u) => u.literal)
       } : {
         ...e,
-        ...m({
-          parent: n,
+        ...y({
+          parent: t,
           meta: e,
-          property: a
+          property: m
         })
       };
     }
-    if ($(t))
-      return {
-        ...e,
-        type: "multiple",
-        members: t.elements,
-        rest: t.rest
-      };
-    e = { ...t.annotations?.jsonSchema ?? {}, ...e };
-    let l = t.annotations?.title ?? "unknown";
-    return l === "unknown" && (J(t) ? l = "string" : G(t) ? l = "number" : R(t) && (l = "boolean")), l === "Int" || l === "int" ? (e.type = "number", e.refinement = "int") : e.type = l, Object.hasOwnProperty.call(e, "required") || (e.required = !s), e;
+    return i.AST.isArrays(n) ? {
+      ...e,
+      type: "multiple",
+      members: n.elements,
+      rest: n.rest
+    } : (e = { ...C(n), ...$(n), ...e }, e);
   }
-  return r;
-}, z = (e, n = "") => {
-  const t = {};
-  for (const i in e) {
-    const r = e[i], s = n ? `${n}.${i}` : i;
-    r && typeof r == "object" && "type" in r ? t[s] = r : r && typeof r == "object" && Object.assign(t, z(r, s));
+  return a;
+}, V = (e, t = "") => {
+  const n = {};
+  for (const r in e) {
+    const a = e[r], s = t ? `${t}.${r}` : r;
+    a && typeof a == "object" && "type" in a ? n[s] = a : a && typeof a == "object" && Object.assign(n, V(a, s));
   }
-  return t;
-}, re = (e) => {
-  const n = e.ast, t = {}, i = {}, r = {};
-  if (k(n)) {
-    const o = n.types.filter((f) => !q(f) && !V(f)).map(E);
-    if (o.every((f) => c(f)) && o.length > 0) {
-      const f = [];
-      for (const a of o)
-        if (c(a)) {
-          const p = a.propertySignatures.find(
-            (b) => b.name.toString() === "_tag"
+  return n;
+}, J = (e) => {
+  const t = S(e.ast), n = {}, r = {}, a = {};
+  if (i.AST.isUnion(t)) {
+    const s = F(t.types);
+    if (s.every(i.AST.isObjects) && s.length > 0) {
+      const o = [];
+      for (const m of s)
+        if (i.AST.isObjects(m)) {
+          const c = m.propertySignatures.find(
+            (p) => p.name.toString() === "_tag"
           );
-          let v = null;
-          p && B(p.type) && (v = p.type.literal, f.push(v));
-          const M = m({
-            propertySignatures: a.propertySignatures
+          let u = null;
+          const v = c ? _(c.type) : null;
+          v && i.AST.isLiteral(v) && (u = v.literal, o.push(u), c && i.AST.isUnion(c.type) && K() && u != null && !E.has(u) && (E.add(u), console.warn(
+            `[OmegaForm] Union member with _tag "${u}" uses S.Struct({ _tag: S.Literal("${u}"), ... }). Please migrate to S.TaggedStruct("${u}", { ... }) for cleaner AST handling.`
+          )));
+          const f = y({
+            propertySignatures: m.propertySignatures
           });
-          v && (r[v] = z(M)), Object.assign(t, M);
+          u && (a[u] = V(f)), Object.assign(n, f);
         }
-      return f.length > 0 && (t._tag = {
+      return o.length > 0 && (n._tag = {
         type: "select",
-        members: f,
+        members: o,
         required: !0
-      }), { meta: t, defaultValues: i, unionMeta: r };
+      }), { meta: n, defaultValues: r, unionMeta: a };
     }
   }
-  if (c(n)) {
-    const s = m({
-      propertySignatures: n.propertySignatures
+  if (i.AST.isObjects(t)) {
+    const s = y({
+      propertySignatures: t.propertySignatures
     });
-    if (Object.values(s).every((l) => l && "type" in l))
-      return { meta: s, defaultValues: i, unionMeta: r };
-    const o = (l, f = "") => {
-      for (const a in l) {
-        const p = f ? `${f}.${a}` : a;
-        l[a] && typeof l[a] == "object" && "type" in l[a] ? t[p] = l[a] : l[a] && typeof l[a] == "object" && o(l[a], p);
+    if (Object.values(s).every((o) => o && "type" in o))
+      return { meta: s, defaultValues: r, unionMeta: a };
+    const l = (o, m = "") => {
+      for (const c in o) {
+        const u = m ? `${m}.${c}` : c;
+        o[c] && typeof o[c] == "object" && "type" in o[c] ? n[u] = o[c] : o[c] && typeof o[c] == "object" && l(o[c], u);
       }
     };
-    o(s);
+    l(s);
   }
-  return { meta: t, defaultValues: i, unionMeta: r };
-}, me = (e) => e, ye = (e) => {
-  const { meta: n, unionMeta: t } = re(e);
-  return { schema: e, meta: n, unionMeta: t };
-}, ce = (e, n) => {
-  n || (n = te().trans);
-  let t;
+  return { meta: n, defaultValues: r, unionMeta: a };
+}, Z = (e) => e, ee = (e) => {
+  const { meta: t, unionMeta: n } = J(e);
+  return { schema: e, meta: t, unionMeta: n };
+}, te = (e, t) => {
+  t || (t = I().trans);
+  let n;
   switch (e.type) {
-    case "string": {
-      if (t = N, e.format === "email" && (t = N.check(
-        x(
-          (i) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(i) || n("validation.email.invalid"),
-          { title: "email format" }
-        )
-      )), e.required || typeof e.minLength == "number") {
-        const i = e.required ? Math.max(1, e.minLength || 0) : e.minLength || 0;
-        i > 0 && (t = t.check(
-          x(
-            (r) => r.length >= i || n("validation.string.minLength", { minLength: i }),
-            { title: `minLength(${i})` }
-          )
-        ));
-      }
-      typeof e.maxLength == "number" && (t = t.check(
-        x(
-          (i) => i.length <= e.maxLength || n("validation.string.maxLength", { maxLength: e.maxLength }),
-          { title: `maxLength(${e.maxLength})` }
-        )
-      ));
+    case "string":
+      n = e.format === "email" ? i.Email.annotate({
+        message: t("validation.email.invalid")
+      }) : i.String.annotate({
+        message: t("validation.empty")
+      }), e.required && (n = n.check(i.isMinLength(1, {
+        message: t("validation.empty")
+      }))), typeof e.maxLength == "number" && (n = n.check(i.isMaxLength(e.maxLength, {
+        message: t("validation.string.maxLength", {
+          maxLength: e.maxLength
+        })
+      }))), typeof e.minLength == "number" && (n = n.check(i.isMinLength(e.minLength, {
+        message: t("validation.string.minLength", {
+          minLength: e.minLength
+        })
+      })));
       break;
-    }
-    case "number": {
-      e.refinement === "int" ? t = Y : t = Z, typeof e.minimum == "number" && (t = t.check(
-        x(
-          (i) => i >= e.minimum || n(
-            e.minimum === 0 ? "validation.number.positive" : "validation.number.min",
-            { minimum: e.minimum, isExclusive: !1 }
-          ),
-          { title: `>=${e.minimum}` }
-        )
-      )), typeof e.maximum == "number" && (t = t.check(
-        x(
-          (i) => i <= e.maximum || n("validation.number.max", {
-            maximum: e.maximum,
-            isExclusive: !1
-          }),
-          { title: `<=${e.maximum}` }
-        )
-      )), typeof e.exclusiveMinimum == "number" && (t = t.check(
-        x(
-          (i) => i > e.exclusiveMinimum || n(
-            e.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min",
-            { minimum: e.exclusiveMinimum, isExclusive: !0 }
-          ),
-          { title: `>${e.exclusiveMinimum}` }
-        )
-      )), typeof e.exclusiveMaximum == "number" && (t = t.check(
-        x(
-          (i) => i < e.exclusiveMaximum || n("validation.number.max", {
-            maximum: e.exclusiveMaximum,
-            isExclusive: !0
-          }),
-          { title: `<${e.exclusiveMaximum}` }
-        )
-      ));
+    case "number":
+      e.refinement === "int" ? n = i.Number.annotate({
+        message: t("validation.empty")
+      }).check(i.isInt({
+        message: t("validation.integer.expected", { actualValue: "NaN" })
+      })) : (n = i.Number.annotate({
+        message: t("validation.number.expected", { actualValue: "NaN" })
+      }), e.required && (n = n.annotate({
+        message: t("validation.empty")
+      }))), typeof e.minimum == "number" && (n = n.check(i.isGreaterThanOrEqualTo(e.minimum, {
+        message: t(e.minimum === 0 ? "validation.number.positive" : "validation.number.min", {
+          minimum: e.minimum,
+          isExclusive: !0
+        })
+      }))), typeof e.maximum == "number" && (n = n.check(i.isLessThanOrEqualTo(e.maximum, {
+        message: t("validation.number.max", {
+          maximum: e.maximum,
+          isExclusive: !0
+        })
+      }))), typeof e.exclusiveMinimum == "number" && (n = n.check(i.isGreaterThan(e.exclusiveMinimum, {
+        message: t(e.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min", {
+          minimum: e.exclusiveMinimum,
+          isExclusive: !1
+        })
+      }))), typeof e.exclusiveMaximum == "number" && (n = n.check(i.isLessThan(e.exclusiveMaximum, {
+        message: t("validation.number.max", {
+          maximum: e.exclusiveMaximum,
+          isExclusive: !1
+        })
+      })));
       break;
-    }
-    case "select": {
-      e.members.length === 0 ? t = j : e.members.length === 1 ? t = K(e.members[0]) : t = _(e.members.map((i) => K(i)));
+    case "select":
+      n = i.Literals(e.members).annotate({
+        message: t("validation.not_a_valid", {
+          type: "select",
+          message: e.members.join(", ")
+        })
+      });
       break;
-    }
-    case "multiple": {
-      t = H(N);
+    case "multiple":
+      n = i.Array(i.String).annotate({
+        message: t("validation.not_a_valid", {
+          type: "multiple",
+          message: e.members.join(", ")
+        })
+      });
       break;
-    }
-    case "boolean": {
-      t = X;
+    case "boolean":
+      n = i.Boolean;
       break;
-    }
-    case "unknown": {
-      t = j;
+    case "date":
+      n = i.Date;
       break;
-    }
-    default: {
-      console.warn(`Unhandled field type: ${e.type}`), t = j;
+    case "unknown":
+      n = i.Unknown;
+      break;
+    default:
+      console.warn(`Unhandled field type: ${e}`), n = i.Unknown;
       break;
-    }
   }
-  return e.required || (t = _([t, I, ee])), Q(t);
-}, se = [
+  return e.required || (n = i.NullishOr(n)), i.toStandardSchemaV1(n);
+}, W = [
   "button",
   "checkbox",
   "color",
@@ -368,72 +428,76 @@ const ie = (e) => k(e) ? e.types.find((n) => q(n) || n === I.ast) : !1, g = (e)
   "text",
   "time",
   "url"
-], de = (e) => se.includes(e) ? e : "text";
-function le(e, n) {
-  const t = { ...e };
-  for (const i in n)
-    Array.isArray(n[i]) ? t[i] = n[i] : n[i] && ne(n[i]) ? t[i] = le(t[i], n[i]) : t[i] = n[i];
-  return t;
+], ne = (e) => W.includes(e) ? e : "text";
+function z(e, t) {
+  const n = { ...e };
+  for (const r in t)
+    Array.isArray(t[r]) ? n[r] = t[r] : t[r] && G(t[r]) ? n[r] = z(n[r], t[r]) : n[r] = t[r];
+  return n;
 }
-function A(e) {
+function L(e) {
   return e && "fields" in e && typeof e.fields == "object";
 }
-function oe(e) {
+function H(e) {
   return e && "members" in e && Array.isArray(e.members);
 }
-const U = (e, n = {}) => {
-  const t = e.ast;
+const M = (e, t = {}) => {
+  const n = e.ast, r = A(n);
+  if (r !== void 0)
+    return r;
   if (g(e.ast) === "null")
     return null;
   if (g(e.ast) !== "undefined") {
-    if (c(t)) {
-      const i = { ...n };
-      for (const r of t.propertySignatures) {
-        const s = r.name.toString(), o = r.type;
-        let l;
-        e.fields && e.fields[s] ? l = e.fields[s] : l = W(o);
-        const f = U(l, n[s] || {});
-        f !== void 0 && (i[s] = f);
+    if (L(e)) {
+      const a = {};
+      for (const [s, l] of Object.entries(e.fields)) {
+        const o = A(l?.ast);
+        if (o !== void 0) {
+          a[s] = o;
+          continue;
+        }
+        const m = M(l, t[s] || {});
+        m !== void 0 ? a[s] = m : g(l.ast) === "undefined" && (a[s] = void 0);
       }
-      return i;
+      return { ...a, ...t };
     }
-    if (A(e)) {
-      const i = {};
-      for (const [r, s] of Object.entries(e.fields)) {
-        const o = s?.ast;
-        if (o?.defaultValue)
-          try {
-            i[r] = o.defaultValue();
+    if (e?.from && L(e.from))
+      return M(e.from, t);
+    if (H(e)) {
+      const a = e.members.reduce((s, l) => (L(l) && Object.entries(l.fields).forEach(([o, m]) => {
+        const c = A(m.ast), u = s[o] ? A(s[o].ast) : void 0;
+        (!s[o] || c !== void 0 && u === void 0) && (s[o] = m);
+      }), s), {});
+      return Object.keys(a).length === 0 ? Object.keys(t).length > 0 ? t : void 0 : Object.entries(a).reduce((s, [l, o]) => (s[l] = M(o, t[l] || {}), s), t);
+    }
+    if (Object.keys(t).length === 0) {
+      if (i.AST.isObjects(n)) {
+        const a = { ...t };
+        for (const s of n.propertySignatures) {
+          const l = s.name.toString(), o = s.type, m = A(o);
+          if (m !== void 0) {
+            a[l] = m;
             continue;
-          } catch {
           }
-        const l = U(s, n[r] || {});
-        l !== void 0 && (i[r] = l);
+          const c = i.make(o), u = M(c, t[l] || {});
+          u !== void 0 ? a[l] = u : g(o) === "undefined" && (a[l] = void 0);
+        }
+        return a;
       }
-      return { ...i, ...n };
-    }
-    if (e?.from && A(e.from))
-      return U(e.from, n);
-    if (oe(e)) {
-      const i = e.members.reduce((r, s) => (A(s) && Object.entries(s.fields).forEach(([o, l]) => {
-        const f = l.ast, a = r[o]?.ast;
-        (!r[o] || f?.defaultValue && !a?.defaultValue) && (r[o] = l);
-      }), r), {});
-      return Object.entries(i).reduce((r, [s, o]) => (r[s] = U(o, n[s] || {}), r), n);
+      if (i.AST.isString(n))
+        return "";
+      if (i.AST.isBoolean(n))
+        return !1;
     }
-    if (Object.keys(n).length === 0 && t.context?.defaultValue, J(t))
-      return "";
-    if (R(t))
-      return !1;
   }
 };
 export {
-  m as createMeta,
-  le as deepMerge,
-  U as defaultsValueFromSchema,
-  me as duplicateSchema,
-  ce as generateInputStandardSchemaFromFieldMeta,
-  ye as generateMetaFromSchema,
-  de as getInputType,
+  y as createMeta,
+  z as deepMerge,
+  M as defaultsValueFromSchema,
+  Z as duplicateSchema,
+  te as generateInputStandardSchemaFromFieldMeta,
+  ee as generateMetaFromSchema,
+  ne as getInputType,
   g as isNullableOrUndefined
 };