@effect-app/vue-components 2.6.2 → 2.7.1

package/dist/vue-components.es11.js

@@ -1,6 +1,6 @@
-import l from "./vue-components.es28.js";
+import l from "./vue-components.es29.js";
 import { inject as c, provide as u } from "vue";
-import { onMountedWithCleanup as f } from "./vue-components.es29.js";
+import { onMountedWithCleanup as f } from "./vue-components.es16.js";
 const p = () => l(), i = Symbol("DialogBus"), r = () => c(i, null), g = () => {
   const n = p();
   return u(i, n), n;

package/dist/vue-components.es12.js

@@ -1,139 +1,139 @@
-import { S as n, Option as M } from "effect-app";
-import { getMetadataFromSchema as _ } from "@effect-app/vue/form";
-import { useIntl as w, getTransformationFrom as N } from "./vue-components.es3.js";
-const E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === n.Null.ast), d = (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, L = (e) => {
+import { S as n, Option as L } from "effect-app";
+import { getMetadataFromSchema as w } from "@effect-app/vue/form";
+import { useIntl as N, getTransformationFrom as M } from "./vue-components.es3.js";
+const E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === n.Null.ast), d = (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 = [];
   for (const t of e)
     if (n.AST.isUnion(t)) {
-      const g = L(t.types);
-      i.push(...g);
+      const c = _(t.types);
+      i.push(...c);
     } else
       i.push(t);
   return i;
-}, m = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: g }, a = {}) => {
+}, u = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: c }, o = {}) => {
   if (t && t._tag === "Transformation")
-    return m({
+    return u({
       parent: i,
       meta: e,
       property: t.from
     });
   if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return m({
+    return u({
       meta: e,
       propertySignatures: t.propertySignatures
     });
-  if (g) {
-    for (const r of g) {
-      const o = i ? `${i}.${r.name.toString()}` : r.name.toString(), s = d(r.type);
-      let l;
-      e._isNullableDiscriminatedUnion && r.name.toString() === "_tag" || e.required === !1 ? l = !1 : l = !s;
-      const T = r.type;
+  if (c) {
+    for (const r of c) {
+      const p = i ? `${i}.${r.name.toString()}` : r.name.toString(), s = d(r.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 c = L(r.type.types).filter(
-          (p) => p._tag !== "UndefinedKeyword" && p !== n.Null.ast
-        ).map(N);
-        if (c.some(
-          (p) => "propertySignatures" in p
+        const S = _(r.type.types).filter(
+          (l) => l._tag !== "UndefinedKeyword" && l !== n.Null.ast
+        ).map(M);
+        if (S.some(
+          (l) => "propertySignatures" in l
         )) {
           if (!s) {
-            const p = m({
-              parent: o,
+            const l = u({
+              parent: p,
               property: r.type,
-              meta: { required: l, nullableOrUndefined: s }
+              meta: { required: a, nullableOrUndefined: s }
             });
-            a[o] = p;
+            o[p] = l;
           }
-          for (const p of c)
-            if ("propertySignatures" in p) {
-              const u = s && c.length > 1;
+          for (const l of S)
+            if ("propertySignatures" in l) {
+              const m = s && S.length > 1;
               Object.assign(
-                a,
-                m({
-                  parent: o,
-                  propertySignatures: p.propertySignatures,
-                  meta: u ? { _isNullableDiscriminatedUnion: !0 } : {}
+                o,
+                u({
+                  parent: p,
+                  propertySignatures: l.propertySignatures,
+                  meta: m ? { _isNullableDiscriminatedUnion: !0 } : {}
                 })
               );
             }
         } else {
-          const p = c.filter(n.AST.isTupleType);
-          if (p.length > 0) {
-            const u = p[0];
-            if (a[o] = {
+          const l = S.filter(n.AST.isTupleType);
+          if (l.length > 0) {
+            const m = l[0];
+            if (o[p] = {
               type: "multiple",
-              members: u.elements,
-              rest: u.rest,
-              required: l,
+              members: m.elements,
+              rest: m.rest,
+              required: a,
               nullableOrUndefined: s
-            }, u.rest && u.rest.length > 0) {
-              const S = u.rest[0];
-              if (S.type._tag === "TypeLiteral" && "propertySignatures" in S.type)
-                for (const f of S.type.propertySignatures) {
-                  const b = `${o}.${f.name.toString()}`, h = m({
-                    parent: b,
-                    property: f.type,
+            }, 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 = `${p}.${g.name.toString()}`, v = u({
+                    parent: h,
+                    property: g.type,
                     meta: {
-                      required: !d(f.type),
-                      nullableOrUndefined: d(f.type)
+                      required: !d(g.type),
+                      nullableOrUndefined: d(g.type)
                     }
                   });
-                  if (h && typeof h == "object" && "type" in h && (a[b] = h, h.type === "multiple" && n.AST.isTupleType(f.type) && f.type.rest && f.type.rest.length > 0)) {
-                    const U = f.type.rest[0];
+                  if (v && typeof v == "object" && "type" in v && (o[h] = v, v.type === "multiple" && n.AST.isTupleType(g.type) && g.type.rest && g.type.rest.length > 0)) {
+                    const U = g.type.rest[0];
                     if (U.type._tag === "TypeLiteral" && "propertySignatures" in U.type)
-                      for (const v of U.type.propertySignatures) {
-                        const A = `${b}.${v.name.toString()}`, x = m({
+                      for (const x of U.type.propertySignatures) {
+                        const A = `${h}.${x.name.toString()}`, O = u({
                           parent: A,
-                          property: v.type,
+                          property: x.type,
                           meta: {
-                            required: !d(v.type),
-                            nullableOrUndefined: d(v.type)
+                            required: !d(x.type),
+                            nullableOrUndefined: d(x.type)
                           }
                         });
-                        x && typeof x == "object" && "type" in x && (a[A] = x);
+                        O && typeof O == "object" && "type" in O && (o[A] = O);
                       }
                   }
                 }
             }
           } else {
-            const u = m({
-              parent: o,
+            const m = u({
+              parent: p,
               property: r.type,
-              meta: { required: l, nullableOrUndefined: s }
+              meta: { required: a, nullableOrUndefined: s }
             });
-            a[o] = u;
+            o[p] = m;
           }
         }
-      } else if ("propertySignatures" in T)
+      } else if ("propertySignatures" in f)
         Object.assign(
-          a,
-          m({
-            parent: o,
-            propertySignatures: T.propertySignatures,
-            meta: { required: l, nullableOrUndefined: s }
+          o,
+          u({
+            parent: p,
+            propertySignatures: f.propertySignatures,
+            meta: { required: a, nullableOrUndefined: s }
           })
         );
       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 c = r.type.rest[0].type;
-          if (c._tag === "TypeLiteral" && "propertySignatures" in c)
-            for (const y of c.propertySignatures) {
-              const p = `${o}.${y.name.toString()}`;
+          const S = r.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 u = y.type.rest[0].type;
-                if (u._tag === "TypeLiteral" && "propertySignatures" in u)
-                  for (const S of u.propertySignatures) {
-                    const f = `${p}.${S.name.toString()}`, b = m({
-                      parent: f,
-                      property: S.type,
+                const m = y.type.rest[0].type;
+                if (m._tag === "TypeLiteral" && "propertySignatures" in m)
+                  for (const T of m.propertySignatures) {
+                    const g = `${l}.${T.name.toString()}`, h = u({
+                      parent: g,
+                      property: T.type,
                       meta: {
-                        required: !d(S.type),
-                        nullableOrUndefined: d(S.type)
+                        required: !d(T.type),
+                        nullableOrUndefined: d(T.type)
                       }
                     });
-                    a[f] = b;
+                    o[g] = h;
                   }
                 else
-                  a[p] = {
+                  o[l] = {
                     type: "multiple",
                     members: y.type.elements,
                     rest: y.type.rest,
@@ -141,61 +141,61 @@ const E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKe
                     nullableOrUndefined: d(y.type)
                   };
               } else {
-                const u = m({
-                  parent: p,
+                const m = u({
+                  parent: l,
                   property: y.type,
                   meta: {
                     required: !d(y.type),
                     nullableOrUndefined: d(y.type)
                   }
                 });
-                a[p] = u;
+                o[l] = m;
               }
             }
         } else
-          a[o] = {
+          o[p] = {
             type: "multiple",
             members: r.type.elements,
             rest: r.type.rest,
-            required: l,
+            required: a,
             nullableOrUndefined: s
           };
       else {
-        const O = m({
-          parent: o,
+        const b = u({
+          parent: p,
           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: l && (r.type._tag !== "StringKeyword" || _(r.type).minLength),
+            required: a && (r.type._tag !== "StringKeyword" || w(r.type).minLength),
             nullableOrUndefined: s
           }
         });
-        a[o] = O;
+        o[p] = b;
       }
     }
-    return a;
+    return o;
   }
   if (t) {
     const r = E(t);
     if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), n.AST.isUnion(t)) {
-      const s = L(t.types), l = s.find(
-        (T) => T._tag !== "UndefinedKeyword" && T !== n.Null.ast
+      const s = _(t.types), a = s.find(
+        (f) => f._tag !== "UndefinedKeyword" && f !== n.Null.ast
       );
-      return "propertySignatures" in l ? m({
-        propertySignatures: l.propertySignatures,
+      return "propertySignatures" in a ? u({
+        propertySignatures: a.propertySignatures,
         parent: i,
         meta: e
       }) : s.every(n.AST.isLiteral) ? {
         ...e,
         type: "select",
-        members: s.map((T) => T.literal)
+        members: s.map((f) => f.literal)
       } : {
         ...e,
-        ...m({
+        ...u({
           parent: i,
           meta: e,
-          property: l
+          property: a
         })
       };
     }
@@ -206,11 +206,11 @@ const E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKe
         members: t.elements,
         rest: t.rest
       };
-    const o = n.AST.getAnnotation(
+    const p = n.AST.getAnnotation(
       t,
       n.AST.JSONSchemaAnnotationId
-    ).pipe(M.getOrElse(() => ({})));
-    return e = { ...e, ...o }, "from" in t ? m({
+    ).pipe(L.getOrElse(() => ({})));
+    return e = { ...e, ...p }, "from" in t ? u({
       parent: i,
       meta: e,
       property: t.from
@@ -218,34 +218,56 @@ const E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKe
       t,
       n.AST.TitleAnnotationId
     ).pipe(
-      M.getOrElse(() => "unknown")
+      L.getOrElse(() => "unknown")
     ), e);
   }
-  return a;
+  return o;
 }, q = (e) => {
   const i = e.ast, t = {};
   if (i._tag === "Transformation" || i._tag === "Refinement")
     return q(n.make(i.from));
+  if (i._tag === "Union") {
+    const r = (i.types || []).filter((s) => s._tag !== "UndefinedKeyword" && s !== n.Null.ast).map(M);
+    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"
+          );
+          f && n.AST.isLiteral(f.type) && s.push(f.type.literal);
+          const b = u({
+            propertySignatures: a.propertySignatures
+          });
+          Object.assign(t, b);
+        }
+      return s.length > 0 && (t._tag = {
+        type: "select",
+        members: s,
+        required: !0
+      }), t;
+    }
+  }
   if ("propertySignatures" in i) {
-    const g = m({
+    const c = u({
       propertySignatures: i.propertySignatures
     });
-    if (Object.values(g).every((r) => r && "type" in r))
-      return g;
-    const a = (r, o = "") => {
+    if (Object.values(c).every((r) => r && "type" in r))
+      return c;
+    const o = (r, p = "") => {
       for (const s in r) {
-        const l = o ? `${o}.${s}` : s;
-        r[s] && typeof r[s] == "object" && "type" in r[s] ? t[l] = r[s] : r[s] && typeof r[s] == "object" && a(r[s], l);
+        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);
       }
     };
-    a(g);
+    o(c);
   }
   return t;
-}, P = (e) => n.extend(e, n.Struct({})), F = (e) => {
+}, P = (e) => n.extend(e, n.Struct({})), j = (e) => {
   const i = q(e);
   return { schema: e, meta: i };
-}, j = (e) => {
-  const { trans: i } = w();
+}, F = (e) => {
+  const { trans: i } = N();
   let t;
   switch (e.type) {
     case "string":
@@ -352,10 +374,10 @@ const E = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKe
   "url"
 ], R = (e) => k.includes(e) ? e : "text";
 export {
-  m as createMeta,
+  u as createMeta,
   P as duplicateSchema,
-  j as generateInputStandardSchemaFromFieldMeta,
-  F as generateMetaFromSchema,
+  F as generateInputStandardSchemaFromFieldMeta,
+  j as generateMetaFromSchema,
   R as getInputType,
   D as nullableInput
 };

package/dist/vue-components.es16.js

@@ -1,12 +1,13 @@
-import { Exit as c, Runtime as u } from "effect";
-import { dual as n, isFunction as m } from "./vue-components.es30.js";
-const i = Symbol.for("clone-trait"), a = n(2, (e, t) => i in e ? e[i](t) : Object.setPrototypeOf(t, Object.getPrototypeOf(e)));
-n(2, (e, t) => a(e, { ...e, ...m(t) ? t(e) : t }));
-const p = (e, t) => new Promise((o, s) => e.addObserver((r) => {
-  c.isSuccess(r) ? o(r.value) : s(u.makeFiberFailure(r.cause));
-}));
+import { onMounted as e, onUnmounted as u } from "vue";
+function p(t) {
+  let n;
+  e(() => {
+    const o = t();
+    o && (n = o);
+  }), u(() => {
+    n && n();
+  });
+}
 export {
-  a as clone,
-  i as cloneTrait,
-  p as runtimeFiberAsPromise
+  p as onMountedWithCleanup
 };

package/dist/vue-components.es17.js

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

package/dist/vue-components.es18.js

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

package/dist/vue-components.es19.js

@@ -1,70 +1,57 @@
-import { defineComponent as O, computed as j, createElementBlock as M, openBlock as _, Fragment as E, renderList as A, renderSlot as F, createVNode as g, unref as h, mergeProps as k } from "vue";
-import { Order as l, pipe as v, Array as u } from "effect-app";
-const I = /* @__PURE__ */ O({
-  __name: "OmegaAutoGen",
+import { defineComponent as F, computed as f, onMounted as M, provide as P, createBlock as c, openBlock as s, resolveDynamicComponent as p, withCtx as g, renderSlot as o, createElementBlock as k, normalizeProps as l, guardReactiveProps as u, Fragment as A, renderList as C, mergeProps as b } from "vue";
+const N = /* @__PURE__ */ F({
+  inheritAttrs: !1,
+  __name: "OmegaArray",
   props: {
     form: {},
-    pick: {},
-    omit: {},
-    labelMap: { type: Function },
-    filterMap: { type: Function },
-    order: {},
-    sort: {}
+    inputClass: {},
+    name: {},
+    defaultItems: {},
+    items: {}
   },
-  setup(i) {
-    const p = (e) => (r) => Object.fromEntries(
-      Object.entries(r).map(([t, o]) => [t, e(o, t)])
-    ), a = (e) => (r) => Object.fromEntries(
-      Object.entries(r).filter(([t, o]) => e(o, t))
-    ), m = (e) => (r) => Object.entries(r).reduce(
-      (t, [o, c]) => {
-        const s = e(c, o);
-        return s !== !1 && (t[o] = s), t;
-      },
-      {}
-    ), n = i, f = (e, r) => {
-      const t = r?.indexOf(e) ?? -1;
-      return t === -1 ? Number.MAX_SAFE_INTEGER : t;
-    }, d = l.mapInput(
-      l.number,
-      (e) => f(e.name, n.order || [])
-    ), b = j(
-      () => v(
-        n.form.meta,
-        // include / exclude
-        a(
-          (e, r) => n.pick ? n.pick.includes(r) && !n.omit?.includes(r) : !n.omit?.includes(r)
-        ),
-        (e) => e,
-        // labelMap and adding name
-        p((e, r) => ({
-          name: r,
-          label: n.labelMap?.(r) || r,
-          ...e
-        })),
-        // filterMap
-        n.filterMap ? m((e) => {
-          const r = n.filterMap?.(e.name, e);
-          return r === void 0 || r === !0 ? e : r;
-        }) : (e) => e,
-        // transform to array
-        (e) => Object.values(e),
-        // order
-        u.sort(d),
-        // sort
-        n.sort ? u.sort(n.sort) : (e) => e
-      )
-    );
-    return (e, r) => (_(!0), M(E, null, A(b.value, ({ name: t, label: o, ...c }) => F(e.$slots, "default", {
-      child: { name: t, label: o, ...c }
-    }, () => [
-      g(h(i.form).Input, k({
-        name: t,
-        label: o
-      }, { ref_for: !0 }, c), null, 16, ["name", "label"])
-    ])), 256));
+  setup(n) {
+    const a = n, y = a.form.useStore((e) => e.values), i = f(() => {
+      const e = a.name.replace(/\[/g, ".").replace(/\]/g, "");
+      try {
+        return e.split(".").reduce((r, t) => r && r[t], y.value);
+      } catch (r) {
+        return console.error(r), [];
+      }
+    });
+    M(async () => {
+      a.defaultItems && !i.value && a.form.setFieldValue(a.name, a.defaultItems);
+    });
+    const $ = f(() => (r) => {
+      const t = r.replace(/\[\d+\]/g, "");
+      return a.form.meta[t];
+    });
+    return P("getMetaFromArray", $), (e, r) => (s(), c(p(n.form.Field), { name: n.name }, {
+      default: g(({ field: t, state: d }) => [
+        o(e.$slots, "pre-array", l(u({ field: t, state: d }))),
+        (s(!0), k(A, null, C(i.value, (B, m) => (s(), c(p(n.form.Field), {
+          key: `${n.name}[${Number(m)}]`,
+          name: (
+            // eslint-disable-next-line
+            `${n.name}[${Number(m)}]`
+          )
+        }, {
+          default: g(({ field: v, state: h }) => [
+            o(e.$slots, "default", b({ ref_for: !0 }, {
+              subField: v,
+              subState: h,
+              index: Number(m),
+              field: t
+            }))
+          ]),
+          _: 2
+        }, 1032, ["name"]))), 128)),
+        o(e.$slots, "post-array", l(u({ field: t, state: d }))),
+        o(e.$slots, "field", l(u({ field: t })))
+      ]),
+      _: 3
+    }, 8, ["name"]));
   }
 });
 export {
-  I as default
+  N as default
 };