@effect-app/vue-components 3.2.0 → 4.0.0-beta.0

package/dist/vue-components.es12.js

@@ -1,391 +1,358 @@
-import { S as i, Option as M } from "effect-app";
-import { getMetadataFromSchema as V } from "@effect-app/vue/form";
-import { useIntl as E, getTransformationFrom as _ } from "./vue-components.es3.js";
-import { isObject as $ } from "./vue-components.es17.js";
-const j = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKeyword" || n === i.Null.ast), c = (e) => !e || !i.AST.isUnion(e) ? !1 : e.types.find((n) => n._tag === "UndefinedKeyword") ? "undefined" : e.types.find((n) => n === i.Null.ast) ? "null" : !1, L = (e) => {
+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.es17.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.es18.js";
+import { useIntl as te, getTransformationFrom as E } from "./vue-components.es3.js";
+import { isObject as ne } from "./vue-components.es19.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 (i.AST.isUnion(t)) {
-      const o = L(t.types);
-      n.push(...o);
+    if (k(t)) {
+      const i = F(t.types);
+      n.push(...i);
     } else
       n.push(t);
   return n;
-}, y = ({ meta: e = {}, parent: n = "", property: t, propertySignatures: o }, s = {}) => {
-  if (t && t._tag === "Transformation") {
-    const r = i.AST.getAnnotation(t, i.AST.TitleAnnotationId).pipe(M.getOrElse(() => ""));
-    if (r !== "Int" && r !== "int")
-      return y({
+}, 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.from
+        property: t
       });
   }
-  if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return y({
+  if (t && c(t))
+    return m({
       meta: e,
       propertySignatures: t.propertySignatures
     });
-  if (o) {
-    for (const r of o) {
-      const l = n ? `${n}.${r.name.toString()}` : r.name.toString(), a = c(r.type);
-      let f;
-      e._isNullableDiscriminatedUnion && r.name.toString() === "_tag" || e.required === !1 ? f = !1 : f = !a;
-      const p = r.type;
-      if (i.AST.isUnion(r.type)) {
-        const S = L(r.type.types).filter(
-          (u) => u._tag !== "UndefinedKeyword" && u !== i.Null.ast
-        ).map(_);
-        if (S.some(
-          (u) => "propertySignatures" in u
+  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 (!a) {
-            const u = y({
-              parent: l,
-              property: r.type,
-              meta: { required: f, nullableOrUndefined: a }
+          if (!l) {
+            const u = m({
+              parent: o,
+              property: s.type,
+              meta: { required: p, nullableOrUndefined: l }
             });
-            s[l] = u;
+            r[o] = u;
           }
-          for (const u of S)
-            if ("propertySignatures" in u) {
-              const m = a && S.length > 1;
+          for (const u of b)
+            if (c(u)) {
+              const y = l && b.length > 1;
               Object.assign(
-                s,
-                y({
-                  parent: l,
+                r,
+                m({
+                  parent: o,
                   propertySignatures: u.propertySignatures,
-                  meta: m ? { _isNullableDiscriminatedUnion: !0 } : {}
+                  meta: y ? { _isNullableDiscriminatedUnion: !0 } : {}
                 })
               );
             }
         } else {
-          const u = S.filter(i.AST.isTupleType);
+          const u = b.filter($);
           if (u.length > 0) {
-            const m = u[0];
-            if (s[l] = {
+            const y = u[0];
+            if (r[o] = {
               type: "multiple",
-              members: m.elements,
-              rest: m.rest,
-              required: f,
-              nullableOrUndefined: a
-            }, m.rest && m.rest.length > 0) {
-              const T = m.rest[0];
-              if (T.type._tag === "TypeLiteral" && "propertySignatures" in T.type)
-                for (const g of T.type.propertySignatures) {
-                  const h = `${l}.${g.name.toString()}`, v = y({
-                    parent: h,
-                    property: g.type,
+              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,
+                    property: d.type,
                     meta: {
-                      required: !c(g.type),
-                      nullableOrUndefined: c(g.type)
+                      required: !g(d.type),
+                      nullableOrUndefined: g(d.type)
                     }
                   });
-                  if (v && typeof v == "object" && "type" in v && (s[h] = v, v.type === "multiple" && i.AST.isTupleType(g.type) && g.type.rest && g.type.rest.length > 0)) {
-                    const w = g.type.rest[0];
-                    if (w.type._tag === "TypeLiteral" && "propertySignatures" in w.type)
-                      for (const x of w.type.propertySignatures) {
-                        const N = `${h}.${x.name.toString()}`, O = y({
-                          parent: N,
-                          property: x.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,
                           meta: {
-                            required: !c(x.type),
-                            nullableOrUndefined: c(x.type)
+                            required: !g(T.type),
+                            nullableOrUndefined: g(T.type)
                           }
                         });
-                        O && typeof O == "object" && "type" in O && (s[N] = O);
+                        w && typeof w == "object" && "type" in w && (r[D] = w);
                       }
                   }
                 }
             }
           } else {
-            const m = y({
-              parent: l,
-              property: r.type,
-              meta: { required: f, nullableOrUndefined: a }
+            const y = m({
+              parent: o,
+              property: s.type,
+              meta: { required: p, nullableOrUndefined: l }
             });
-            s[l] = m;
+            r[o] = y;
           }
         }
       } else {
-        const d = _(p);
-        if ("propertySignatures" in d)
+        const M = E(v);
+        if (c(M))
           Object.assign(
-            s,
-            y({
-              parent: l,
-              propertySignatures: d.propertySignatures,
-              meta: { required: f, nullableOrUndefined: a }
+            r,
+            m({
+              parent: o,
+              propertySignatures: M.propertySignatures,
+              meta: { required: p, nullableOrUndefined: l }
             })
           );
-        else if (i.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 b = r.type.rest[0].type;
-            if (b._tag === "TypeLiteral" && "propertySignatures" in b)
-              for (const u of b.propertySignatures) {
-                const m = `${l}.${u.name.toString()}`;
-                if (i.AST.isTupleType(u.type) && u.type.rest.length > 0) {
-                  const T = u.type.rest[0].type;
-                  if (T._tag === "TypeLiteral" && "propertySignatures" in T)
-                    for (const g of T.propertySignatures) {
-                      const h = `${m}.${g.name.toString()}`, v = y({
-                        parent: h,
-                        property: g.type,
+        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: !c(g.type),
-                          nullableOrUndefined: c(g.type)
+                          required: !g(d.type),
+                          nullableOrUndefined: g(d.type)
                         }
                       });
-                      s[h] = v;
+                      r[O] = h;
                     }
                   else
-                    s[m] = {
+                    r[y] = {
                       type: "multiple",
                       members: u.type.elements,
                       rest: u.type.rest,
-                      required: !c(u.type),
-                      nullableOrUndefined: c(u.type)
+                      required: !g(u.type),
+                      nullableOrUndefined: g(u.type)
                     };
                 } else {
-                  const T = y({
-                    parent: m,
+                  const S = m({
+                    parent: y,
                     property: u.type,
                     meta: {
-                      required: !c(u.type),
-                      nullableOrUndefined: c(u.type)
+                      required: !g(u.type),
+                      nullableOrUndefined: g(u.type)
                     }
                   });
-                  s[m] = T;
+                  r[y] = S;
                 }
               }
           } else
-            s[l] = {
+            r[o] = {
               type: "multiple",
-              members: r.type.elements,
-              rest: r.type.rest,
-              required: f,
-              nullableOrUndefined: a
+              members: s.type.elements,
+              rest: s.type.rest,
+              required: p,
+              nullableOrUndefined: l
             };
         else {
-          const S = y({
-            parent: l,
-            property: r.type,
+          const b = m({
+            parent: o,
+            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: f && (r.type._tag !== "StringKeyword" || V(r.type).minLength),
-              nullableOrUndefined: a
+              required: p,
+              nullableOrUndefined: l,
+              ...a && { refinement: "int" }
             }
           });
-          s[l] = S;
+          r[o] = b;
         }
       }
     }
-    return s;
+    return r;
   }
   if (t) {
-    const r = j(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), i.AST.isUnion(t)) {
-      const f = L(t.types), p = f.find(
-        (d) => d._tag !== "UndefinedKeyword" && d !== i.Null.ast
+    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 "propertySignatures" in p ? y({
-        propertySignatures: p.propertySignatures,
+      return c(a) ? m({
+        propertySignatures: a.propertySignatures,
         parent: n,
         meta: e
-      }) : f.every(i.AST.isLiteral) ? {
+      }) : f.every(B) ? {
         ...e,
         type: "select",
-        members: f.map((d) => d.literal)
+        members: f.map((p) => p.literal)
       } : {
         ...e,
-        ...y({
+        ...m({
           parent: n,
           meta: e,
-          property: p
+          property: a
         })
       };
     }
-    if (i.AST.isTupleType(t))
+    if ($(t))
       return {
         ...e,
         type: "multiple",
         members: t.elements,
         rest: t.rest
       };
-    e = { ...i.AST.getAnnotation(
-      t,
-      i.AST.JSONSchemaAnnotationId
-    ).pipe(M.getOrElse(() => ({}))), ...e };
-    const a = i.AST.getAnnotation(
-      t,
-      i.AST.TitleAnnotationId
-    ).pipe(
-      M.getOrElse(() => "unknown")
-    );
-    if (a === "Int" || a === "int")
-      e.type = "number", e.refinement = "int";
-    else {
-      if ("from" in t)
-        return y({
-          parent: n,
-          meta: e,
-          property: t.from
-        });
-      e.type = a;
-    }
-    return e;
+    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 s;
-}, q = (e, n = "") => {
+  return r;
+}, z = (e, n = "") => {
   const t = {};
-  for (const o in e) {
-    const s = e[o], r = n ? `${n}.${o}` : o;
-    s && typeof s == "object" && "type" in s ? t[r] = s : s && typeof s == "object" && Object.assign(t, q(s, r));
+  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 t;
-}, k = (e) => {
-  const n = e.ast, t = {}, o = {}, s = {};
-  if (n._tag === "Transformation" || n._tag === "Refinement")
-    return k(i.make(n.from));
-  if (n._tag === "Union") {
-    const a = (n.types || []).filter((p) => p._tag !== "UndefinedKeyword" && p !== i.Null.ast).map(_);
-    if (a.every((p) => p._tag === "TypeLiteral" && "propertySignatures" in p) && a.length > 0) {
-      const p = [];
-      for (const d of a)
-        if ("propertySignatures" in d) {
-          const S = d.propertySignatures.find(
-            (m) => m.name.toString() === "_tag"
+}, 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"
           );
-          let b = null;
-          S && i.AST.isLiteral(S.type) && (b = S.type.literal, p.push(b));
-          const u = y({
-            propertySignatures: d.propertySignatures
+          let v = null;
+          p && B(p.type) && (v = p.type.literal, f.push(v));
+          const M = m({
+            propertySignatures: a.propertySignatures
           });
-          b && (s[b] = q(u)), Object.assign(t, u);
+          v && (r[v] = z(M)), Object.assign(t, M);
         }
-      return p.length > 0 && (t._tag = {
+      return f.length > 0 && (t._tag = {
         type: "select",
-        members: p,
+        members: f,
         required: !0
-      }), { meta: t, defaultValues: o, unionMeta: s };
+      }), { meta: t, defaultValues: i, unionMeta: r };
     }
   }
-  if ("propertySignatures" in n) {
-    const r = y({
+  if (c(n)) {
+    const s = m({
       propertySignatures: n.propertySignatures
     });
-    if (Object.values(r).every((a) => a && "type" in a))
-      return { meta: r, defaultValues: o, unionMeta: s };
-    const l = (a, f = "") => {
-      for (const p in a) {
-        const d = f ? `${f}.${p}` : p;
-        a[p] && typeof a[p] == "object" && "type" in a[p] ? t[d] = a[p] : a[p] && typeof a[p] == "object" && l(a[p], d);
+    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);
       }
     };
-    l(r);
+    o(s);
   }
-  return { meta: t, defaultValues: o, unionMeta: s };
-}, B = (e) => i.extend(e, i.Struct({})), z = (e) => {
-  const { meta: n, unionMeta: t } = k(e);
+  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 };
-}, C = (e, n) => {
-  n || (n = E().trans);
+}, ce = (e, n) => {
+  n || (n = te().trans);
   let t;
   switch (e.type) {
-    case "string":
-      t = i.String.annotations({
-        message: () => n("validation.empty")
-      }), e.format === "email" && (t = i.compose(
-        t,
-        i.Email.annotations({
-          message: () => n("validation.email.invalid")
-        })
-      )), e.required && (t = t.annotations({
-        message: () => n("validation.empty")
-      }).pipe(i.minLength(1)).annotations({
-        message: () => n("validation.empty")
-      })), typeof e.maxLength == "number" && (t = t.pipe(i.maxLength(e.maxLength)).annotations({
-        message: () => n("validation.string.maxLength", {
-          maxLength: e.maxLength
-        })
-      })), typeof e.minLength == "number" && (t = t.pipe(i.minLength(e.minLength)).annotations({
-        message: () => n("validation.string.minLength", {
-          minLength: e.minLength
-        })
-      }));
-      break;
-    case "number":
-      e.refinement === "int" ? t = i.Number.annotations({
-        message: () => n("validation.empty")
-      }).pipe(
-        i.int({ message: (s) => n("validation.integer.expected", { actualValue: String(s.actual) }) })
-      ) : (t = i.Number.annotations({
-        message: () => n("validation.number.expected", { actualValue: "NaN" })
-      }), e.required && t.annotations({
-        message: () => n("validation.empty")
-      })), typeof e.minimum == "number" && (t = t.pipe(i.greaterThanOrEqualTo(e.minimum)).annotations({
-        message: () => n(e.minimum === 0 ? "validation.number.positive" : "validation.number.min", {
-          minimum: e.minimum,
-          isExclusive: !0
-        })
-      })), typeof e.maximum == "number" && (t = t.pipe(i.lessThanOrEqualTo(e.maximum)).annotations({
-        message: () => n("validation.number.max", {
-          maximum: e.maximum,
-          isExclusive: !0
-        })
-      })), typeof e.exclusiveMinimum == "number" && (t = t.pipe(i.greaterThan(e.exclusiveMinimum)).annotations({
-        message: () => n(e.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min", {
-          minimum: e.exclusiveMinimum,
-          isExclusive: !1
-        })
-      })), typeof e.exclusiveMaximum == "number" && (t = t.pipe(i.lessThan(e.exclusiveMaximum)).annotations({
-        message: () => n("validation.number.max", {
-          maximum: e.exclusiveMaximum,
-          isExclusive: !1
-        })
-      }));
+    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})` }
+        )
+      ));
       break;
-    case "select":
-      t = i.Literal(...e.members).annotations({
-        message: () => ({
-          message: n("validation.not_a_valid", {
-            type: "select",
-            message: e.members.join(", ")
+    }
+    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
           }),
-          override: !0
-        })
-      });
+          { 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}` }
+        )
+      ));
       break;
-    case "multiple":
-      t = i.Array(i.String).annotations({
-        message: () => n("validation.not_a_valid", {
-          type: "multiple",
-          message: e.members.join(", ")
-        })
-      });
+    }
+    case "select": {
+      e.members.length === 0 ? t = j : e.members.length === 1 ? t = K(e.members[0]) : t = _(e.members.map((i) => K(i)));
+      break;
+    }
+    case "multiple": {
+      t = H(N);
       break;
-    case "boolean":
-      t = i.Boolean;
+    }
+    case "boolean": {
+      t = X;
       break;
-    case "unknown":
-      t = i.Unknown;
+    }
+    case "unknown": {
+      t = j;
       break;
-    default:
-      console.warn(`Unhandled field type: ${e}`), t = i.Unknown;
+    }
+    default: {
+      console.warn(`Unhandled field type: ${e.type}`), t = j;
       break;
+    }
   }
-  return e.required ? t.pipe(
-    i.annotations({
-      message: () => n("validation.empty")
-    })
-  ) : t = i.NullishOr(t), i.standardSchemaV1(t);
-}, G = (e, n) => i.NullOr(e).pipe(
-  i.transform(i.typeSchema(e), {
-    decode: (t) => t ?? n(),
-    encode: (t) => t
-  })
-), K = [
+  return e.required || (t = _([t, I, ee])), Q(t);
+}, se = [
   "button",
   "checkbox",
   "color",
@@ -401,90 +368,72 @@ const j = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
   "text",
   "time",
   "url"
-], H = (e) => K.includes(e) ? e : "text";
-function I(e, n) {
+], de = (e) => se.includes(e) ? e : "text";
+function le(e, n) {
   const t = { ...e };
-  for (const o in n)
-    Array.isArray(n[o]) ? t[o] = n[o] : n[o] && $(n[o]) ? t[o] = I(t[o], n[o]) : t[o] = n[o];
+  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;
 }
-function U(e) {
+function A(e) {
   return e && "fields" in e && typeof e.fields == "object";
 }
-function F(e) {
+function oe(e) {
   return e && "members" in e && Array.isArray(e.members);
 }
-const A = (e, n = {}) => {
+const U = (e, n = {}) => {
   const t = e.ast;
-  if (t?.defaultValue)
-    return t.defaultValue();
-  if (c(e.ast) === "null")
+  if (g(e.ast) === "null")
     return null;
-  if (c(e.ast) !== "undefined") {
-    if (U(e)) {
-      const o = {};
-      for (const [s, r] of Object.entries(e.fields)) {
-        const l = r?.ast;
-        if (l?.defaultValue)
+  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);
+      }
+      return i;
+    }
+    if (A(e)) {
+      const i = {};
+      for (const [r, s] of Object.entries(e.fields)) {
+        const o = s?.ast;
+        if (o?.defaultValue)
           try {
-            o[s] = l.defaultValue();
+            i[r] = o.defaultValue();
             continue;
           } catch {
           }
-        const a = A(r, n[s] || {});
-        a !== void 0 && (o[s] = a);
+        const l = U(s, n[r] || {});
+        l !== void 0 && (i[r] = l);
       }
-      return { ...o, ...n };
+      return { ...i, ...n };
     }
-    if (e?.from && U(e.from))
-      return A(e.from, n);
-    if (F(e)) {
-      const o = e.members.reduce((s, r) => (U(r) && Object.entries(r.fields).forEach(([l, a]) => {
-        const f = a.ast, p = s[l]?.ast;
-        (!s[l] || f?.defaultValue && !p?.defaultValue) && (s[l] = a);
-      }), s), {});
-      return Object.entries(o).reduce((s, [r, l]) => (s[r] = A(l, n[r] || {}), s), 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 (Object.keys(n).length === 0)
-      switch (e.ast._tag) {
-        case "Refinement":
-          return A(i.make(e.ast.from), n);
-        case "Transformation": {
-          const o = i.make(e.ast.from);
-          return A(o, n);
-        }
-        case "TypeLiteral": {
-          const o = { ...n };
-          for (const s of t.propertySignatures) {
-            const r = s.name.toString(), l = s.type;
-            if (l._tag === "Transformation" && l.defaultValue) {
-              o[r] = l.defaultValue();
-              continue;
-            }
-            if (l.defaultValue) {
-              o[r] = l.defaultValue();
-              continue;
-            }
-            const a = i.make(l), f = A(a, n[r] || {});
-            f !== void 0 && (o[r] = f);
-          }
-          return o;
-        }
-        case "StringKeyword":
-          return "";
-        case "BooleanKeyword":
-          return !1;
-      }
+    if (Object.keys(n).length === 0 && t.context?.defaultValue, J(t))
+      return "";
+    if (R(t))
+      return !1;
   }
 };
 export {
-  y as createMeta,
-  I as deepMerge,
-  A as defaultsValueFromSchema,
-  B as duplicateSchema,
-  C as generateInputStandardSchemaFromFieldMeta,
-  z as generateMetaFromSchema,
-  H as getInputType,
-  c as isNullableOrUndefined,
-  G as nullableInput
+  m as createMeta,
+  le as deepMerge,
+  U as defaultsValueFromSchema,
+  me as duplicateSchema,
+  ce as generateInputStandardSchemaFromFieldMeta,
+  ye as generateMetaFromSchema,
+  de as getInputType,
+  g as isNullableOrUndefined
 };