@effect-app/vue-components 1.0.0-next.9 → 1.0.1

package/dist/vue-components.es7.js

@@ -1,352 +1,211 @@
-import { S as n, Option as c, pipe as L } from "effect-app";
-import { getTransformationFrom as U, useIntl as _ } from "./vue-components.es3.js";
-const N = n.NonEmptyArray(n.String), E = (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, m = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: p }, o = {}) => {
-  if (t && t._tag === "Transformation")
-    return m({
-      parent: i,
-      meta: e,
-      property: t.from
-    });
-  if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return m({
-      meta: e,
-      propertySignatures: t.propertySignatures
-    });
-  if (p) {
-    for (const r of p) {
-      const l = i ? `${i}.${r.name.toString()}` : r.name.toString(), a = g(r.type), u = !a, A = r.type;
-      if (n.AST.isUnion(r.type)) {
-        const T = r.type.types.filter(
-          (s) => s._tag !== "UndefinedKeyword" && s !== n.Null.ast
-        ).map(U);
-        if (T.some(
-          (s) => "propertySignatures" in s
-        )) {
-          if (!a) {
-            const s = m({
-              parent: l,
-              property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
-            });
-            o[l] = s;
-          }
-          for (const s of T)
-            "propertySignatures" in s && Object.assign(
-              o,
-              m({
-                parent: l,
-                propertySignatures: s.propertySignatures,
-                meta: { required: u, nullableOrUndefined: a }
-              })
-            );
-        } else {
-          const s = T.filter(n.AST.isTupleType);
-          if (s.length > 0) {
-            const f = s[0];
-            if (o[l] = {
-              type: "multiple",
-              members: f.elements,
-              rest: f.rest,
-              required: u,
-              nullableOrUndefined: a
-            }, f.rest && f.rest.length > 0) {
-              const d = f.rest[0];
-              if (d.type._tag === "TypeLiteral" && "propertySignatures" in d.type)
-                for (const y of d.type.propertySignatures) {
-                  const b = `${l}.${y.name.toString()}`, S = m({
-                    parent: b,
-                    property: y.type,
-                    meta: {
-                      required: !g(y.type),
-                      nullableOrUndefined: g(y.type)
-                    }
-                  });
-                  if (S && typeof S == "object" && "type" in S && (o[b] = S, S.type === "multiple" && n.AST.isTupleType(y.type) && y.type.rest && y.type.rest.length > 0)) {
-                    const O = y.type.rest[0];
-                    if (O.type._tag === "TypeLiteral" && "propertySignatures" in O.type)
-                      for (const x of O.type.propertySignatures) {
-                        const M = `${b}.${x.name.toString()}`, v = m({
-                          parent: M,
-                          property: x.type,
-                          meta: {
-                            required: !g(x.type),
-                            nullableOrUndefined: g(x.type)
-                          }
-                        });
-                        v && typeof v == "object" && "type" in v && (o[M] = v);
-                      }
-                  }
-                }
-            }
-          } else {
-            const f = m({
-              parent: l,
-              property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
-            });
-            o[l] = f;
-          }
-        }
-      } else if ("propertySignatures" in A)
-        Object.assign(
-          o,
-          m({
-            parent: l,
-            propertySignatures: A.propertySignatures,
-            meta: { required: u, nullableOrUndefined: a }
-          })
-        );
-      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 h = r.type.rest[0].type;
-          if (h._tag === "TypeLiteral" && "propertySignatures" in h)
-            for (const s of h.propertySignatures) {
-              const f = `${l}.${s.name.toString()}`;
-              if (n.AST.isTupleType(s.type) && s.type.rest.length > 0) {
-                const d = s.type.rest[0].type;
-                if (d._tag === "TypeLiteral" && "propertySignatures" in d)
-                  for (const y of d.propertySignatures) {
-                    const b = `${f}.${y.name.toString()}`, S = m({
-                      parent: b,
-                      property: y.type,
-                      meta: {
-                        required: !g(y.type),
-                        nullableOrUndefined: g(y.type)
-                      }
-                    });
-                    o[b] = S;
-                  }
-                else
-                  o[f] = {
-                    type: "multiple",
-                    members: s.type.elements,
-                    rest: s.type.rest,
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
-                  };
-              } else {
-                const d = m({
-                  parent: f,
-                  property: s.type,
-                  meta: {
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
-                  }
-                });
-                o[f] = d;
-              }
-            }
-        } else
-          o[l] = {
-            type: "multiple",
-            members: r.type.elements,
-            rest: r.type.rest,
-            required: u,
-            nullableOrUndefined: a
-          };
-      else {
-        const T = m({
-          parent: l,
-          property: r.type,
-          meta: { required: u, nullableOrUndefined: a }
-        });
-        o[l] = T;
-      }
+import { useForm as D, useStore as H } from "@tanstack/vue-form";
+import { S as O, Effect as d, Fiber as y } from "effect-app";
+import { runtimeFiberAsPromise as J } from "./vue-components.es10.js";
+import { isObject as q } from "./vue-components.es11.js";
+import { computed as I, onUnmounted as K, onMounted as B, onBeforeUnmount as G, watch as W, h as $ } from "vue";
+import k from "./vue-components.es12.js";
+import z from "./vue-components.es13.js";
+import { buildOmegaErrors as Q } from "./vue-components.es6.js";
+import T from "./vue-components.es14.js";
+import { generateMetaFromSchema as X } from "./vue-components.es8.js";
+import Y from "./vue-components.es5.js";
+import Z from "./vue-components.es15.js";
+import { trace as P } from "./vue-components.es16.js";
+import { context as g } from "./vue-components.es17.js";
+const p = (c) => function(o) {
+  return {
+    render() {
+      return $(o, {
+        form: c,
+        on: this.$listeners,
+        attrs: this.$attrs
+      }, this.$slots);
     }
-    return o;
-  }
-  if (t) {
-    const r = E(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), n.AST.isUnion(t)) {
-      const a = t.types.find(
-        (u) => u._tag !== "UndefinedKeyword" && u !== n.Null.ast
-      );
-      return "propertySignatures" in a ? m({
-        propertySignatures: a.propertySignatures,
-        parent: i,
-        meta: e
-      }) : t.types.every(n.AST.isLiteral) ? {
-        ...e,
-        type: "select",
-        members: t.types.map((u) => u.literal)
-      } : {
-        ...e,
-        ...m({
-          parent: i,
-          meta: e,
-          property: a
-        })
-      };
-    }
-    if (n.AST.isTupleType(t))
+  };
+}, C = (c) => function(o) {
+  return {
+    setup() {
       return {
-        ...e,
-        type: "multiple",
-        members: t.elements,
-        rest: t.rest
+        ...c
       };
-    const l = n.AST.getAnnotation(
-      t,
-      n.AST.JSONSchemaAnnotationId
-    ).pipe(c.getOrElse(() => ({})));
-    return e = { ...e, ...l }, "from" in t ? m({
-      parent: i,
-      meta: e,
-      property: t.from
-    }) : (e.type = n.AST.getAnnotation(
-      t,
-      n.AST.TitleAnnotationId
-    ).pipe(
-      c.getOrElse(() => "unknown")
-    ), e);
+    },
+    render({ errors: h, generalErrors: w, showErrors: S }) {
+      return $(o, {
+        errors: h,
+        generalErrors: w,
+        showErrors: S,
+        on: this.$listeners,
+        attrs: this.$attrs
+      }, this.$slots);
+    }
+  };
+}, pe = (c, a, o) => {
+  if (!c) throw new Error("Schema is required");
+  const h = O.standardSchemaV1(c), w = O.decode(c), { filterItems: S, meta: f } = X(c), l = I(() => {
+    if (o?.persistency?.id)
+      return o.persistency.id;
+    const e = window.location.pathname, r = Object.keys(f);
+    return `${e}-${r.join("-")}`;
+  }), A = () => {
+    const e = new URLSearchParams(window.location.search);
+    e.delete(l.value);
+    const r = new URL(window.location.href);
+    r.search = e.toString(), window.history.replaceState({}, "", r.toString());
+  };
+  function E(e, r) {
+    for (const t in r)
+      r[t] && q(r[t]) ? (e[t] || (e[t] = {}), E(e[t], r[t])) : e[t] = r[t];
+    return e;
   }
-  return o;
-}, q = (e) => {
-  const i = e.ast, t = {};
-  if (i._tag === "Transformation" || i._tag === "Refinement")
-    return q(n.make(i.from));
-  if ("propertySignatures" in i) {
-    const p = m({
-      propertySignatures: i.propertySignatures
+  const U = I(() => {
+    if (a?.defaultValues && !o?.persistency?.overrideDefaultValues)
+      return a?.defaultValues;
+    let e;
+    const r = o?.persistency;
+    if (!r?.policies || r.policies.length === 0) return {};
+    if (r.policies.includes("querystring"))
+      try {
+        const s = new URLSearchParams(window.location.search).get(l.value);
+        A(), s && (e = JSON.parse(s));
+      } catch (t) {
+        console.error(t);
+      }
+    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 s = JSON.parse(
+            t.getItem(l.value) || "{}"
+          );
+          t.removeItem(l.value), e = s;
+        } catch (s) {
+          console.error(s);
+        }
+    }
+    if (e ??= {}, a?.defaultValues == null)
+      return e;
+    {
+      const t = a?.defaultValues;
+      return E(t, e);
+    }
+  }), M = (e, r) => e ? g.with(P.setSpan(g.active(), e), r) : r(), u = D({
+    ...a,
+    validators: {
+      onSubmit: h,
+      ...a?.validators || {}
+    },
+    onSubmit: a?.onSubmit ? ({ formApi: e, meta: r, value: t }) => M(r?.currentSpan, async () => {
+      const s = await d.runPromise(w(t)), n = a.onSubmit({
+        formApi: e,
+        meta: r,
+        value: s
+      });
+      return y.isFiber(n) && y.isRuntimeFiber(n) ? await J(n) : d.isEffect(n) ? await d.runPromise(
+        n.pipe(
+          // meta?.currentSpan
+          //   ? Effect.withParentSpan(meta.currentSpan)
+          //   : (_) => _,
+          d.flatMap((m) => y.join(m))
+        )
+      ) : n;
+    }) : void 0,
+    defaultValues: U.value
+  }), N = () => {
+    Object.keys(f).forEach((e) => {
+      u.setFieldValue(e, void 0);
     });
-    if (Object.values(p).every((r) => r && "type" in r))
-      return p;
-    const o = (r, l = "") => {
-      for (const a in r) {
-        const u = l ? `${l}.${a}` : a;
-        r[a] && typeof r[a] == "object" && "type" in r[a] ? t[u] = r[a] : r[a] && typeof r[a] == "object" && o(r[a], u);
+  }, V = (e) => e.reduce((r, t) => {
+    const s = t.split(".");
+    return s.reduce((n, m, x) => (x === s.length - 1 ? n[m] = u.getFieldValue(t) : n[m] = n[m] ?? {}, n[m]), r), r;
+  }, {}), F = (e) => {
+    if (e) {
+      if (Array.isArray(e.keys))
+        return V(e.keys);
+      if (Array.isArray(e.banKeys)) {
+        const r = Object.keys(f).filter((t) => e.banKeys?.includes(t));
+        return V(r);
       }
-    };
-    o(p);
-  }
-  return t;
-}, I = (e) => n.extend(e, n.Struct({})), K = (e) => {
-  const i = q(e), t = L(
-    e.ast,
-    c.liftPredicate((p) => p._tag === "Refinement" && "filter" in p),
-    c.flatMap((p) => n.AST.getJSONSchemaAnnotation(p)),
-    c.filter((p) => "items" in p),
-    c.filterMap(({ items: p }) => n.decodeUnknownOption(N)(p)),
-    c.zipWith(
-      n.AST.getMessageAnnotation(e.ast),
-      (p, o) => ({
-        items: p,
-        message: o("")
-      })
-    ),
-    c.getOrUndefined
+      return u.store.state.values;
+    }
+  }, v = () => {
+    const e = o?.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 = F(e);
+      return r.setItem(l.value, JSON.stringify(t));
+    }
+  }, j = () => {
+    const e = o?.persistency;
+    if (!(!e?.policies || e.policies.length === 0) && e.policies.includes("querystring")) {
+      const r = F(e), t = new URLSearchParams(window.location.search);
+      t.set(l.value, JSON.stringify(r));
+      const s = new URL(window.location.href);
+      s.search = t.toString(), window.history.replaceState({}, "", s.toString());
+    }
+  };
+  K(v), B(() => {
+    window.addEventListener("beforeunload", v), window.addEventListener("blur", j);
+  }), G(() => {
+    window.removeEventListener("beforeunload", v), window.removeEventListener("blur", j);
+  });
+  const R = u.handleSubmit, i = Object.assign(u, {
+    i18nNamespace: o?.i18nNamespace,
+    meta: f,
+    filterItems: S,
+    clear: N,
+    handleSubmit: (e) => {
+      const r = P.getSpan(g.active());
+      return R({ currentSpan: r, ...e });
+    }
+    // /** @experimental */
+    // handleSubmitEffect: (meta?: Record<string, any>) =>
+    //   Effect.currentSpan.pipe(
+    //     Effect.option,
+    //     Effect
+    //       .flatMap((span) =>
+    //         Effect.promise(() => form.handleSubmit(Option.isSome(span) ? { currentSpan: span.value, ...meta } : meta))
+    //       )
+    //   )
+  }), _ = H(
+    i.store,
+    (e) => e.submissionAttempts
+  ), b = i.useStore((e) => e.errors);
+  W(
+    () => [i.filterItems, b.value],
+    () => {
+      const e = i.filterItems, r = b.value;
+      return e ? r ? (Object.values(r).filter(
+        (s) => !!s
+      ).flatMap(
+        (s) => Object.values(s).flat().map((n) => n.message)
+      ).some((s) => s === e.message) && e.items.forEach((s) => {
+        const n = i.getFieldMeta(s);
+        n && i.setFieldMeta(s, {
+          ...n,
+          errorMap: {
+            onSubmit: [
+              { path: [s], message: e.message }
+            ]
+          }
+        });
+      }), {}) : {} : {};
+    }
   );
-  return { schema: e, meta: i, filterItems: t };
-}, P = (e) => {
-  const { trans: i } = _();
-  let t;
-  switch (e.type) {
-    case "string":
-      t = n.String.annotations({
-        message: () => i("validation.empty")
-      }), e.format === "email" && (t = n.compose(
-        t,
-        n.Email.annotations({
-          message: () => i("validation.email.invalid")
-        })
-      )), e.required && t.annotations({
-        message: () => i("validation.empty")
-      }), e.maxLength && (t = t.pipe(n.maxLength(e.maxLength)).annotations({
-        message: () => i("validation.string.maxLength", {
-          maxLength: e.maxLength
-        })
-      })), e.minLength && (t = t.pipe(n.minLength(e.minLength)).annotations({
-        message: () => i("validation.string.minLength", {
-          minLength: e.minLength
-        })
-      }));
-      break;
-    case "number":
-      t = n.Number.annotations({
-        message: () => i("validation.empty")
-      }), e.required && t.annotations({
-        message: () => i("validation.empty")
-      }), e.minimum && (t = t.pipe(n.greaterThanOrEqualTo(e.minimum)).annotations({
-        message: () => i("validation.number.min", {
-          minimum: e.minimum,
-          isExclusive: !0
-        })
-      })), e.maximum && (t = t.pipe(n.lessThanOrEqualTo(e.maximum)).annotations({
-        message: () => i("validation.number.max", {
-          maximum: e.maximum,
-          isExclusive: !0
-        })
-      })), e.exclusiveMinimum && (t = t.pipe(n.greaterThan(e.exclusiveMinimum)).annotations({
-        message: () => i("validation.number.min", {
-          minimum: e.exclusiveMinimum,
-          isExclusive: !1
-        })
-      })), e.exclusiveMaximum && (t = t.pipe(n.lessThan(e.exclusiveMaximum)).annotations({
-        message: () => i("validation.number.max", {
-          maximum: e.exclusiveMaximum,
-          isExclusive: !1
-        })
-      }));
-      break;
-    case "select":
-      t = n.Literal(...e.members).annotations({
-        message: () => ({
-          message: i("validation.not_a_valid", {
-            type: "select",
-            message: e.members.join(", ")
-          }),
-          override: !0
-        })
-      });
-      break;
-    case "multiple":
-      t = n.Array(n.String).annotations({
-        message: () => i("validation.not_a_valid", {
-          type: "multiple",
-          message: e.members.join(", ")
-        })
-      });
-      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 e.required ? t.pipe(
-    n.annotations({
-      message: () => i("validation.empty")
-    })
-  ) : t = n.NullishOr(t), n.standardSchemaV1(t);
-}, j = (e, i) => n.NullOr(e).pipe(
-  n.transform(n.typeSchema(e), {
-    decode: (t) => t ?? i(),
-    encode: (t) => t
-  })
-), k = [
-  "button",
-  "checkbox",
-  "color",
-  "date",
-  "email",
-  "number",
-  "password",
-  "radio",
-  "range",
-  "search",
-  "submit",
-  "tel",
-  "text",
-  "time",
-  "url"
-], F = (e) => k.includes(e) ? e : "text";
+  const L = Q(_, b, o?.showErrorsOn);
+  return Object.assign(i, {
+    errorContext: L,
+    Form: p(i)(Z),
+    Input: p(i)(o?.input ?? Y),
+    Field: u.Field,
+    Errors: C(L)(T),
+    Array: p(i)(k),
+    AutoGen: p(i)(z)
+  });
+};
 export {
-  m as createMeta,
-  I as duplicateSchema,
-  P as generateInputStandardSchemaFromFieldMeta,
-  K as generateMetaFromSchema,
-  F as getInputType,
-  j as nullableInput
+  pe as useOmegaForm
 };