@effect-app/vue-components 3.0.4 → 3.0.6

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

@@ -95,7 +95,7 @@ export type StringFieldMeta = BaseFieldMeta & {
     format?: string;
 };
 export type NumberFieldMeta = BaseFieldMeta & {
-    type: "number";
+    type: "number" | "int";
     minimum?: number;
     maximum?: number;
     exclusiveMinimum?: number;

package/dist/vue-components.es12.js

@@ -1,282 +1,296 @@
-import { S as i, Option as q } from "effect-app";
-import { getMetadataFromSchema as V } from "@effect-app/vue/form";
-import { useIntl as E, getTransformationFrom as U } from "./vue-components.es3.js";
+import { S as i, Option as w } from "effect-app";
+import { getMetadataFromSchema as k } from "@effect-app/vue/form";
+import { useIntl as V, getTransformationFrom as _ } from "./vue-components.es3.js";
 import { isObject as $ } from "./vue-components.es16.js";
-const j = (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, _ = (e) => {
+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) => {
   const n = [];
   for (const t of e)
     if (i.AST.isUnion(t)) {
-      const o = _(t.types);
+      const o = L(t.types);
       n.push(...o);
     } else
       n.push(t);
   return n;
-}, y = ({ meta: e = {}, parent: n = "", property: t, propertySignatures: o }, r = {}) => {
-  if (t && t._tag === "Transformation")
-    return y({
-      parent: n,
-      meta: e,
-      property: t.from
-    });
+}, 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(w.getOrElse(() => ""));
+    if (r !== "Int" && r !== "int")
+      return y({
+        parent: n,
+        meta: e,
+        property: t.from
+      });
+  }
   if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
     return y({
       meta: e,
       propertySignatures: t.propertySignatures
     });
   if (o) {
-    for (const s of o) {
-      const l = n ? `${n}.${s.name.toString()}` : s.name.toString(), a = g(s.type);
-      let f;
-      e._isNullableDiscriminatedUnion && s.name.toString() === "_tag" || e.required === !1 ? f = !1 : f = !a;
-      const p = s.type;
-      if (i.AST.isUnion(s.type)) {
-        const c = _(s.type.types).filter(
-          (u) => u._tag !== "UndefinedKeyword" && u !== i.Null.ast
-        ).map(U);
-        if (c.some(
-          (u) => "propertySignatures" in u
+    for (const r of o) {
+      const u = n ? `${n}.${r.name.toString()}` : r.name.toString(), a = c(r.type);
+      let m;
+      e._isNullableDiscriminatedUnion && r.name.toString() === "_tag" || e.required === !1 ? m = !1 : m = !a;
+      const l = r.type;
+      if (i.AST.isUnion(r.type)) {
+        const S = L(r.type.types).filter(
+          (p) => p._tag !== "UndefinedKeyword" && p !== i.Null.ast
+        ).map(_);
+        if (S.some(
+          (p) => "propertySignatures" in p
         )) {
           if (!a) {
-            const u = y({
-              parent: l,
-              property: s.type,
-              meta: { required: f, nullableOrUndefined: a }
+            const p = y({
+              parent: u,
+              property: r.type,
+              meta: { required: m, nullableOrUndefined: a }
             });
-            r[l] = u;
+            s[u] = p;
           }
-          for (const u of c)
-            if ("propertySignatures" in u) {
-              const m = a && c.length > 1;
+          for (const p of S)
+            if ("propertySignatures" in p) {
+              const f = a && S.length > 1;
               Object.assign(
-                r,
+                s,
                 y({
-                  parent: l,
-                  propertySignatures: u.propertySignatures,
-                  meta: m ? { _isNullableDiscriminatedUnion: !0 } : {}
+                  parent: u,
+                  propertySignatures: p.propertySignatures,
+                  meta: f ? { _isNullableDiscriminatedUnion: !0 } : {}
                 })
               );
             }
         } else {
-          const u = c.filter(i.AST.isTupleType);
-          if (u.length > 0) {
-            const m = u[0];
-            if (r[l] = {
+          const p = S.filter(i.AST.isTupleType);
+          if (p.length > 0) {
+            const f = p[0];
+            if (s[u] = {
               type: "multiple",
-              members: m.elements,
-              rest: m.rest,
-              required: f,
+              members: f.elements,
+              rest: f.rest,
+              required: m,
               nullableOrUndefined: a
-            }, m.rest && m.rest.length > 0) {
-              const T = m.rest[0];
+            }, f.rest && f.rest.length > 0) {
+              const T = f.rest[0];
               if (T.type._tag === "TypeLiteral" && "propertySignatures" in T.type)
-                for (const d of T.type.propertySignatures) {
-                  const h = `${l}.${d.name.toString()}`, v = y({
-                    parent: h,
-                    property: d.type,
+                for (const g of T.type.propertySignatures) {
+                  const x = `${u}.${g.name.toString()}`, v = y({
+                    parent: x,
+                    property: g.type,
                     meta: {
-                      required: !g(d.type),
-                      nullableOrUndefined: g(d.type)
+                      required: !c(g.type),
+                      nullableOrUndefined: c(g.type)
                     }
                   });
-                  if (v && typeof v == "object" && "type" in v && (r[h] = v, v.type === "multiple" && i.AST.isTupleType(d.type) && d.type.rest && d.type.rest.length > 0)) {
-                    const w = d.type.rest[0];
-                    if (w.type._tag === "TypeLiteral" && "propertySignatures" in w.type)
-                      for (const A of w.type.propertySignatures) {
-                        const L = `${h}.${A.name.toString()}`, O = y({
-                          parent: L,
+                  if (v && typeof v == "object" && "type" in v && (s[x] = v, v.type === "multiple" && i.AST.isTupleType(g.type) && g.type.rest && g.type.rest.length > 0)) {
+                    const M = g.type.rest[0];
+                    if (M.type._tag === "TypeLiteral" && "propertySignatures" in M.type)
+                      for (const A of M.type.propertySignatures) {
+                        const N = `${x}.${A.name.toString()}`, O = y({
+                          parent: N,
                           property: A.type,
                           meta: {
-                            required: !g(A.type),
-                            nullableOrUndefined: g(A.type)
+                            required: !c(A.type),
+                            nullableOrUndefined: c(A.type)
                           }
                         });
-                        O && typeof O == "object" && "type" in O && (r[L] = O);
+                        O && typeof O == "object" && "type" in O && (s[N] = O);
                       }
                   }
                 }
             }
           } else {
-            const m = y({
-              parent: l,
-              property: s.type,
-              meta: { required: f, nullableOrUndefined: a }
+            const f = y({
+              parent: u,
+              property: r.type,
+              meta: { required: m, nullableOrUndefined: a }
             });
-            r[l] = m;
+            s[u] = f;
           }
         }
       } else {
-        const S = U(p);
-        if ("propertySignatures" in S)
+        const d = _(l);
+        if ("propertySignatures" in d)
           Object.assign(
-            r,
+            s,
             y({
-              parent: l,
-              propertySignatures: S.propertySignatures,
-              meta: { required: f, nullableOrUndefined: a }
+              parent: u,
+              propertySignatures: d.propertySignatures,
+              meta: { required: m, nullableOrUndefined: a }
             })
           );
-        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 b = s.type.rest[0].type;
+        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;
+              for (const p of b.propertySignatures) {
+                const f = `${u}.${p.name.toString()}`;
+                if (i.AST.isTupleType(p.type) && p.type.rest.length > 0) {
+                  const T = p.type.rest[0].type;
                   if (T._tag === "TypeLiteral" && "propertySignatures" in T)
-                    for (const d of T.propertySignatures) {
-                      const h = `${m}.${d.name.toString()}`, v = y({
-                        parent: h,
-                        property: d.type,
+                    for (const g of T.propertySignatures) {
+                      const x = `${f}.${g.name.toString()}`, v = y({
+                        parent: x,
+                        property: g.type,
                         meta: {
-                          required: !g(d.type),
-                          nullableOrUndefined: g(d.type)
+                          required: !c(g.type),
+                          nullableOrUndefined: c(g.type)
                         }
                       });
-                      r[h] = v;
+                      s[x] = v;
                     }
                   else
-                    r[m] = {
+                    s[f] = {
                       type: "multiple",
-                      members: u.type.elements,
-                      rest: u.type.rest,
-                      required: !g(u.type),
-                      nullableOrUndefined: g(u.type)
+                      members: p.type.elements,
+                      rest: p.type.rest,
+                      required: !c(p.type),
+                      nullableOrUndefined: c(p.type)
                     };
                 } else {
                   const T = y({
-                    parent: m,
-                    property: u.type,
+                    parent: f,
+                    property: p.type,
                     meta: {
-                      required: !g(u.type),
-                      nullableOrUndefined: g(u.type)
+                      required: !c(p.type),
+                      nullableOrUndefined: c(p.type)
                     }
                   });
-                  r[m] = T;
+                  s[f] = T;
                 }
               }
           } else
-            r[l] = {
+            s[u] = {
               type: "multiple",
-              members: s.type.elements,
-              rest: s.type.rest,
-              required: f,
+              members: r.type.elements,
+              rest: r.type.rest,
+              required: m,
               nullableOrUndefined: a
             };
         else {
-          const c = y({
-            parent: l,
-            property: s.type,
+          const S = y({
+            parent: u,
+            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: f && (s.type._tag !== "StringKeyword" || V(s.type).minLength),
+              required: m && (r.type._tag !== "StringKeyword" || k(r.type).minLength),
               nullableOrUndefined: a
             }
           });
-          r[l] = c;
+          s[u] = S;
         }
       }
     }
-    return r;
+    return s;
   }
   if (t) {
-    const s = j(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !s), i.AST.isUnion(t)) {
-      const a = _(t.types), f = a.find(
-        (p) => p._tag !== "UndefinedKeyword" && p !== i.Null.ast
+    const r = j(t);
+    if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), i.AST.isUnion(t)) {
+      const m = L(t.types), l = m.find(
+        (d) => d._tag !== "UndefinedKeyword" && d !== i.Null.ast
       );
-      return "propertySignatures" in f ? y({
-        propertySignatures: f.propertySignatures,
+      return "propertySignatures" in l ? y({
+        propertySignatures: l.propertySignatures,
         parent: n,
         meta: e
-      }) : a.every(i.AST.isLiteral) ? {
+      }) : m.every(i.AST.isLiteral) ? {
         ...e,
         type: "select",
-        members: a.map((p) => p.literal)
+        members: m.map((d) => d.literal)
       } : {
         ...e,
         ...y({
           parent: n,
           meta: e,
-          property: f
+          property: l
         })
       };
     }
-    return i.AST.isTupleType(t) ? {
-      ...e,
-      type: "multiple",
-      members: t.elements,
-      rest: t.rest
-    } : (e = { ...i.AST.getAnnotation(
+    if (i.AST.isTupleType(t))
+      return {
+        ...e,
+        type: "multiple",
+        members: t.elements,
+        rest: t.rest
+      };
+    e = { ...i.AST.getAnnotation(
       t,
       i.AST.JSONSchemaAnnotationId
-    ).pipe(q.getOrElse(() => ({}))), ...e }, "from" in t ? y({
-      parent: n,
-      meta: e,
-      property: t.from
-    }) : (e.type = i.AST.getAnnotation(
+    ).pipe(w.getOrElse(() => ({}))), ...e };
+    const a = i.AST.getAnnotation(
       t,
       i.AST.TitleAnnotationId
     ).pipe(
-      q.getOrElse(() => "unknown")
-    ), e));
+      w.getOrElse(() => "unknown")
+    );
+    if (a === "Int" || a === "int")
+      e.type = "int";
+    else {
+      if ("from" in t)
+        return y({
+          parent: n,
+          meta: e,
+          property: t.from
+        });
+      e.type = a;
+    }
+    return e;
   }
-  return r;
-}, N = (e, n = "") => {
+  return s;
+}, q = (e, n = "") => {
   const t = {};
   for (const o in e) {
-    const r = e[o], s = n ? `${n}.${o}` : o;
-    r && typeof r == "object" && "type" in r ? t[s] = r : r && typeof r == "object" && Object.assign(t, N(r, s));
+    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));
   }
   return t;
-}, k = (e) => {
-  const n = e.ast, t = {}, o = {}, r = {};
+}, E = (e) => {
+  const n = e.ast, t = {}, o = {}, s = {};
   if (n._tag === "Transformation" || n._tag === "Refinement")
-    return k(i.make(n.from));
+    return E(i.make(n.from));
   if (n._tag === "Union") {
-    const a = (n.types || []).filter((p) => p._tag !== "UndefinedKeyword" && p !== i.Null.ast).map(U);
-    if (a.every((p) => p._tag === "TypeLiteral" && "propertySignatures" in p) && a.length > 0) {
-      const p = [];
-      for (const S of a)
-        if ("propertySignatures" in S) {
-          const c = S.propertySignatures.find(
-            (m) => m.name.toString() === "_tag"
+    const a = (n.types || []).filter((l) => l._tag !== "UndefinedKeyword" && l !== i.Null.ast).map(_);
+    if (a.every((l) => l._tag === "TypeLiteral" && "propertySignatures" in l) && a.length > 0) {
+      const l = [];
+      for (const d of a)
+        if ("propertySignatures" in d) {
+          const S = d.propertySignatures.find(
+            (f) => f.name.toString() === "_tag"
           );
           let b = null;
-          c && i.AST.isLiteral(c.type) && (b = c.type.literal, p.push(b));
-          const u = y({
-            propertySignatures: S.propertySignatures
+          S && i.AST.isLiteral(S.type) && (b = S.type.literal, l.push(b));
+          const p = y({
+            propertySignatures: d.propertySignatures
           });
-          b && (r[b] = N(u)), Object.assign(t, u);
+          b && (s[b] = q(p)), Object.assign(t, p);
         }
-      return p.length > 0 && (t._tag = {
+      return l.length > 0 && (t._tag = {
         type: "select",
-        members: p,
+        members: l,
         required: !0
-      }), { meta: t, defaultValues: o, unionMeta: r };
+      }), { meta: t, defaultValues: o, unionMeta: s };
     }
   }
   if ("propertySignatures" in n) {
-    const s = y({
+    const r = y({
       propertySignatures: n.propertySignatures
     });
-    if (Object.values(s).every((a) => a && "type" in a))
-      return { meta: s, defaultValues: o, unionMeta: r };
-    const l = (a, f = "") => {
-      for (const p in a) {
-        const S = f ? `${f}.${p}` : p;
-        a[p] && typeof a[p] == "object" && "type" in a[p] ? t[S] = a[p] : a[p] && typeof a[p] == "object" && l(a[p], S);
+    if (Object.values(r).every((a) => a && "type" in a))
+      return { meta: r, defaultValues: o, unionMeta: s };
+    const u = (a, m = "") => {
+      for (const l in a) {
+        const d = m ? `${m}.${l}` : l;
+        a[l] && typeof a[l] == "object" && "type" in a[l] ? t[d] = a[l] : a[l] && typeof a[l] == "object" && u(a[l], d);
       }
     };
-    l(s);
+    u(r);
   }
-  return { meta: t, defaultValues: o, unionMeta: r };
+  return { meta: t, defaultValues: o, unionMeta: s };
 }, B = (e) => i.extend(e, i.Struct({})), z = (e) => {
-  const { meta: n, unionMeta: t } = k(e);
+  const { meta: n, unionMeta: t } = E(e);
   return { schema: e, meta: n, unionMeta: t };
 }, C = (e, n) => {
-  n || (n = E().trans);
+  n || (n = V().trans);
   let t;
   switch (e.type) {
     case "string":
@@ -301,9 +315,37 @@ const j = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
         })
       }));
       break;
-    case "number":
+    case "int": {
       t = i.Number.annotations({
         message: () => n("validation.empty")
+      }).pipe(
+        i.int({ message: (s) => n("validation.integer.expected", { actualValue: String(s.actual) }) })
+      ), 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
+        })
+      }));
+      break;
+    }
+    case "number":
+      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({
@@ -384,71 +426,71 @@ const j = (e) => i.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKe
   "time",
   "url"
 ], H = (e) => K.includes(e) ? e : "text";
-function F(e, n) {
+function I(e, n) {
   const t = { ...e };
   for (const o in n)
-    Array.isArray(n[o]) ? t[o] = n[o] : n[o] && $(n[o]) ? t[o] = F(t[o], n[o]) : t[o] = n[o];
+    Array.isArray(n[o]) ? t[o] = n[o] : n[o] && $(n[o]) ? t[o] = I(t[o], n[o]) : t[o] = n[o];
   return t;
 }
-function M(e) {
+function U(e) {
   return e && "fields" in e && typeof e.fields == "object";
 }
-function P(e) {
+function F(e) {
   return e && "members" in e && Array.isArray(e.members);
 }
-const x = (e, n = {}) => {
+const h = (e, n = {}) => {
   const t = e.ast;
   if (t?.defaultValue)
     return t.defaultValue();
-  if (g(e.ast) === "null")
+  if (c(e.ast) === "null")
     return null;
-  if (g(e.ast) !== "undefined") {
-    if (M(e)) {
+  if (c(e.ast) !== "undefined") {
+    if (U(e)) {
       const o = {};
-      for (const [r, s] of Object.entries(e.fields)) {
-        const l = s?.ast;
-        if (l?.defaultValue)
+      for (const [s, r] of Object.entries(e.fields)) {
+        const u = r?.ast;
+        if (u?.defaultValue)
           try {
-            o[r] = l.defaultValue();
+            o[s] = u.defaultValue();
             continue;
           } catch {
           }
-        const a = x(s, n[r] || {});
-        a !== void 0 && (o[r] = a);
+        const a = h(r, n[s] || {});
+        a !== void 0 && (o[s] = a);
       }
       return { ...o, ...n };
     }
-    if (e?.from && M(e.from))
-      return x(e.from, n);
-    if (P(e)) {
-      const o = e.members.reduce((r, s) => (M(s) && Object.entries(s.fields).forEach(([l, a]) => {
-        const f = a.ast, p = r[l]?.ast;
-        (!r[l] || f?.defaultValue && !p?.defaultValue) && (r[l] = a);
-      }), r), {});
-      return Object.entries(o).reduce((r, [s, l]) => (r[s] = x(l, n[s] || {}), r), n);
+    if (e?.from && U(e.from))
+      return h(e.from, n);
+    if (F(e)) {
+      const o = e.members.reduce((s, r) => (U(r) && Object.entries(r.fields).forEach(([u, a]) => {
+        const m = a.ast, l = s[u]?.ast;
+        (!s[u] || m?.defaultValue && !l?.defaultValue) && (s[u] = a);
+      }), s), {});
+      return Object.entries(o).reduce((s, [r, u]) => (s[r] = h(u, n[r] || {}), s), n);
     }
     if (Object.keys(n).length === 0)
       switch (e.ast._tag) {
         case "Refinement":
-          return x(i.make(e.ast.from), n);
+          return h(i.make(e.ast.from), n);
         case "Transformation": {
           const o = i.make(e.ast.from);
-          return x(o, n);
+          return h(o, n);
         }
         case "TypeLiteral": {
           const o = { ...n };
-          for (const r of t.propertySignatures) {
-            const s = r.name.toString(), l = r.type;
-            if (l._tag === "Transformation" && l.defaultValue) {
-              o[s] = l.defaultValue();
+          for (const s of t.propertySignatures) {
+            const r = s.name.toString(), u = s.type;
+            if (u._tag === "Transformation" && u.defaultValue) {
+              o[r] = u.defaultValue();
               continue;
             }
-            if (l.defaultValue) {
-              o[s] = l.defaultValue();
+            if (u.defaultValue) {
+              o[r] = u.defaultValue();
               continue;
             }
-            const a = i.make(l), f = x(a, n[s] || {});
-            f !== void 0 && (o[s] = f);
+            const a = i.make(u), m = h(a, n[r] || {});
+            m !== void 0 && (o[r] = m);
           }
           return o;
         }
@@ -461,12 +503,12 @@ const x = (e, n = {}) => {
 };
 export {
   y as createMeta,
-  F as deepMerge,
-  x as defaultsValueFromSchema,
+  I as deepMerge,
+  h as defaultsValueFromSchema,
   B as duplicateSchema,
   C as generateInputStandardSchemaFromFieldMeta,
   z as generateMetaFromSchema,
   H as getInputType,
-  g as isNullableOrUndefined,
+  c as isNullableOrUndefined,
   G as nullableInput
 };

package/dist/vue-components.es22.js

@@ -1,4 +1,4 @@
-import { TraceAPI as r } from "./vue-components.es51.js";
+import { TraceAPI as r } from "./vue-components.es52.js";
 var t = r.getInstance();
 export {
   t as trace

package/dist/vue-components.es23.js

@@ -1,4 +1,4 @@
-import { ContextAPI as t } from "./vue-components.es50.js";
+import { ContextAPI as t } from "./vue-components.es51.js";
 var o = t.getInstance();
 export {
   o as context

package/dist/vue-components.es36.js

@@ -1,7 +1,7 @@
 import { defineComponent as m, createElementBlock as d, openBlock as u, withModifiers as f, createElementVNode as l, unref as s, renderSlot as a } from "vue";
 import { useStore as b } from "@tanstack/vue-form";
 import { usePreventClose as p } from "./vue-components.es11.js";
-import { getOmegaStore as c } from "./vue-components.es52.js";
+import { getOmegaStore as c } from "./vue-components.es53.js";
 const S = ["disabled"], V = /* @__PURE__ */ m({
   __name: "OmegaWrapper",
   props: {