@effect-app/vue-components 0.4.6 → 0.6.1

package/dist/vue-components.es8.js

@@ -1,8 +1,218 @@
-(function(){"use strict";try{if(typeof document<"u"){var n=document.createElement("style");if(n.appendChild(document.createTextNode("fieldset[data-v-6833e150]{display:contents}")),document.head.appendChild(n),window.customElements){const e=window.customElements.define;window.customElements.define=function(i,t){const o=t.prototype.connectedCallback;return t.prototype.connectedCallback=function(){if(o&&o.call(this),this.shadowRoot){const d=document.createElement("style");d.appendChild(document.createTextNode("fieldset[data-v-6833e150]{display:contents}")),this.shadowRoot.appendChild(d)}},e.call(window.customElements,i,t)}}}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
-import o from "./vue-components.es11.js";
-
-import m from "./vue-components.es13.js";
-const e = /* @__PURE__ */ m(o, [["__scopeId", "data-v-6833e150"]]);
+import { S as i, pipe as p, Option as f } from "effect-app";
+import { useIntl as S } from "./vue-components.es3.js";
+const y = i.NonEmptyArray(i.String), v = (e) => i.AST.isUnion(e) && e.types.find((t) => t._tag === "UndefinedKeyword" || t === i.Null.ast), x = (e) => !e || !i.AST.isUnion(e) ? !1 : e.types.find((t) => t._tag === "UndefinedKeyword") ? "undefined" : e.types.find((t) => t === i.Null.ast) ? "null" : !1, m = ({ meta: e = {}, parent: t = "", property: n, propertySignatures: a }, l = {}) => {
+  if (n && n._tag === "Transformation")
+    return m({
+      parent: t,
+      meta: e,
+      property: n.from
+    });
+  if ((n == null ? void 0 : n._tag) === "TypeLiteral" && "propertySignatures" in n)
+    return m({
+      meta: e,
+      propertySignatures: n.propertySignatures
+    });
+  if (a) {
+    for (const s of a) {
+      const u = t ? `${t}.${s.name.toString()}` : s.name.toString(), r = x(s.type), o = !r;
+      let d = s.type;
+      if (i.AST.isUnion(s.type) && (d = s.type.types.find(
+        (g) => g._tag !== "UndefinedKeyword" && g !== i.Null.ast
+      )), "propertySignatures" in d)
+        Object.assign(
+          l,
+          m({
+            parent: u,
+            propertySignatures: d.propertySignatures,
+            meta: { required: o, nullableOrUndefined: r }
+          })
+        );
+      else {
+        const g = m({
+          parent: u,
+          property: s.type,
+          meta: { required: o, nullableOrUndefined: r }
+        });
+        l[u] = g;
+      }
+    }
+    return l;
+  }
+  if (n) {
+    const s = v(n);
+    if (Object.hasOwnProperty.call(e, "required") || (e.required = !s), i.AST.isUnion(n)) {
+      const r = n.types.find(
+        (o) => o._tag !== "UndefinedKeyword" && o !== i.Null.ast
+      );
+      return "propertySignatures" in r ? m({
+        propertySignatures: r.propertySignatures,
+        parent: t,
+        meta: e
+      }) : n.types.every(i.AST.isLiteral) ? {
+        ...e,
+        type: "select",
+        members: n.types.map((o) => o.literal)
+      } : {
+        ...e,
+        ...m({
+          parent: t,
+          meta: e,
+          property: r
+        })
+      };
+    }
+    if (i.AST.isTupleType(n))
+      return {
+        ...e,
+        type: "multiple",
+        members: n.elements
+      };
+    const u = i.AST.getAnnotation(
+      n,
+      i.AST.JSONSchemaAnnotationId
+    ).pipe(f.getOrElse(() => ({})));
+    return e = { ...e, ...u }, "from" in n ? m({
+      parent: t,
+      meta: e,
+      property: n.from
+    }) : (e.type = i.AST.getAnnotation(
+      n,
+      i.AST.TitleAnnotationId
+    ).pipe(
+      f.getOrElse(() => "unknown")
+    ), e);
+  }
+  return l;
+}, c = (e) => {
+  const t = e.ast, n = {};
+  if (t._tag === "Transformation" || t._tag === "Refinement")
+    return c(i.make(t.from));
+  if ("propertySignatures" in t) {
+    const a = m({
+      propertySignatures: t.propertySignatures
+    });
+    if (Object.values(a).every((s) => s && "type" in s))
+      return a;
+    const l = (s, u = "") => {
+      for (const r in s) {
+        const o = u ? `${u}.${r}` : r;
+        s[r] && typeof s[r] == "object" && "type" in s[r] ? n[o] = s[r] : s[r] && typeof s[r] == "object" && l(s[r], o);
+      }
+    };
+    l(a);
+  }
+  return n;
+}, b = (e) => i.extend(e, i.Struct({})), A = (e) => {
+  const t = c(e), n = p(
+    e.ast,
+    f.liftPredicate((a) => a._tag === "Refinement" && "filter" in a),
+    f.flatMap((a) => i.AST.getJSONSchemaAnnotation(a)),
+    f.filter((a) => "items" in a),
+    f.filterMap(
+      ({ items: a }) => i.decodeUnknownOption(y)(a)
+    ),
+    f.zipWith(
+      i.AST.getMessageAnnotation(e.ast),
+      (a, l) => ({
+        items: a,
+        message: l("")
+      })
+    ),
+    f.getOrUndefined
+  );
+  return { schema: e, meta: t, filterItems: n };
+}, O = (e) => {
+  const { trans: t } = S();
+  let n;
+  switch (e.type) {
+    case "string":
+      n = i.String.annotations({
+        message: () => t("validation.empty")
+      }), e.format === "email" && (n = i.compose(
+        n,
+        i.Email.annotations({
+          message: () => t("validation.email.invalid")
+        })
+      )), e.required && n.annotations({
+        message: () => t("validation.empty")
+      }), e.maxLength && (n = n.pipe(i.maxLength(e.maxLength)).annotations({
+        message: () => t("validation.string.maxLength", {
+          maxLength: e.maxLength
+        })
+      })), e.minLength && (n = n.pipe(i.minLength(e.minLength)).annotations({
+        message: () => t("validation.string.minLength", {
+          minLength: e.minLength
+        })
+      }));
+      break;
+    case "number":
+      n = i.Number.annotations({
+        message: () => t("validation.empty")
+      }), e.required && n.annotations({
+        message: () => t("validation.empty")
+      }), e.minimum && (n = n.pipe(i.greaterThanOrEqualTo(e.minimum)).annotations({
+        message: () => t("validation.number.min", {
+          minimum: e.minimum,
+          isExclusive: !0
+        })
+      })), e.maximum && (n = n.pipe(i.lessThanOrEqualTo(e.maximum)).annotations({
+        message: () => t("validation.number.max", {
+          maximum: e.maximum,
+          isExclusive: !0
+        })
+      })), e.exclusiveMinimum && (n = n.pipe(i.greaterThan(e.exclusiveMinimum)).annotations({
+        message: () => t("validation.number.min", {
+          minimum: e.exclusiveMinimum,
+          isExclusive: !1
+        })
+      })), e.exclusiveMaximum && (n = n.pipe(i.lessThan(e.exclusiveMaximum)).annotations({
+        message: () => t("validation.number.max", {
+          maximum: e.exclusiveMaximum,
+          isExclusive: !1
+        })
+      }));
+      break;
+    case "select":
+      n = i.Literal(...e.members).annotations({
+        message: () => ({
+          message: t("validation.not_a_valid", {
+            type: "select",
+            message: e.members.join(", ")
+          }),
+          override: !0
+        })
+      });
+      break;
+    case "multiple":
+      n = i.Array(i.String).annotations({
+        message: () => t("validation.not_a_valid", {
+          type: "multiple",
+          message: e.members.join(", ")
+        })
+      });
+      break;
+    case "boolean":
+      n = i.Boolean;
+      break;
+    // todo: switch must be exhaustive or have default case, otherwise falls through with schema undefined.
+    case "unknown":
+      n = i.Unknown;
+      break;
+  }
+  return e.required ? n.pipe(
+    i.annotations({
+      message: () => t("validation.empty")
+    })
+  ) : n = i.NullishOr(n), i.standardSchemaV1(n);
+}, L = (e, t) => i.NullOr(e).pipe(
+  i.transform(i.typeSchema(e), {
+    decode: (n) => n ?? t(),
+    encode: (n) => n
+  })
+);
 export {
-  e as default
+  b as duplicateSchema,
+  O as generateInputStandardSchemaFromFieldMeta,
+  A as generateMetaFromSchema,
+  L as nullableInput
 };

package/dist/vue-components.es9.js

@@ -1,8 +1,8 @@
-(function(){"use strict";try{if(typeof document<"u"){var t=document.createElement("style");if(t.appendChild(document.createTextNode(".v-enter-from[data-v-502ecb3a],.v-leave-to[data-v-502ecb3a]{max-height:0px;grid-template-rows:0fr;opacity:0}.v-enter-active[data-v-502ecb3a],.v-leave-active[data-v-502ecb3a]{display:grid;transition:all .15s}.v-enter-to[data-v-502ecb3a],.v-leave-from[data-v-502ecb3a]{grid-template-rows:1fr;max-height:50vh;opacity:1}.error-alert[data-v-502ecb3a]{transition-behavior:allow-discrete;display:grid;overflow:hidden;min-height:0}.error-alert>*[data-v-502ecb3a]{min-height:0}.error-list[data-v-502ecb3a]{container-type:inline-size;display:grid;grid-template-columns:auto 1fr auto;gap:.5em;align-items:start}@container (max-width: 28.125rem){.error-list[data-v-502ecb3a]{grid-template-columns:auto 1fr}.error-link[data-v-502ecb3a]{grid-column:1 / -1;justify-self:end}}@container (max-width: 18.75rem){.error-list[data-v-502ecb3a]{grid-template-columns:1fr}.error-message[data-v-502ecb3a]{grid-column:1 / -1}}.error-item[data-v-502ecb3a]{display:contents}a[data-v-502ecb3a]{min-width:min-content}.error-link[data-v-502ecb3a]{align-items:center;color:inherit;display:inline-flex;flex-wrap:wrap;gap:.25em;padding-bottom:1em;text-decoration:none}")),document.head.appendChild(t),window.customElements){const e=window.customElements.define;window.customElements.define=function(n,a){const i=a.prototype.connectedCallback;return a.prototype.connectedCallback=function(){if(i&&i.call(this),this.shadowRoot){const r=document.createElement("style");r.appendChild(document.createTextNode(".v-enter-from[data-v-502ecb3a],.v-leave-to[data-v-502ecb3a]{max-height:0px;grid-template-rows:0fr;opacity:0}.v-enter-active[data-v-502ecb3a],.v-leave-active[data-v-502ecb3a]{display:grid;transition:all .15s}.v-enter-to[data-v-502ecb3a],.v-leave-from[data-v-502ecb3a]{grid-template-rows:1fr;max-height:50vh;opacity:1}.error-alert[data-v-502ecb3a]{transition-behavior:allow-discrete;display:grid;overflow:hidden;min-height:0}.error-alert>*[data-v-502ecb3a]{min-height:0}.error-list[data-v-502ecb3a]{container-type:inline-size;display:grid;grid-template-columns:auto 1fr auto;gap:.5em;align-items:start}@container (max-width: 28.125rem){.error-list[data-v-502ecb3a]{grid-template-columns:auto 1fr}.error-link[data-v-502ecb3a]{grid-column:1 / -1;justify-self:end}}@container (max-width: 18.75rem){.error-list[data-v-502ecb3a]{grid-template-columns:1fr}.error-message[data-v-502ecb3a]{grid-column:1 / -1}}.error-item[data-v-502ecb3a]{display:contents}a[data-v-502ecb3a]{min-width:min-content}.error-link[data-v-502ecb3a]{align-items:center;color:inherit;display:inline-flex;flex-wrap:wrap;gap:.25em;padding-bottom:1em;text-decoration:none}")),this.shadowRoot.appendChild(r)}},e.call(window.customElements,n,a)}}}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
-import o from "./vue-components.es15.js";
+(function(){"use strict";try{if(typeof document<"u"){var n=document.createElement("style");if(n.appendChild(document.createTextNode("fieldset[data-v-a32b1c91]{display:contents}")),document.head.appendChild(n),window.customElements){const e=window.customElements.define;window.customElements.define=function(c,t){const o=t.prototype.connectedCallback;return t.prototype.connectedCallback=function(){if(o&&o.call(this),this.shadowRoot){const d=document.createElement("style");d.appendChild(document.createTextNode("fieldset[data-v-a32b1c91]{display:contents}")),this.shadowRoot.appendChild(d)}},e.call(window.customElements,c,t)}}}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
+import o from "./vue-components.es11.js";
 
 import r from "./vue-components.es13.js";
-const e = /* @__PURE__ */ r(o, [["__scopeId", "data-v-502ecb3a"]]);
+const m = /* @__PURE__ */ r(o, [["__scopeId", "data-v-a32b1c91"]]);
 export {
-  e as default
+  m as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "0.4.6",
+  "version": "0.6.1",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "@tanstack/vue-form": "^1.2.4",
@@ -26,8 +26,10 @@
     "@vitejs/plugin-vue": "^5.2.3",
     "@vue/eslint-config-prettier": "^10.2.0",
     "@vue/eslint-config-typescript": "^14.5.0",
+    "@vue/test-utils": "^2.4.6",
     "eslint-plugin-prettier": "^5.2.6",
     "eslint-plugin-vue": "^10.0.0",
+    "jsdom": "^26.1.0",
     "rimraf": "^6.0.1",
     "sass": "^1.86.0",
     "storybook": "^8.6.12",
@@ -56,13 +58,17 @@
     "effect-app": "2.40.1"
   },
   "scripts": {
-    "build": "rimraf dist && vue-tsc && vite build",
+    "build": "pnpm test:run && pnpm build:run",
+    "build:run": "rimraf dist && vue-tsc && vite build",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:serve": "vitepress serve docs",
     "lint": "NODE_OPTIONS=--max-old-space-size=8192 eslint src",
     "autofix": "pnpm lint --fix",
     "storybook": "storybook dev -p 6006",
-    "build-storybook": "storybook build"
+    "build-storybook": "storybook build",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:watch": "vitest watch"
   }
 }

package/src/components/OmegaForm/OmegaAutoGen.vue

@@ -0,0 +1,110 @@
+<template>
+  <slot
+    v-for="{ name, label, ...attrs } in children"
+    :child="{ name, label, ...attrs }"
+  >
+    <OmegaInput :form="props.form" :name="name" :label="label" v-bind="attrs" />
+  </slot>
+</template>
+
+<script setup lang="ts" generic="From, To">
+import { computed } from "vue"
+import {
+  type NestedKeyOf,
+  type MetaRecord,
+  type FormType,
+  type FieldMeta,
+  type OmegaInputProps,
+} from "./OmegaFormStuff"
+import { pipe, Order, Array as A } from "effect-app"
+import OmegaInput from "./OmegaInput.vue"
+
+export type OmegaAutoGenMeta<From, To> = Omit<OmegaInputProps<From, To>, "form">
+type NewMeta = OmegaAutoGenMeta<From, To>
+
+const mapObject =
+  <K extends string, A, B>(fn: (value: A, key: K) => B) =>
+  (obj: Record<K, A>): Record<K, B> =>
+    Object.fromEntries(
+      (Object.entries(obj) as [K, A][]).map(([k, v]) => [k, fn(v, k)]),
+    ) as Record<K, B> // Cast needed for Object.fromEntries
+
+const filterRecord =
+  <K extends string, V>(predicate: (value: V, key: K) => boolean) =>
+  (obj: Record<K, V>): Record<K, V> =>
+    Object.fromEntries(
+      (Object.entries(obj) as [K, V][]).filter(([k, v]) => predicate(v, k)),
+    ) as Record<K, V>
+
+const filterMapRecord =
+  <K extends string, A, B>(fn: (value: A, key: K) => false | B) =>
+  (obj: Record<K, A>): Record<K, B> =>
+    (Object.entries(obj) as [K, A][]).reduce(
+      (acc, [key, value]) => {
+        const result = fn(value, key)
+        if (result !== false) {
+          acc[key] = result
+        }
+        return acc
+      },
+      {} as Record<K, B>,
+    )
+
+const props = defineProps<{
+  form: FormType<From, To> & {
+    meta: MetaRecord<To>
+  }
+  pick?: NestedKeyOf<To>[]
+  omit?: NestedKeyOf<To>[]
+  labelMap?: (key: NestedKeyOf<To>) => string | undefined
+  filterMap?: <M extends NewMeta>(key: NestedKeyOf<To>, meta: M) => boolean | M
+  order?: NestedKeyOf<To>[]
+  sort?: Order.Order<NewMeta>
+}>()
+
+const namePosition = (name: NestedKeyOf<To>, order: NestedKeyOf<To>[]) => {
+  const index = order?.indexOf(name) ?? -1
+  return index === -1 ? Number.MAX_SAFE_INTEGER : index
+}
+
+const orderBy: Order.Order<NewMeta> = Order.mapInput(
+  Order.number,
+  (x: NewMeta) => namePosition(x.name, props.order || []),
+)
+
+const children = computed<NewMeta[]>(() =>
+  pipe(
+    props.form.meta as Record<NestedKeyOf<To>, FieldMeta | undefined>,
+    // include / exclude
+    filterRecord((_, metaKey) =>
+      props.pick
+        ? props.pick.includes(metaKey) && !props.omit?.includes(metaKey)
+        : !props.omit?.includes(metaKey),
+    ),
+    x => x,
+    // labelMap and adding name
+    mapObject((metaValue, metaKey) => ({
+      name: metaKey,
+      label: props.labelMap?.(metaKey) || metaKey,
+      ...metaValue,
+    })),
+    // filterMap
+    props.filterMap
+      ? filterMapRecord(m => {
+          const result = props.filterMap?.(m.name!, m as NewMeta)
+          return result === undefined || result === true ? m : result
+        })
+      : x => x,
+    // transform to array
+    obj => Object.values(obj) as NewMeta[],
+    // order
+    A.sort(orderBy),
+    // sort
+    props.sort ? A.sort(props.sort) : x => x,
+  ),
+)
+
+defineSlots<{
+  default(props: { child: NewMeta }): void
+}>()
+</script>

package/src/components/OmegaForm/OmegaErrors.vue

@@ -130,7 +130,7 @@ const showedGeneralErrors = computed(() => {
   }
 }
 
-.error-list {
+div.error-list {
   container-type: inline-size;
   display: grid;
   grid-template-columns: auto 1fr auto;
@@ -139,7 +139,7 @@ const showedGeneralErrors = computed(() => {
 }
 
 @container (max-width: 28.125rem) {
-  .error-list {
+  div.error-list {
     grid-template-columns: auto 1fr;
   }
 
@@ -150,7 +150,7 @@ const showedGeneralErrors = computed(() => {
 }
 
 @container (max-width: 18.75rem) {
-  .error-list {
+  div.error-list {
     grid-template-columns: 1fr;
   }
 

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -122,7 +122,7 @@ export type FormComponent<T, S> = FieldComponent<
 > &
   Component
 
-export type FormType<T, S> = OmegaFormApi<T, S> & {
+export type FormType<T, S = unknown> = OmegaFormApi<T, S> & {
   Field: Component
 }
 

package/src/components/OmegaForm/OmegaInternalInput.vue

@@ -22,6 +22,7 @@ import {
   watchEffect,
   type ComputedRef,
   getCurrentInstance,
+  nextTick,
 } from "vue"
 import type {
   FieldValidators,
@@ -73,12 +74,14 @@ const errors = computed(() =>
 // we remove value and errors when the field is empty and not required
 //watchEffect will trigger infinite times with both free fieldValue and errors, so bet to watch a stupid boolean
 watch(
-  () => [!!fieldValue.value],
-  () => {
-    if (errors.value.length && !fieldValue.value && !props.meta?.required) {
-      fieldApi.setValue(
-        props.meta?.nullableOrUndefined === "undefined" ? undefined : null,
-      )
+  () => !!fieldValue.value,
+  value => {
+    if (!value) {
+      nextTick(() => {
+        fieldApi.setValue(
+          props.meta?.nullableOrUndefined === "undefined" ? undefined : null,
+        )
+      })
     }
   },
 )

package/src/components/OmegaForm/OmegaWrapper.vue

@@ -61,8 +61,8 @@
 import { useStore, type StandardSchemaV1Issue } from "@tanstack/vue-form"
 import { type S } from "effect-app"
 import {
-  type FilterItems,
   type FormProps,
+  type FilterItems,
   type OmegaFormApi,
   type OmegaFormState,
   type ShowErrorsOn,
@@ -74,23 +74,24 @@ import {
   type OmegaFormReturn,
   useOmegaForm,
 } from "./useOmegaForm"
-import { computed, watch, defineSlots } from "vue"
+import { computed, watch, onBeforeMount } from "vue"
 
 const props = defineProps<
   {
     omegaConfig?: OmegaConfig<From>
     subscribe?: K[]
     showErrorsOn?: ShowErrorsOn
-  } & (
-    | {
-        form: OmegaFormReturn<To, From>
-        schema?: undefined
-      }
-    | (FormProps<To, From> & {
-        form?: undefined
-        schema: S.Schema<From, To, never>
-      })
-  )
+  } & FormProps<To, From> &
+    (
+      | {
+          form: OmegaFormReturn<To, From>
+          schema?: undefined
+        }
+      | {
+          form?: undefined
+          schema: S.Schema<From, To, never>
+        }
+    )
 >()
 
 const localForm = computed(() => {
@@ -102,6 +103,52 @@ const localForm = computed(() => {
 
 const formToUse = computed(() => props.form ?? localForm.value!)
 
+onBeforeMount(() => {
+  if (!props.form) return
+  const formOptionsKeys = Object.keys(props.form.options || {})
+
+  const excludedKeys: Set<keyof typeof props> = new Set([
+    "omegaConfig",
+    "subscribe",
+    "showErrorsOn",
+    "asyncAlways",
+    "form",
+    "schema",
+  ])
+
+  const filteredProps = Object.fromEntries(
+    Object.entries(props).filter(
+      ([key, value]) =>
+        !excludedKeys.has(key as keyof typeof props) && value !== undefined,
+    ),
+  ) as Partial<typeof props>
+
+  const propsKeys = Object.keys(filteredProps)
+
+  const overlappingKeys = formOptionsKeys.filter(
+    key =>
+      propsKeys.includes(key) &&
+      filteredProps[key as keyof typeof props] !== undefined,
+  )
+
+  if (overlappingKeys.length > 0) {
+    console.warn(
+      `[OmegaWrapper] Overlapping keys found between form options and filtered props:\n${overlappingKeys.join(
+        ", \n",
+      )}.\nProps will overwrite existing form options. This might indicate a configuration issue.`,
+    )
+  }
+
+  const mergedOptions = {
+    ...formToUse.value.options,
+    ...filteredProps,
+  }
+
+  formToUse.value.options = Object.fromEntries(
+    Object.entries(mergedOptions).filter(([_, value]) => value !== undefined),
+  )
+})
+
 const formIsSubmitting = useStore(
   formToUse.value.store,
   state => state.isSubmitting,

package/src/components/OmegaForm/index.ts

@@ -2,28 +2,11 @@ import { defineCustomElement } from "vue"
 import { default as OmegaForm } from "./OmegaWrapper.vue"
 import { default as OmegaInput } from "./OmegaInput.vue"
 import { default as OmegaErrors } from "./OmegaErrors.vue"
+import { default as OmegaAutoGen } from "./OmegaAutoGen.vue"
 
 export * as OmegaErrorsContext from "./OmegaErrorsContext"
 export * from "./OmegaFormStuff"
 export { useOmegaForm } from "./useOmegaForm"
 export { default } from "./OmegaWrapper.vue"
 
-export { OmegaForm, OmegaInput, OmegaErrors }
-
-const OmegaFormCE = defineCustomElement(OmegaForm as any)
-const OmegaInputCE = defineCustomElement(OmegaInput as any)
-const OmegaErrorsCE = defineCustomElement(OmegaErrors as any)
-
-export { OmegaFormCE, OmegaInputCE, OmegaErrorsCE }
-
-export function registerOmegaForm() {
-  if (!customElements.get("omega-form")) {
-    customElements.define("omega-form", OmegaFormCE)
-  }
-  if (!customElements.get("omega-input")) {
-    customElements.define("omega-input", OmegaInputCE)
-  }
-  if (!customElements.get("omega-errors")) {
-    customElements.define("omega-errors", OmegaErrorsCE)
-  }
-}
+export { OmegaForm, OmegaInput, OmegaErrors, OmegaAutoGen }

package/src/components/OmegaForm/useOmegaForm.ts

@@ -57,7 +57,7 @@ export const OmegaFormKey = Symbol("OmegaForm") as InjectionKey<OF<any, any>>
 
 export interface OmegaFormReturn<To extends Record<PropertyKey, any>, From>
   extends OF<To, From> {
-  Input: typeof OmegaFormInput<From, To>
+  Input: typeof OmegaFormInput
 }
 
 export const useOmegaForm = <

package/src/env.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="vite/client" />
-
-declare module "*.vue" {
-  import { DefineComponent } from "vue"
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types
-  const component: DefineComponent<{}, {}, any>
-  export default component
-}