@effect-app/vue-components 2.9.2 → 2.10.2

package/dist/vue-components.es12.js

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