@effect-app/vue-components 2.0.0 → 2.1.0

package/dist/vue-components.es10.js

@@ -1,353 +1,235 @@
-import { S as n, Option as M } from "effect-app";
-import { getMetadataFromSchema as w } from "@effect-app/vue/form";
-import { useIntl as _, getTransformationFrom as N } from "./vue-components.es3.js";
-const E = (e) => n.AST.isUnion(e) && e.types.find((r) => r._tag === "UndefinedKeyword" || r === n.Null.ast), f = (e) => !e || !n.AST.isUnion(e) ? !1 : e.types.find((r) => r._tag === "UndefinedKeyword") ? "undefined" : e.types.find((r) => r === n.Null.ast) ? "null" : !1, L = (e) => {
-  const r = [];
-  for (const t of e)
-    if (n.AST.isUnion(t)) {
-      const g = L(t.types);
-      r.push(...g);
-    } else
-      r.push(t);
-  return r;
-}, l = ({ meta: e = {}, parent: r = "", property: t, propertySignatures: g }, a = {}) => {
-  if (t && t._tag === "Transformation")
-    return l({
-      parent: r,
-      meta: e,
-      property: t.from
-    });
-  if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return l({
-      meta: e,
-      propertySignatures: t.propertySignatures
-    });
-  if (g) {
-    for (const i of g) {
-      const o = r ? `${r}.${i.name.toString()}` : i.name.toString(), s = f(i.type), u = !s, S = i.type;
-      if (n.AST.isUnion(i.type)) {
-        const T = L(i.type.types).filter(
-          (p) => p._tag !== "UndefinedKeyword" && p !== n.Null.ast
-        ).map(N);
-        if (T.some(
-          (p) => "propertySignatures" in p
-        )) {
-          if (!s) {
-            const p = l({
-              parent: o,
-              property: i.type,
-              meta: { required: u, nullableOrUndefined: s }
-            });
-            a[o] = p;
-          }
-          for (const p of T)
-            "propertySignatures" in p && Object.assign(
-              a,
-              l({
-                parent: o,
-                propertySignatures: p.propertySignatures,
-                meta: { required: u, nullableOrUndefined: s }
-              })
-            );
-        } else {
-          const p = T.filter(n.AST.isTupleType);
-          if (p.length > 0) {
-            const m = p[0];
-            if (a[o] = {
-              type: "multiple",
-              members: m.elements,
-              rest: m.rest,
-              required: u,
-              nullableOrUndefined: s
-            }, m.rest && m.rest.length > 0) {
-              const c = m.rest[0];
-              if (c.type._tag === "TypeLiteral" && "propertySignatures" in c.type)
-                for (const d of c.type.propertySignatures) {
-                  const b = `${o}.${d.name.toString()}`, h = l({
-                    parent: b,
-                    property: d.type,
-                    meta: {
-                      required: !f(d.type),
-                      nullableOrUndefined: f(d.type)
-                    }
-                  });
-                  if (h && typeof h == "object" && "type" in h && (a[b] = h, h.type === "multiple" && n.AST.isTupleType(d.type) && d.type.rest && d.type.rest.length > 0)) {
-                    const A = d.type.rest[0];
-                    if (A.type._tag === "TypeLiteral" && "propertySignatures" in A.type)
-                      for (const x of A.type.propertySignatures) {
-                        const q = `${b}.${x.name.toString()}`, v = l({
-                          parent: q,
-                          property: x.type,
-                          meta: {
-                            required: !f(x.type),
-                            nullableOrUndefined: f(x.type)
-                          }
-                        });
-                        v && typeof v == "object" && "type" in v && (a[q] = v);
-                      }
-                  }
-                }
-            }
-          } else {
-            const m = l({
-              parent: o,
-              property: i.type,
-              meta: { required: u, nullableOrUndefined: s }
-            });
-            a[o] = m;
+import { useForm as q } from "@tanstack/vue-form";
+import { Data as B, S as D, Effect as c, Fiber as x, Option as P, Array as g } from "effect-app";
+import { runtimeFiberAsPromise as K } from "./vue-components.es16.js";
+import { isObject as T } from "./vue-components.es17.js";
+import { computed as O, onUnmounted as N, onMounted as G, onBeforeUnmount as z, watch as W, ref as Q, h as H } from "vue";
+import X from "./vue-components.es18.js";
+import Y from "./vue-components.es19.js";
+import Z from "./vue-components.es20.js";
+import { generateMetaFromSchema as C } from "./vue-components.es12.js";
+import ee from "./vue-components.es6.js";
+import re from "./vue-components.es8.js";
+import te from "./vue-components.es21.js";
+import { trace as R } from "./vue-components.es22.js";
+import { context as L } from "./vue-components.es23.js";
+class ne extends B.TaggedError("FormErrors") {
+}
+const E = (u) => function(s) {
+  return {
+    render() {
+      return H(s, {
+        form: u,
+        ...this.$attrs
+      }, this.$slots);
+    }
+  };
+}, se = (u) => function(s) {
+  return {
+    setup() {
+      const { fieldMap: b, form: p } = u, y = p.useStore((d) => d.errors), f = p.useStore((d) => d.fieldMeta), M = p.useStore((d) => d.errorMap), j = O(() => {
+        const d = g.filterMap(
+          Object.entries(f.value),
+          ([i, v]) => {
+            const h = v.errors ?? [];
+            if (!h.length) return P.none();
+            const a = b.value.get(i);
+            return a ? P.some({
+              label: a.label,
+              inputId: a.id,
+              // Only show the first error
+              errors: [h[0]?.message].filter(Boolean)
+            }) : P.none();
           }
-        }
-      } else if ("propertySignatures" in S)
-        Object.assign(
-          a,
-          l({
-            parent: o,
-            propertySignatures: S.propertySignatures,
-            meta: { required: u, nullableOrUndefined: s }
-          })
-        );
-      else if (n.AST.isTupleType(i.type))
-        if (i.type.rest.length > 0 && i.type.rest[0].type._tag === "TypeLiteral" && "propertySignatures" in i.type.rest[0].type) {
-          const T = i.type.rest[0].type;
-          if (T._tag === "TypeLiteral" && "propertySignatures" in T)
-            for (const y of T.propertySignatures) {
-              const p = `${o}.${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 c of m.propertySignatures) {
-                    const d = `${p}.${c.name.toString()}`, b = l({
-                      parent: d,
-                      property: c.type,
-                      meta: {
-                        required: !f(c.type),
-                        nullableOrUndefined: f(c.type)
-                      }
+        ), F = [];
+        if (M.value.onSubmit) {
+          for (const [i, v] of Object.entries(M.value.onSubmit))
+            if (g.isArray(v) && v.length)
+              for (const h of v) {
+                const a = h;
+                if (a?.path && g.isArray(a.path) && a.path.length) {
+                  const S = a.path.join(".");
+                  if (!b.value.has(S)) {
+                    F.push({
+                      label: S,
+                      inputId: S,
+                      errors: [a.message].filter(Boolean)
                     });
-                    a[d] = b;
-                  }
-                else
-                  a[p] = {
-                    type: "multiple",
-                    members: y.type.elements,
-                    rest: y.type.rest,
-                    required: !f(y.type),
-                    nullableOrUndefined: f(y.type)
-                  };
-              } else {
-                const m = l({
-                  parent: p,
-                  property: y.type,
-                  meta: {
-                    required: !f(y.type),
-                    nullableOrUndefined: f(y.type)
+                    break;
                   }
-                });
-                a[p] = m;
+                }
               }
-            }
-        } else
-          a[o] = {
-            type: "multiple",
-            members: i.type.elements,
-            rest: i.type.rest,
-            required: u,
-            nullableOrUndefined: s
-          };
-      else {
-        const O = l({
-          parent: o,
-          property: i.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: u && (i.type._tag !== "StringKeyword" || w(i.type).minLength),
-            nullableOrUndefined: s
-          }
-        });
-        a[o] = O;
-      }
-    }
-    return a;
-  }
-  if (t) {
-    const i = E(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !i), n.AST.isUnion(t)) {
-      const s = L(t.types), u = s.find(
-        (S) => S._tag !== "UndefinedKeyword" && S !== n.Null.ast
-      );
-      return "propertySignatures" in u ? l({
-        propertySignatures: u.propertySignatures,
-        parent: r,
-        meta: e
-      }) : s.every(n.AST.isLiteral) ? {
-        ...e,
-        type: "select",
-        members: s.map((S) => S.literal)
-      } : {
-        ...e,
-        ...l({
-          parent: r,
-          meta: e,
-          property: u
-        })
-      };
-    }
-    if (n.AST.isTupleType(t))
+        }
+        return [...d, ...F];
+      });
       return {
-        ...e,
-        type: "multiple",
-        members: t.elements,
-        rest: t.rest
+        generalErrors: y,
+        errors: j
       };
-    const o = n.AST.getAnnotation(
-      t,
-      n.AST.JSONSchemaAnnotationId
-    ).pipe(M.getOrElse(() => ({})));
-    return e = { ...e, ...o }, "from" in t ? l({
-      parent: r,
-      meta: e,
-      property: t.from
-    }) : (e.type = n.AST.getAnnotation(
-      t,
-      n.AST.TitleAnnotationId
-    ).pipe(
-      M.getOrElse(() => "unknown")
-    ), e);
+    },
+    render({ errors: b, generalErrors: p }) {
+      return H(s, {
+        errors: b,
+        generalErrors: p,
+        ...this.$attrs
+      }, this.$slots);
+    }
+  };
+}, be = (u, l, s) => {
+  if (!u) throw new Error("Schema is required");
+  const b = D.standardSchemaV1(u), p = D.decode(u), { meta: y } = C(u), f = O(() => {
+    if (s?.persistency?.id)
+      return s.persistency.id;
+    const e = window.location.pathname, r = Object.keys(y);
+    return `${e}-${r.join("-")}`;
+  }), M = () => {
+    const e = new URLSearchParams(window.location.search);
+    e.delete(f.value);
+    const r = new URL(window.location.href);
+    r.search = e.toString(), window.history.replaceState({}, "", r.toString());
+  };
+  function j(e, r) {
+    for (const t in r)
+      r[t] && T(r[t]) ? (e[t] || (e[t] = {}), j(e[t], r[t])) : e[t] = r[t];
+    return e;
   }
-  return a;
-}, U = (e) => {
-  const r = e.ast, t = {};
-  if (r._tag === "Transformation" || r._tag === "Refinement")
-    return U(n.make(r.from));
-  if ("propertySignatures" in r) {
-    const g = l({
-      propertySignatures: r.propertySignatures
-    });
-    if (Object.values(g).every((i) => i && "type" in i))
-      return g;
-    const a = (i, o = "") => {
-      for (const s in i) {
-        const u = o ? `${o}.${s}` : s;
-        i[s] && typeof i[s] == "object" && "type" in i[s] ? t[u] = i[s] : i[s] && typeof i[s] == "object" && a(i[s], u);
+  const d = O(() => {
+    if (l?.defaultValues && !s?.persistency?.overrideDefaultValues)
+      return l?.defaultValues;
+    let e;
+    const r = s?.persistency;
+    if (!r?.policies || r.policies.length === 0) return {};
+    if (r.policies.includes("querystring"))
+      try {
+        const o = new URLSearchParams(window.location.search).get(f.value);
+        M(), o && (e = JSON.parse(o));
+      } catch (t) {
+        console.error(t);
       }
-    };
-    a(g);
-  }
-  return t;
-}, P = (e) => n.extend(e, n.Struct({})), F = (e) => {
-  const r = U(e);
-  return { schema: e, meta: r };
-}, j = (e) => {
-  const { trans: r } = _();
-  let t;
-  switch (e.type) {
-    case "string":
-      t = n.String.annotations({
-        message: () => r("validation.empty")
-      }), e.format === "email" && (t = n.compose(
-        t,
-        n.Email.annotations({
-          message: () => r("validation.email.invalid")
-        })
-      )), e.required && t.annotations({
-        message: () => r("validation.empty")
-      }), e.maxLength && (t = t.pipe(n.maxLength(e.maxLength)).annotations({
-        message: () => r("validation.string.maxLength", {
-          maxLength: e.maxLength
-        })
-      })), e.minLength && (t = t.pipe(n.minLength(e.minLength)).annotations({
-        message: () => r("validation.string.minLength", {
-          minLength: e.minLength
-        })
-      }));
-      break;
-    case "number":
-      t = n.Number.annotations({
-        message: () => r("validation.empty")
-      }), e.required && t.annotations({
-        message: () => r("validation.empty")
-      }), e.minimum && (t = t.pipe(n.greaterThanOrEqualTo(e.minimum)).annotations({
-        message: () => r("validation.number.min", {
-          minimum: e.minimum,
-          isExclusive: !0
-        })
-      })), e.maximum && (t = t.pipe(n.lessThanOrEqualTo(e.maximum)).annotations({
-        message: () => r("validation.number.max", {
-          maximum: e.maximum,
-          isExclusive: !0
-        })
-      })), e.exclusiveMinimum && (t = t.pipe(n.greaterThan(e.exclusiveMinimum)).annotations({
-        message: () => r("validation.number.min", {
-          minimum: e.exclusiveMinimum,
-          isExclusive: !1
-        })
-      })), e.exclusiveMaximum && (t = t.pipe(n.lessThan(e.exclusiveMaximum)).annotations({
-        message: () => r("validation.number.max", {
-          maximum: e.exclusiveMaximum,
-          isExclusive: !1
-        })
-      }));
-      break;
-    case "select":
-      t = n.Literal(...e.members).annotations({
-        message: () => ({
-          message: r("validation.not_a_valid", {
-            type: "select",
-            message: e.members.join(", ")
-          }),
-          override: !0
-        })
-      });
-      break;
-    case "multiple":
-      t = n.Array(n.String).annotations({
-        message: () => r("validation.not_a_valid", {
-          type: "multiple",
-          message: e.members.join(", ")
-        })
+    if (
+      // query string has higher priority than local/session storage
+      !e && (r.policies.includes("local") || r.policies.includes("session"))
+    ) {
+      const t = r.policies.includes("local") ? localStorage : sessionStorage;
+      if (t)
+        try {
+          const o = JSON.parse(
+            t.getItem(f.value) || "{}"
+          );
+          t.removeItem(f.value), e = o;
+        } catch (o) {
+          console.error(o);
+        }
+    }
+    if (e ??= {}, l?.defaultValues == null)
+      return e;
+    {
+      const t = l?.defaultValues;
+      return j(t, e);
+    }
+  }), F = (e, r) => e ? L.with(R.setSpan(L.active(), e), r) : r(), i = q({
+    ...l,
+    validators: {
+      onSubmit: b,
+      ...l?.validators || {}
+    },
+    onSubmit: l?.onSubmit ? ({ formApi: e, meta: r, value: t }) => F(r?.currentSpan, async () => {
+      const o = await c.runPromise(p(t)), n = l.onSubmit({
+        formApi: e,
+        meta: r,
+        value: o
       });
-      break;
-    case "boolean":
-      t = n.Boolean;
-      break;
-    // todo: switch must be exhaustive or have default case, otherwise falls through with schema undefined.
-    case "unknown":
-      t = n.Unknown;
-      break;
+      return x.isFiber(n) && x.isRuntimeFiber(n) ? await K(n) : c.isEffect(n) ? await c.runPromise(
+        n.pipe(
+          // meta?.currentSpan
+          //   ? Effect.withParentSpan(meta.currentSpan)
+          //   : (_) => _,
+          c.flatMap((m) => x.join(m))
+        )
+      ) : n;
+    }) : void 0,
+    defaultValues: d.value
+  }), v = () => {
+    Object.keys(y).forEach((e) => {
+      i.setFieldValue(e, void 0);
+    });
+  }, h = (e) => e.reduce((r, t) => {
+    const o = t.split(".");
+    return o.reduce((n, m, A) => (A === o.length - 1 ? n[m] = i.getFieldValue(t) : n[m] = n[m] ?? {}, n[m]), r), r;
+  }, {}), a = (e) => {
+    if (e) {
+      if (g.isArray(e.keys))
+        return h(e.keys);
+      if (g.isArray(e.banKeys)) {
+        const r = Object.keys(y).filter((t) => e.banKeys?.includes(t));
+        return h(r);
+      }
+      return i.store.state.values;
+    }
+  }, S = () => {
+    const e = s?.persistency;
+    if (!(!e?.policies || e.policies.length === 0) && (e.policies.includes("local") || e.policies.includes("session"))) {
+      const r = e.policies.includes("local") ? localStorage : sessionStorage;
+      if (!r) return;
+      const t = a(e);
+      return r.setItem(f.value, JSON.stringify(t));
+    }
+  }, U = () => {
+    const e = s?.persistency;
+    if (!(!e?.policies || e.policies.length === 0) && e.policies.includes("querystring")) {
+      const r = a(e), t = new URLSearchParams(window.location.search);
+      t.set(f.value, JSON.stringify(r));
+      const o = new URL(window.location.href);
+      o.search = t.toString(), window.history.replaceState({}, "", o.toString());
+    }
+  }, _ = (e) => {
+    i.store.state.isDirty && e.preventDefault();
+  };
+  if (N(S), G(() => {
+    window.addEventListener("beforeunload", S), window.addEventListener("blur", U), s?.preventWindowExit && s.preventWindowExit !== "nope" && window.addEventListener("beforeunload", _);
+  }), z(() => {
+    window.removeEventListener("beforeunload", S), window.removeEventListener("blur", U), s?.preventWindowExit && s.preventWindowExit !== "nope" && window.removeEventListener("beforeunload", _);
+  }), s?.preventWindowExit === "prevent-and-reset") {
+    const e = i.useStore((n) => n.isSubmitting), r = i.useStore((n) => n.submissionAttempts), t = i.useStore((n) => n.canSubmit), o = i.useStore((n) => n.values);
+    W([e, r], ([n, m], [A]) => {
+      A && !n && m > 0 && t.value && i.reset(o.value);
+    });
   }
-  return e.required ? t.pipe(
-    n.annotations({
-      message: () => r("validation.empty")
-    })
-  ) : t = n.NullishOr(t), n.standardSchemaV1(t);
-}, R = (e, r) => n.NullOr(e).pipe(
-  n.transform(n.typeSchema(e), {
-    decode: (t) => t ?? r(),
-    encode: (t) => t
-  })
-), k = [
-  "button",
-  "checkbox",
-  "color",
-  "date",
-  "email",
-  "number",
-  "password",
-  "radio",
-  "range",
-  "search",
-  "submit",
-  "tel",
-  "text",
-  "time",
-  "url"
-], J = (e) => k.includes(e) ? e : "text";
+  const I = (e) => c.currentSpan.pipe(
+    c.option,
+    c.flatMap(
+      (r) => c.promise(() => i.handleSubmit(P.isSome(r) ? { currentSpan: r.value, ...e } : e))
+    )
+  ), J = (e) => e?.checkErrors ? I(e?.meta).pipe(c.flatMap(c.fnUntraced(function* () {
+    const r = i.getAllErrors();
+    if (Object.keys(r.fields).length || r.form.errors.length)
+      return yield* new ne({ form: r.form, fields: r.fields });
+  }))) : I(e?.meta), k = i.handleSubmit, V = Q(/* @__PURE__ */ new Map()), w = Object.assign(i, {
+    i18nNamespace: s?.i18nNamespace,
+    ignorePreventCloseEvents: s?.ignorePreventCloseEvents,
+    meta: y,
+    clear: v,
+    handleSubmit: (e) => {
+      const r = R.getSpan(L.active());
+      return k({ currentSpan: r, ...e });
+    },
+    // /** @experimental */
+    handleSubmitEffect: J,
+    registerField: (e) => {
+      W(e, (r) => V.value.set(r.name, { label: r.label, id: r.id }), { immediate: !0 }), N(() => V.value.delete(e.value.name));
+    }
+  }), $ = { form: w, fieldMap: V };
+  return Object.assign(w, {
+    errorContext: $,
+    Form: E(w)(te),
+    Input: E(w)(s?.input ?? ee),
+    TaggedUnion: E(w)(re),
+    Field: i.Field,
+    Errors: se($)(Z),
+    Array: E(w)(X),
+    AutoGen: E(w)(Y)
+  });
+};
 export {
-  l as createMeta,
-  P as duplicateSchema,
-  j as generateInputStandardSchemaFromFieldMeta,
-  F as generateMetaFromSchema,
-  J as getInputType,
-  R as nullableInput
+  ne as FormErrors,
+  be as useOmegaForm
 };

package/dist/vue-components.es11.js

@@ -1,36 +1,32 @@
-import { h as o } from "vue";
-import l from "./vue-components.es6.js";
-import { useOmegaForm as O } from "./vue-components.es8.js";
-const g = (n) => (...m) => {
-  const [p, s, a] = m;
-  return O(
-    p,
-    s,
-    {
-      ...a,
-      input: {
-        name: "WrappedInput",
-        inheritAttrs: !1,
-        setup(c, { attrs: t }) {
-          return () => o(l, {
-            ...c,
-            ...t
-          }, {
-            // Override the default slot that OmegaInternalInput provides
-            default: ({ field: f, state: i, ...r }) => {
-              const u = Object.fromEntries(
-                Object.entries(t).filter(
-                  ([e]) => !Object.prototype.hasOwnProperty.call(r, e) && e !== "form"
-                )
-              );
-              return o(n, { ...u, field: f, state: i, inputProps: r });
-            }
-          });
-        }
-      }
-    }
-  );
+import l from "./vue-components.es28.js";
+import { inject as c, provide as u } from "vue";
+import { onMountedWithCleanup as f } from "./vue-components.es29.js";
+const p = () => l(), i = Symbol("DialogBus"), r = () => c(i, null), g = () => {
+  const n = p();
+  return u(i, n), n;
+}, d = (n) => {
+  const o = r();
+  if (!o)
+    return;
+  const s = n();
+  f(() => {
+    const e = (t) => {
+      s.value && (confirm("Es sind ungespeicherte Änderungen vorhanden. Wirklich schließen?") || (t.prevent = !0));
+    };
+    return o.on("dialog-closing", e), () => o.off("dialog-closing", e);
+  });
+}, h = (n) => {
+  let o = r();
+  return o || (o = g()), () => {
+    const e = {};
+    o.emit("dialog-closing", e), e.prevent ? typeof e.prevent == "object" && "then" in e.prevent && e.prevent.then((t) => {
+      t !== !1 && n();
+    }) : n();
+  };
 };
 export {
-  g as createUseFormWithCustomInput
+  r as injectBus,
+  g as provideBus,
+  h as useOnClose,
+  d as usePreventClose
 };