@effect-app/vue-components 0.7.2 → 0.7.4

package/dist/types/components/OmegaForm/OmegaArray.vue.d.ts

@@ -1,6 +1,9 @@
 import { type OmegaInputProps } from "./OmegaFormStuff";
-declare const _default: <From, To>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Omit<OmegaInputProps<From, To>, "type" | "validators" | "label" | "options"> & Partial<{}>> & import("vue").PublicProps;
+import { type DeepValue, type DeepKeys } from "@tanstack/vue-form";
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & (Omit<OmegaInputProps<T, T>, "type" | "validators" | "items" | "label" | "options"> & {
+        items?: DeepValue<T, DeepKeys<T>>;
+    }) & Partial<{}>> & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {

package/dist/types/components/OmegaForm/OmegaFormStuff.d.ts

@@ -85,7 +85,7 @@ export type FilterItems = {
         readonly message: string | Effect.Effect<string>;
     };
 };
-type CreateMeta = {
+export type CreateMeta = {
     parent?: string;
     meta?: Record<string, any>;
     nullableOrUndefined?: false | "undefined" | "null";
@@ -107,4 +107,3 @@ export declare const generateInputStandardSchemaFromFieldMeta: (meta: FieldMeta)
 export declare const nullableInput: <A, I, R>(schema: S.Schema<A, I, R>, defaultValue: () => A) => S.transform<import("effect/Schema").NullOr<S.Schema<A, I, R>> & {
     withDefault: S.PropertySignature<":", A | null, never, ":", I | null, true, R>;
 }, S.SchemaClass<A, A, never>>;
-export {};

package/dist/vue-components.es6.js

@@ -1,52 +1,67 @@
-import { defineComponent as c, computed as g, provide as M, createBlock as m, openBlock as s, resolveDynamicComponent as u, withCtx as i, createElementBlock as _, renderSlot as l, Fragment as h, renderList as k, mergeProps as v, normalizeProps as F, guardReactiveProps as S } from "vue";
-import { createMeta as A } from "./vue-components.es9.js";
-const C = /* @__PURE__ */ c({
+import { defineComponent as c, onMounted as g, watch as M, computed as F, provide as h, createBlock as p, openBlock as m, resolveDynamicComponent as i, withCtx as l, createElementBlock as _, renderSlot as u, Fragment as k, renderList as v, mergeProps as A, normalizeProps as S, guardReactiveProps as $ } from "vue";
+import { createMeta as B } from "./vue-components.es9.js";
+const w = /* @__PURE__ */ c({
   inheritAttrs: !1,
   __name: "OmegaArray",
   props: {
     form: {},
-    name: {}
+    name: {},
+    items: {}
   },
   setup(f) {
-    const p = f, d = g(() => {
-      const e = p.form.meta[p.name];
+    const r = f;
+    g(() => {
+      r.items && r.form.setFieldValue(r.name, r.items);
+    }), M(
+      () => r.items,
+      async (e) => {
+        e && r.form.setFieldValue(r.name, e);
+      }
+    );
+    const d = F(() => {
+      const e = r.form.meta[r.name];
       if (e && e.type === "multiple") {
-        const n = e.rest.reduce(
-          (t, r) => (r.type._tag === "TypeLiteral" && t.propertySignatures.push(...r.type.propertySignatures), t),
-          {
-            propertySignatures: []
-          }
-        ), a = A(n);
+        const o = e.rest.reduce((t, a) => a.type._tag === "TypeLiteral" ? {
+          ...t,
+          propertySignatures: [
+            ...t.propertySignatures || [],
+            ...a.type.propertySignatures
+          ]
+        } : {
+          ...t,
+          property: a.type
+        }, {}), n = B({ ...o, meta: e });
         return (t) => {
-          const r = t.split("]."), o = r[r.length - 1];
-          return a[o];
+          if (t.endsWith("]")) return n;
+          const a = t.split("]."), s = a[a.length - 1];
+          return n[s];
         };
       }
-      return (n) => {
+      return (o) => {
       };
     });
-    return M("getMetaFromArray", d), (e, n) => (s(), m(u(e.form.Field), { name: e.name }, {
-      default: i(({ field: a }) => [
-        (s(!0), _(h, null, k(a.state.value, (y, t) => (s(), m(u(e.form.Field), {
+    return h("getMetaFromArray", d), (e, o) => (m(), p(i(e.form.Field), { name: e.name }, {
+      default: l(({ field: n }) => [
+        (m(!0), _(k, null, v(n.state.value, (y, t) => (m(), p(i(e.form.Field), {
           key: t,
           name: `${e.name}[${t}]`
         }, {
-          default: i(({ field: r, state: o }) => [
-            l(e.$slots, "default", v({ ref_for: !0 }, {
-              field: a,
-              subField: r,
-              subState: o,
+          default: l(({ field: a, state: s }) => [
+            u(e.$slots, "default", A({ ref_for: !0 }, {
+              field: n,
+              subField: a,
+              subState: s,
               index: t
             }))
           ]),
           _: 2
         }, 1032, ["name"]))), 128)),
-        l(e.$slots, "field", F(S({ field: a })))
+        u(e.$slots, "field", S($({ field: n })))
       ]),
       _: 3
     }, 8, ["name"]));
   }
 });
 export {
-  C as default
+  w as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "@tanstack/vue-form": "^1.2.4",

package/src/components/OmegaForm/OmegaArray.vue

@@ -23,37 +23,65 @@
   </component>
 </template>
 
-<script setup lang="ts" generic="From, To">
-import { computed, provide } from "vue"
-import { type OmegaInputProps, createMeta } from "./OmegaFormStuff"
-import { type S } from "effect-app"
+<script setup lang="ts" generic="T">
+import { computed, onMounted, provide, watch } from "vue"
+import {
+  type CreateMeta,
+  type OmegaInputProps,
+  createMeta,
+} from "./OmegaFormStuff"
+import { type DeepValue, type DeepKeys } from "@tanstack/vue-form"
 
-const props =
-  defineProps<
-    Omit<OmegaInputProps<From, To>, "validators" | "options" | "label" | "type">
-  >()
+const props = defineProps<
+  Omit<
+    OmegaInputProps<T, T>,
+    "validators" | "options" | "label" | "type" | "items"
+  > & {
+    items?: DeepValue<T, DeepKeys<T>>
+  }
+>()
 
 defineOptions({
   inheritAttrs: false,
 })
 
+onMounted(() => {
+  if (props.items) {
+    props.form.setFieldValue(props.name, props.items)
+  }
+})
+
+watch(
+  () => props.items,
+  async items => {
+    if (items) {
+      props.form.setFieldValue(props.name, items)
+    }
+  },
+)
+
 const getMetaFromArray = computed(() => {
   const inputMeta = props.form.meta[props.name]
   if (inputMeta && inputMeta.type === "multiple") {
-    const propertySignatures = inputMeta.rest.reduce(
-      (acc, curr) => {
-        if (curr.type._tag === "TypeLiteral") {
-          acc.propertySignatures.push(...curr.type.propertySignatures)
-        }
-        return acc
-      },
-      {
-        propertySignatures: [],
-      } as { propertySignatures: S.AST.PropertySignature[] },
-    )
+    const result = inputMeta.rest.reduce<CreateMeta>((acc, curr) => {
+      if (curr.type._tag === "TypeLiteral") {
+        return {
+          ...acc,
+          propertySignatures: [
+            ...(acc.propertySignatures || []),
+            ...curr.type.propertySignatures,
+          ],
+        } as CreateMeta
+      }
+      return {
+        ...acc,
+        property: curr.type,
+      } as CreateMeta
+    }, {} as CreateMeta)
 
-    const arrayMeta = createMeta(propertySignatures)
+    const arrayMeta = createMeta({ ...result, meta: inputMeta })
     const getMeta = (index: string) => {
+      if (index.endsWith("]")) return arrayMeta
       const parts = index.split("].")
       const key = parts[parts.length - 1]
       return arrayMeta[key as keyof typeof arrayMeta]

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -201,7 +201,7 @@ export type FilterItems = {
     | { readonly message: string | Effect.Effect<string> }
 }
 
-type CreateMeta = {
+export type CreateMeta = {
   parent?: string
   meta?: Record<string, any>
   nullableOrUndefined?: false | "undefined" | "null"