@effect-app/vue-components 0.0.1

package/dist/vue-components.es.js

@@ -0,0 +1,624 @@
+import { defineComponent as A, ref as C, createElementBlock as S, openBlock as c, createTextVNode as M, createElementVNode as k, toDisplayString as E, computed as O, readonly as Se, provide as ne, inject as re, watch as L, withModifiers as Oe, unref as f, renderSlot as ae, useId as _e, onMounted as Ee, watchEffect as Te, resolveComponent as U, createBlock as v, createCommentVNode as w, normalizeClass as ke, createVNode as q, resolveDynamicComponent as I, withCtx as _, Transition as we, Fragment as Y, renderList as Z, defineCustomElement as N } from "vue";
+import { useStore as $, useForm as Ie } from "@tanstack/vue-form";
+import { S as s, pipe as Ae, Option as h } from "effect-app";
+import { VTextField as ee, VSelect as Me } from "vuetify/components";
+import { mdiRefresh as qe, mdiLink as $e } from "@mdi/js";
+const Le = { class: "cool" }, Ue = { class: "super" }, Ce = /* @__PURE__ */ A({
+  __name: "TestComponent",
+  props: {
+    test: {}
+  },
+  setup(e) {
+    const n = C("COOL");
+    return (t, r) => (c(), S("div", Le, [
+      r[0] || (r[0] = M("I'm so ")),
+      k("span", Ue, E(n.value), 1),
+      M(" " + E(t.test), 1)
+    ]));
+  }
+}), V = (e, n) => {
+  const t = e.__vccOpts || e;
+  for (const [r, o] of n)
+    t[r] = o;
+  return t;
+}, Ne = /* @__PURE__ */ V(Ce, [["__scopeId", "data-v-24ab8834"]]);
+function Ve(e, n) {
+  return O(() => n ? $(e.store, (r) => {
+    const o = {};
+    for (const a of n)
+      o[a] = r[a];
+    return o;
+  }).value : {});
+}
+const F = Symbol();
+function se(e, n) {
+  const t = C([]), r = (u) => {
+    t.value = t.value.filter((l) => l.inputId !== u);
+  }, o = (u) => {
+    r(u.inputId), t.value.push(u);
+  }, a = () => {
+    t.value = [];
+  }, d = {
+    errors: Se(t),
+    addError: o,
+    removeError: r,
+    clearErrors: a,
+    formSubmissionAttempts: e,
+    generalErrors: n
+  };
+  return ne(F, d), d;
+}
+function x() {
+  const e = re(F);
+  if (!e)
+    throw new Error("useOmegaErrors must be used within an OmegaForm provider");
+  return e;
+}
+const Fe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  OmegaErrorsKey: F,
+  provideOmegaErrors: se,
+  useOmegaErrors: x
+}, Symbol.toStringTag, { value: "Module" })), ie = Symbol(), oe = () => {
+  const e = re(ie);
+  if (!e)
+    throw new Error("useIntl must be used within a IntlProvider");
+  return e;
+}, ot = (e) => ne(ie, e), xe = s.NonEmptyArray(s.String), Be = (e) => s.AST.isUnion(e) && e.types.find((n) => n._tag === "UndefinedKeyword" || n === s.Null.ast), je = (e) => !e || !s.AST.isUnion(e) ? !1 : e.types.find((n) => n._tag === "UndefinedKeyword") ? "undefined" : e.types.find((n) => n === s.Null.ast) ? "null" : !1, y = ({ meta: e = {}, parent: n = "", property: t, propertySignatures: r }, o = {}) => {
+  if (t && t._tag === "Transformation")
+    return y({
+      parent: n,
+      meta: e,
+      property: t.from
+    });
+  if ((t == null ? void 0 : t._tag) === "TypeLiteral" && "propertySignatures" in t)
+    return y({
+      meta: e,
+      propertySignatures: t.propertySignatures
+    });
+  if (r) {
+    for (const a of r) {
+      const d = n ? `${n}.${a.name.toString()}` : a.name.toString(), u = je(a.type), l = e.required ?? !u;
+      let p = a.type;
+      if (s.AST.isUnion(a.type) && (p = a.type.types.find(
+        (m) => m._tag !== "UndefinedKeyword" && m !== s.Null.ast
+      )), "propertySignatures" in p)
+        Object.assign(
+          o,
+          y({
+            parent: d,
+            propertySignatures: p.propertySignatures,
+            meta: { required: l, nullableOrUndefined: u }
+          })
+        );
+      else {
+        const m = y({
+          parent: d,
+          property: a.type,
+          meta: { required: l, nullableOrUndefined: u }
+        });
+        o[d] = m;
+      }
+    }
+    return o;
+  }
+  if (t) {
+    const a = Be(t);
+    if (Object.hasOwnProperty.call(e, "required") || (e.required = !a), s.AST.isUnion(t)) {
+      const u = t.types.find(
+        (l) => l._tag !== "UndefinedKeyword" && l !== s.Null.ast
+      );
+      return "propertySignatures" in u ? y({
+        propertySignatures: u.propertySignatures,
+        parent: n,
+        meta: e
+      }) : t.types.every(s.AST.isLiteral) ? {
+        ...e,
+        type: "select",
+        members: t.types.map((l) => l.literal)
+      } : {
+        ...e,
+        ...y({
+          parent: n,
+          meta: e,
+          property: u
+        })
+      };
+    }
+    if (s.AST.isTupleType(t))
+      return {
+        ...e,
+        type: "multiple",
+        members: t.elements
+      };
+    const d = s.AST.getAnnotation(
+      t,
+      s.AST.JSONSchemaAnnotationId
+    ).pipe(h.getOrElse(() => ({})));
+    return e = { ...e, ...d }, "from" in t ? y({
+      parent: n,
+      meta: e,
+      property: t.from
+    }) : (e.type = s.AST.getAnnotation(
+      t,
+      s.AST.TitleAnnotationId
+    ).pipe(
+      h.getOrElse(() => "unknown")
+    ), e);
+  }
+  return o;
+}, le = (e) => {
+  const n = e.ast, t = {};
+  if (n._tag === "Transformation" || n._tag === "Refinement")
+    return le(s.make(n.from));
+  if ("propertySignatures" in n) {
+    const r = y({
+      propertySignatures: n.propertySignatures
+    });
+    if (Object.values(r).every((a) => a && "type" in a))
+      return r;
+    const o = (a, d = "") => {
+      for (const u in a) {
+        const l = d ? `${d}.${u}` : u;
+        a[u] && typeof a[u] == "object" && "type" in a[u] ? t[l] = a[u] : a[u] && typeof a[u] == "object" && o(a[u], l);
+      }
+    };
+    o(r);
+  }
+  return t;
+}, Ke = (e) => s.extend(e, s.Struct({})), ue = (e) => {
+  const n = le(e), t = Ae(
+    e.ast,
+    h.liftPredicate((r) => r._tag === "Refinement" && "filter" in r),
+    h.flatMap((r) => s.AST.getJSONSchemaAnnotation(r)),
+    h.filter((r) => "items" in r),
+    h.filterMap(
+      ({ items: r }) => s.decodeUnknownOption(xe)(r)
+    ),
+    h.zipWith(
+      s.AST.getMessageAnnotation(e.ast),
+      (r, o) => ({
+        items: r,
+        message: o("")
+      })
+    ),
+    h.getOrUndefined
+  );
+  return { schema: e, meta: n, filterItems: t };
+}, me = (e) => {
+  const { trans: n } = oe();
+  let t;
+  switch (e.type) {
+    case "string":
+      t = s.String.annotations({
+        message: () => n("validation.empty")
+      }), e.format === "email" && (t = s.compose(
+        t,
+        s.Email.annotations({
+          message: () => n("validation.email.invalid")
+        })
+      )), e.required && t.annotations({
+        message: () => n("validation.empty")
+      }), e.maxLength && (t = t.pipe(s.maxLength(e.maxLength)).annotations({
+        message: () => n("validation.string.maxLength", {
+          maxLength: e.maxLength
+        })
+      })), e.minLength && (t = t.pipe(s.minLength(e.minLength)).annotations({
+        message: () => n("validation.string.minLength", {
+          minLength: e.minLength
+        })
+      }));
+      break;
+    case "number":
+      t = s.Number.annotations({
+        message: () => n("validation.empty")
+      }), e.required && t.annotations({
+        message: () => n("validation.empty")
+      }), e.minimum && (t = t.pipe(s.greaterThanOrEqualTo(e.minimum)).annotations({
+        message: () => n("validation.number.min", {
+          minimum: e.minimum,
+          isExclusive: !0
+        })
+      })), e.maximum && (t = t.pipe(s.lessThanOrEqualTo(e.maximum)).annotations({
+        message: () => n("validation.number.max", {
+          maximum: e.maximum,
+          isExclusive: !0
+        })
+      })), e.exclusiveMinimum && (t = t.pipe(s.greaterThan(e.exclusiveMinimum)).annotations({
+        message: () => n("validation.number.min", {
+          minimum: e.exclusiveMinimum,
+          isExclusive: !1
+        })
+      })), e.exclusiveMaximum && (t = t.pipe(s.lessThan(e.exclusiveMaximum)).annotations({
+        message: () => n("validation.number.max", {
+          maximum: e.exclusiveMaximum,
+          isExclusive: !1
+        })
+      }));
+      break;
+    case "select":
+      t = s.Literal(...e.members).annotations({
+        message: () => ({
+          message: n("validation.not_a_valid", {
+            type: "select",
+            message: e.members.join(", ")
+          }),
+          override: !0
+        })
+      });
+      break;
+    case "multiple":
+      t = s.Array(s.String).annotations({
+        message: () => n("validation.not_a_valid", {
+          type: "multiple",
+          message: e.members.join(", ")
+        })
+      });
+      break;
+    case "boolean":
+      t = s.Boolean;
+      break;
+    // todo: switch must be exhaustive or have default case, otherwise falls through with schema undefined.
+    case "unknown":
+      t = s.Unknown;
+      break;
+  }
+  return e.required ? t.pipe(
+    s.annotations({
+      message: () => n("validation.empty")
+    })
+  ) : t = s.NullishOr(t), s.standardSchemaV1(t);
+}, Pe = (e, n) => s.NullOr(e).pipe(
+  s.transform(s.typeSchema(e), {
+    decode: (t) => t ?? n(),
+    encode: (t) => t
+  })
+), de = (e, n) => {
+  if (!e) throw new Error("Schema is required");
+  const t = s.standardSchemaV1(e), { filterItems: r, meta: o } = ue(e), a = Ie({
+    ...n,
+    validators: {
+      onSubmit: t,
+      ...(n == null ? void 0 : n.validators) || {}
+    },
+    onSubmit: n != null && n.onSubmit ? ({ formApi: u, meta: l, value: p }) => {
+      var m;
+      return (m = n.onSubmit) == null ? void 0 : m.call(n, {
+        formApi: u,
+        meta: l,
+        value: p
+      });
+    } : void 0
+  });
+  return Object.assign(a, { meta: o, filterItems: r });
+}, Re = ["disabled"], De = /* @__PURE__ */ A({
+  __name: "OmegaWrapper",
+  props: {
+    subscribe: {},
+    form: {},
+    schema: {},
+    defaultValues: {},
+    defaultState: {},
+    asyncAlways: { type: Boolean },
+    asyncDebounceMs: {},
+    validators: {},
+    onSubmitMeta: {},
+    onSubmitInvalid: { type: Function },
+    transform: {},
+    onSubmit: { type: Function }
+  },
+  setup(e, { expose: n }) {
+    const t = e, r = t.form ?? de(t.schema, t), o = $(r.store, (l) => l.isSubmitting);
+    n(r);
+    const a = Ve(
+      r,
+      t.subscribe
+    ), d = $(
+      r.store,
+      (l) => l.submissionAttempts
+    ), u = r.useStore((l) => l.errors);
+    return L(
+      () => [r.filterItems, u.value],
+      () => {
+        const l = r.filterItems;
+        return l ? u.value ? (Object.values(u.value).filter(
+          (m) => !!m
+        ).flatMap(
+          (m) => Object.values(m).flat().map((b) => b.message)
+        ).some((m) => m === l.message) && l.items.forEach((m) => {
+          const b = r.getFieldMeta(m);
+          r.setFieldMeta(m, {
+            ...b,
+            errorMap: {
+              onSubmit: [{ path: [m], message: l.message }]
+            }
+          });
+        }), {}) : {} : {};
+      }
+    ), se(d, u), (l, p) => (c(), S("form", {
+      onSubmit: p[0] || (p[0] = Oe((m) => f(r).handleSubmit(), ["prevent", "stop"]))
+    }, [
+      k("fieldset", { disabled: f(o) }, [
+        ae(l.$slots, "default", {
+          form: f(r),
+          subscribedValues: f(a)
+        }, void 0, !0)
+      ], 8, Re)
+    ], 32));
+  }
+}), fe = /* @__PURE__ */ V(De, [["__scopeId", "data-v-0de09910"]]), ze = { class: "omega-input" }, Je = /* @__PURE__ */ A({
+  __name: "OmegaInternalInput",
+  props: {
+    field: {},
+    meta: {},
+    label: {},
+    options: {},
+    type: {},
+    validators: {}
+  },
+  setup(e) {
+    const n = e, t = _e(), r = n.field, o = $(r.store, (i) => i), a = O(() => {
+      var i, g;
+      return n.type ? n.type : ((i = n.meta) == null ? void 0 : i.type) === "string" ? n.meta.format === "email" ? "email" : "text" : ((g = n.meta) == null ? void 0 : g.type) || "unknown";
+    }), d = O(() => o.value.value), u = O(
+      () => o.value.meta.errors.map((i) => i.message).filter(Boolean)
+    );
+    L(
+      () => [!!d.value],
+      () => {
+        var i, g;
+        u.value.length && !d.value && !((i = n.meta) != null && i.required) && r.setValue(
+          ((g = n.meta) == null ? void 0 : g.nullableOrUndefined) === "undefined" ? void 0 : null
+        );
+      }
+    ), Ee(() => {
+      var i, g;
+      !d.value && !((i = n.meta) != null && i.required) && ((g = n.meta) == null ? void 0 : g.nullableOrUndefined) === "null" && r.setValue(null);
+    });
+    const l = C(!1), p = () => {
+      l.value = !0;
+    }, { addError: m, formSubmissionAttempts: b, removeError: ye } = x();
+    Te(() => {
+      b.value > 0 && (l.value = !0);
+    });
+    const T = O(() => !l.value && a.value !== "select" ? [] : u.value);
+    return L(
+      () => o.value.meta.errors,
+      () => {
+        o.value.meta.errors.length ? m({
+          inputId: t,
+          errors: o.value.meta.errors.map((i) => i.message).filter(Boolean),
+          label: n.label
+        }) : ye(t);
+      }
+    ), (i, g) => {
+      var B, j, K, P, R, D, z, J, W, G, H, Q;
+      const he = U("v-btn");
+      return c(), S("div", ze, [
+        a.value === "email" || a.value === "text" ? (c(), v(f(ee), {
+          key: 0,
+          id: f(t),
+          required: (B = i.meta) == null ? void 0 : B.required,
+          "min-length": ((j = i.meta) == null ? void 0 : j.type) === "string" && ((K = i.meta) == null ? void 0 : K.minLength),
+          "max-length": ((P = i.meta) == null ? void 0 : P.type) === "string" && ((R = i.meta) == null ? void 0 : R.maxLength),
+          type: a.value,
+          name: i.field.name,
+          label: `${i.label}${(D = i.meta) != null && D.required ? " *" : ""}`,
+          "model-value": i.field.state.value,
+          "error-messages": T.value,
+          error: !!T.value.length,
+          "onUpdate:modelValue": i.field.handleChange,
+          onBlur: p
+        }, null, 8, ["id", "required", "min-length", "max-length", "type", "name", "label", "model-value", "error-messages", "error", "onUpdate:modelValue"])) : w("", !0),
+        a.value === "number" ? (c(), v(f(ee), {
+          key: 1,
+          id: f(t),
+          required: (z = i.meta) == null ? void 0 : z.required,
+          min: ((J = i.meta) == null ? void 0 : J.type) === "number" && i.meta.minimum,
+          max: ((W = i.meta) == null ? void 0 : W.type) === "number" && i.meta.maximum,
+          type: a.value,
+          name: i.field.name,
+          label: `${i.label}${(G = i.meta) != null && G.required ? " *" : ""}`,
+          "model-value": i.field.state.value,
+          "error-messages": T.value,
+          error: !!T.value.length,
+          "onUpdate:modelValue": g[0] || (g[0] = (X) => {
+            i.field.handleChange(Number(X));
+          }),
+          onBlur: p
+        }, null, 8, ["id", "required", "min", "max", "type", "name", "label", "model-value", "error-messages", "error"])) : w("", !0),
+        a.value === "select" || a.value === "multiple" ? (c(), S("div", {
+          key: 2,
+          class: ke(a.value !== "multiple" && "d-flex align-center")
+        }, [
+          q(f(Me), {
+            id: f(t),
+            required: (H = i.meta) == null ? void 0 : H.required,
+            multiple: a.value === "multiple",
+            chips: a.value === "multiple",
+            name: i.field.name,
+            "model-value": i.field.state.value,
+            label: `${i.label}${(Q = i.meta) != null && Q.required ? " *" : ""}`,
+            items: i.options,
+            "error-messages": T.value,
+            error: !!T.value.length,
+            "onUpdate:modelValue": i.field.handleChange,
+            onBlur: p
+          }, null, 8, ["id", "required", "multiple", "chips", "name", "model-value", "label", "items", "error-messages", "error", "onUpdate:modelValue"]),
+          a.value !== "multiple" ? (c(), v(he, {
+            key: 0,
+            "variant-btn": "secondary",
+            "variant-icon": f(qe),
+            class: "mr-2",
+            title: "Reset",
+            onClick: g[1] || (g[1] = (X) => i.field.handleChange(void 0))
+          }, null, 8, ["variant-icon"])) : w("", !0)
+        ], 2)) : w("", !0)
+      ]);
+    };
+  }
+}), ce = /* @__PURE__ */ A({
+  __name: "OmegaInput",
+  props: {
+    form: {},
+    name: {},
+    validators: {},
+    label: {},
+    options: {},
+    type: {}
+  },
+  setup(e) {
+    const n = e, t = O(() => n.form.meta[n.name]), r = O(() => {
+      if (!t.value)
+        throw new Error("Meta is undefined");
+      return me(t.value);
+    });
+    return (o, a) => (c(), v(I(o.form.Field), {
+      name: o.name,
+      validators: {
+        onChange: r.value,
+        ...o.validators
+      }
+    }, {
+      default: _(({
+        field: d
+      }) => [
+        ae(o.$slots, "default", {
+          field: d,
+          label: o.label,
+          options: o.options,
+          meta: t.value,
+          type: o.type
+        }, () => [
+          q(Je, {
+            field: d,
+            label: o.label,
+            options: o.options,
+            meta: t.value,
+            type: o.type
+          }, null, 8, ["field", "label", "options", "meta", "type"])
+        ])
+      ]),
+      _: 3
+    }, 8, ["name", "validators"]));
+  }
+}), We = {
+  key: 0,
+  class: "error-alert"
+}, Ge = { class: "text-h6 mb-3" }, He = { class: "font-weight-medium" }, Qe = { class: "error-message" }, Xe = ["href"], Ye = { key: 1 }, Ze = /* @__PURE__ */ A({
+  __name: "OmegaErrors",
+  setup(e) {
+    const { errors: n, formSubmissionAttempts: t, generalErrors: r } = x(), { trans: o } = oe(), a = O(() => r.value ? r.value.filter(
+      (d) => !!d
+    ).flatMap(
+      (d) => Object.values(d).filter((u) => !!u).flatMap(
+        (u) => u.filter(
+          (l) => !!(l != null && l.message)
+        ).map((l) => l.message)
+      )
+    ) : []);
+    return (d, u) => {
+      const l = U("v-icon"), p = U("v-alert");
+      return c(), v(we, null, {
+        default: _(() => [
+          f(t) > 0 && (f(n).length || a.value.length) ? (c(), S("div", We, [
+            q(p, {
+              type: "error",
+              variant: "tonal",
+              role: "alert",
+              "aria-live": "polite",
+              class: "mb-4"
+            }, {
+              default: _(() => [
+                k("div", Ge, E(f(o)("form.includes_error")) + ":", 1),
+                f(n).length ? (c(), v(I(f(n).length > 1 ? "ul" : "div"), {
+                  key: 0,
+                  class: "error-list"
+                }, {
+                  default: _(() => [
+                    (c(!0), S(Y, null, Z(f(n), (m) => (c(), v(I(f(n).length > 1 ? "li" : "div"), {
+                      key: m.inputId,
+                      class: "error-item"
+                    }, {
+                      default: _(() => [
+                        k("div", He, E(m.label), 1),
+                        k("div", Qe, [
+                          (c(), v(I(m.errors.length > 1 ? "ul" : "div"), { class: "error-list" }, {
+                            default: _(() => [
+                              (c(!0), S(Y, null, Z(m.errors, (b) => (c(), v(I(m.errors.length > 1 ? "li" : "span"), { key: b }, {
+                                default: _(() => [
+                                  M(E(b), 1)
+                                ]),
+                                _: 2
+                              }, 1024))), 128))
+                            ]),
+                            _: 2
+                          }, 1024))
+                        ]),
+                        k("a", {
+                          href: `#${m.inputId}`,
+                          class: "error-link"
+                        }, [
+                          q(l, { icon: f($e) }, null, 8, ["icon"]),
+                          M(" " + E(f(o)("form.fix_input")), 1)
+                        ], 8, Xe)
+                      ]),
+                      _: 2
+                    }, 1024))), 128))
+                  ]),
+                  _: 1
+                })) : (c(), S("span", Ye, E(a.value[0]), 1))
+              ]),
+              _: 1
+            })
+          ])) : w("", !0)
+        ]),
+        _: 1
+      });
+    };
+  }
+}), pe = /* @__PURE__ */ V(Ze, [["__scopeId", "data-v-55fda615"]]), ge = N(fe), ve = N(ce), be = N(pe);
+function et() {
+  customElements.get("omega-form") || customElements.define("omega-form", ge), customElements.get("omega-input") || customElements.define("omega-input", ve), customElements.get("omega-errors") || customElements.define("omega-errors", be);
+}
+const te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  OmegaErrors: pe,
+  OmegaErrorsCE: be,
+  OmegaErrorsContext: Fe,
+  OmegaForm: fe,
+  OmegaFormCE: ge,
+  OmegaInput: ce,
+  OmegaInputCE: ve,
+  TestComponent: Ne,
+  duplicateSchema: Ke,
+  generateInputStandardSchemaFromFieldMeta: me,
+  generateMetaFromSchema: ue,
+  nullableInput: Pe,
+  registerOmegaForm: et,
+  useOmegaForm: de
+}, Symbol.toStringTag, { value: "Module" }));
+function tt(e) {
+  for (const n in te)
+    e.component(n, te[n]);
+}
+const lt = { install: tt };
+export {
+  pe as OmegaErrors,
+  be as OmegaErrorsCE,
+  Fe as OmegaErrorsContext,
+  fe as OmegaForm,
+  ge as OmegaFormCE,
+  ce as OmegaInput,
+  ve as OmegaInputCE,
+  Ne as TestComponent,
+  lt as default,
+  Ke as duplicateSchema,
+  me as generateInputStandardSchemaFromFieldMeta,
+  ue as generateMetaFromSchema,
+  Pe as nullableInput,
+  ot as provideIntl,
+  et as registerOmegaForm,
+  oe as useIntl,
+  de as useOmegaForm
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@effect-app/vue-components",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@mdi/js": "^7.4.47",
+    "@tanstack/vue-form": "^1.1.3",
+    "effect": "^3.14.2",
+    "intl-messageformat": "^10.7.16",
+    "mdi-js": "^1.0.1",
+    "primeflex": "^4.0.0",
+    "primeicons": "^7.0.0",
+    "primevue": "^4.3.3",
+    "vue": "^3.5.13",
+    "vuetify": "^3.7.19"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.14",
+    "@vitejs/plugin-vue": "^5.2.3",
+    "rimraf": "^6.0.1",
+    "sass": "^1.86.0",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.3",
+    "vitepress": "^1.6.3",
+    "vue-tsc": "^2.2.8"
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "module": "./dist/vue-components.es.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/vue-components.es.js"
+    },
+    "./dist/style.css": "./dist/style.css"
+  },
+  "dependencies": {
+    "@effect-app/vue": "2.39.2",
+    "effect-app": "2.37.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && vue-tsc && vite build",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:serve": "vitepress serve docs"
+  }
+}