@effect-app/vue-components 2.9.2 → 2.10.2

package/src/components/OmegaForm/OmegaTaggedUnionInternal.vue

@@ -12,10 +12,7 @@
   generic="From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
 import { type DeepKeys, type DeepValue } from "@tanstack/vue-form"
-import { S } from "effect-app"
 import { watch } from "vue"
-import { getTransformationFrom } from "../../utils"
-import { extractSchemaDefaults } from "./defaultAST"
 import { type OmegaFieldInternalApi } from "./InputProps"
 import { type useOmegaForm } from "./useOmegaForm"
 
@@ -35,51 +32,6 @@ watch(() => props.state, (newTag, oldTag) => {
   }
 
   if (newTag !== oldTag) {
-    // get default values from AST for the new tag (only for root level tagged unions)
-    if (props.name === void 0 && S.AST.isUnion(props.form._schema.ast)) {
-      const indexOfSelectedMember = props
-        .form
-        ._schema
-        .ast
-        .types
-        .map((t, i) => ({ original: i, unwrapped: getTransformationFrom(t) }))
-        .flatMap((x) =>
-          S.AST.isTypeLiteral(x.unwrapped) || S.AST.isTransformation(x.unwrapped)
-            ? x
-                .unwrapped
-                .propertySignatures
-                .filter((ps) => S.AST.isLiteral(ps.type) && ps.type.literal === newTag)
-                .length > 0
-              ? [x.original]
-              : []
-            : []
-        )[0]
-
-      // even if the type doesn't say so, indexOfSelectedMember may be undefined
-      if (
-        indexOfSelectedMember != void 0
-        && "members" in props.form._schema
-        && Array.isArray(props.form._schema.members)
-      ) {
-        const defaultsOfSelectedMember = Object.assign(
-          extractSchemaDefaults(
-            props
-              .form
-              ._schema
-              .members[indexOfSelectedMember],
-            values.value
-          ),
-          { _tag: newTag }
-        )
-
-        props.form.reset(defaultsOfSelectedMember)
-        setTimeout(() => {
-          props.field.validate("change")
-        }, 0)
-        return
-      }
-    }
-
     props.form.reset(values.value)
     setTimeout(() => {
       props.field.validate("change")

package/src/components/OmegaForm/useOmegaForm.ts

@@ -4,14 +4,13 @@
 import * as api from "@opentelemetry/api"
 import { type DeepKeys, DeepValue, type FormAsyncValidateOrFn, type FormValidateOrFn, type StandardSchemaV1, StandardSchemaV1Issue, useForm, ValidationError, ValidationErrorMap } from "@tanstack/vue-form"
 import { Array, Data, Effect, Fiber, Option, Order, S } from "effect-app"
-import { runtimeFiberAsPromise } from "effect-app/utils"
+import { runtimeFiberAsPromise, UnionToTuples } from "effect-app/utils"
 import { Component, computed, ComputedRef, ConcreteComponent, h, type InjectionKey, onBeforeUnmount, onMounted, onUnmounted, Ref, ref, watch } from "vue"
-import { deepMerge, extractSchemaDefaults } from "./defaultAST"
 import { MergedInputProps } from "./InputProps"
 import OmegaArray from "./OmegaArray.vue"
 import OmegaAutoGen from "./OmegaAutoGen.vue"
 import OmegaErrorsInternal from "./OmegaErrorsInternal.vue"
-import { BaseProps, DefaultTypeProps, FieldPath, type FormProps, generateMetaFromSchema, type MetaRecord, type NestedKeyOf, OmegaArrayProps, OmegaAutoGenMeta, OmegaError, type OmegaFormApi, OmegaFormState } from "./OmegaFormStuff"
+import { BaseProps, deepMerge, defaultsValueFromSchema, DefaultTypeProps, FieldPath, type FormProps, generateMetaFromSchema, type MetaRecord, type NestedKeyOf, OmegaArrayProps, OmegaAutoGenMeta, OmegaError, type OmegaFormApi, OmegaFormState } from "./OmegaFormStuff"
 import OmegaInput from "./OmegaInput.vue"
 import OmegaTaggedUnion from "./OmegaTaggedUnion.vue"
 import OmegaForm from "./OmegaWrapper.vue"
@@ -148,6 +147,13 @@ const eHoc = (errorProps: {
   }
 }
 
+export type Policies = "local" | "session" | "querystring"
+export type defaultValuesPriorityUnion = "tanstack" | "persistency" | "schema"
+
+const includesPolicy = (arr: Policies[], policy: Policies) => {
+  return arr.includes(policy)
+}
+
 export type OmegaConfig<T> = {
   i18nNamespace?: string
 
@@ -156,8 +162,8 @@ export type OmegaConfig<T> = {
      * - "querystring": Highest priority when persisting
      * - "local" and then "session": Lower priority storage options
      */
-    policies?: ("local" | "session" | "querystring")[]
-    overrideDefaultValues?: boolean
+    policies?: UnionToTuples<Policies>
+    overrideDefaultValues?: "deprecated: use defaultValuesPriority"
     id?: string
   } & keysRule<T>
 
@@ -174,6 +180,16 @@ export type OmegaConfig<T> = {
   preventWindowExit?: "prevent" | "prevent-and-reset" | "nope"
 
   input?: any
+
+  /**
+   * Default values order is: Tanstack default values passed as second parameter to useOmegaForm, then persistency
+   * default values from querystring or local/session storage, then defaults from schema
+   * You can customize the order and  with omegaConfig.defaultValuesPriority
+   * default value = ['tanstack', 'persistency', 'schema']
+   */
+  defaultValuesPriority?: UnionToTuples<defaultValuesPriorityUnion>
+
+  defaultFromSchema?: "deprecated: use defaultValuesPriority"
 }
 
 export interface OF<From, To> extends OmegaFormApi<From, To> {
@@ -664,18 +680,18 @@ export const useOmegaForm = <
 
   const defaultValues = computed(() => {
     // will contain what we get from querystring or local/session storage
-    let defValuesPatch
+    let persistencyDefaultValues
 
     const persistency = omegaConfig?.persistency
 
     if (
       // query string has higher priority than local/session storage
       persistency?.policies
-      && !defValuesPatch
-      && (persistency.policies.includes("local")
-        || persistency.policies.includes("session"))
+      && !persistencyDefaultValues
+      && (includesPolicy(persistency.policies, "local")
+        || includesPolicy(persistency.policies, "session"))
     ) {
-      const storage = persistency.policies.includes("local")
+      const storage = includesPolicy(persistency.policies, "local")
         ? localStorage
         : sessionStorage
       if (storage) {
@@ -684,19 +700,19 @@ export const useOmegaForm = <
             storage.getItem(persistencyKey.value) || "{}"
           )
           storage.removeItem(persistencyKey.value)
-          defValuesPatch = value
+          persistencyDefaultValues = value
         } catch (error) {
           console.error(error)
         }
       }
     }
-    if (persistency?.policies && persistency.policies.includes("querystring")) {
+    if (persistency?.policies && includesPolicy(persistency.policies, "querystring")) {
       try {
         const params = new URLSearchParams(window.location.search)
         const value = params.get(persistencyKey.value)
         clearUrlParams()
         if (value) {
-          defValuesPatch = deepMerge(defValuesPatch || {}, JSON.parse(value))
+          persistencyDefaultValues = deepMerge(persistencyDefaultValues || {}, JSON.parse(value))
         }
       } catch (error) {
         console.error(error)
@@ -704,14 +720,22 @@ export const useOmegaForm = <
     }
 
     // to be sure we have a valid object at the end of the gathering process
-    defValuesPatch ??= {}
-
-    // we just return what we gathered from the query/storage
-    return extractSchemaDefaults(
-      schema,
-      omegaConfig?.persistency?.overrideDefaultValues
-        ? deepMerge(tanstackFormOptions?.defaultValues || {}, defValuesPatch)
-        : deepMerge(defValuesPatch, tanstackFormOptions?.defaultValues || {})
+    persistencyDefaultValues ??= {}
+
+    const defaults: Record<defaultValuesPriorityUnion, any> = {
+      tanstack: tanstackFormOptions?.defaultValues || {},
+      persistency: persistencyDefaultValues,
+      schema: defaultsValueFromSchema(schema)
+    }
+
+    return (omegaConfig?.defaultValuesPriority || ["tanstack", "persistency", "schema"] as const).reverse().reduce(
+      (acc, m) => {
+        if (!Object.keys(acc).length) {
+          return defaults[m]
+        }
+        return deepMerge(acc, defaults[m])
+      },
+      {}
     )
   })
 
@@ -805,10 +829,10 @@ export const useOmegaForm = <
       return
     }
     if (
-      persistency.policies.includes("local")
-      || persistency.policies.includes("session")
+      includesPolicy(persistency.policies, "local")
+      || includesPolicy(persistency.policies, "session")
     ) {
-      const storage = persistency.policies.includes("local")
+      const storage = includesPolicy(persistency.policies, "local")
         ? localStorage
         : sessionStorage
       if (!storage) return
@@ -822,7 +846,7 @@ export const useOmegaForm = <
     if (!persistency?.policies || persistency.policies.length === 0) {
       return
     }
-    if (persistency.policies.includes("querystring")) {
+    if (includesPolicy(persistency.policies, "querystring")) {
       const values = persistFilter(persistency)
       const searchParams = new URLSearchParams(window.location.search)
       searchParams.set(persistencyKey.value, JSON.stringify(values))

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

@@ -1,4 +0,0 @@
-import { S } from "effect-app";
-export declare function deepMerge(target: any, source: any): any;
-export declare const extractDefaultsFromAST: (schemaObj: any) => any;
-export declare const extractSchemaDefaults: <From, To>(schema: S.Schema<To, From, never>, defaultValues?: Partial<From>) => any;

package/dist/vue-components.es34.js

@@ -1,113 +0,0 @@
-import { defineComponent as _, getCurrentInstance as B, computed as V, createBlock as i, openBlock as e, Transition as x, withCtx as u, createElementBlock as o, createCommentVNode as p, renderSlot as g, normalizeProps as b, guardReactiveProps as I, resolveDynamicComponent as h, unref as d, normalizeClass as v, createElementVNode as n, toDisplayString as a, Fragment as w, renderList as y, createTextVNode as C } from "vue";
-import { useIntl as L } from "./vue-components.es3.js";
-const M = {
-  key: 0,
-  class: "error-alert"
-}, j = { class: "container" }, D = {
-  key: 0,
-  viewBox: "0 0 24 24",
-  fill: "none",
-  xmlns: "http://www.w3.org/2000/svg"
-}, N = { class: "text-h6" }, z = {
-  key: 0,
-  class: "error-list"
-}, G = ["for"], H = { key: 1 }, T = /* @__PURE__ */ _({
-  __name: "OmegaErrorsInternal",
-  props: {
-    generalErrors: {},
-    errors: {},
-    hideErrorDetails: { type: Boolean }
-  },
-  setup(l) {
-    const c = B()?.appContext.components.VAlert, k = l, { trans: E } = L(), m = V(() => k.generalErrors ? k.generalErrors.filter((s) => !!s).flatMap(
-      (s) => Object.values(s).filter((t) => !!t).flatMap(
-        (t) => t.filter(
-          (r) => !!r?.message
-        ).map((r) => r.message)
-      )
-    ) : []);
-    return (s, t) => (e(), i(x, null, {
-      default: u(() => [
-        l.errors.length || m.value.length ? (e(), o("div", M, [
-          g(s.$slots, "default", b(I({ errors: l.errors, showedGeneralErrors: m.value })), () => [
-            (e(), i(h(d(c) ? "v-alert" : "div"), {
-              class: v([d(c) ? "mb-4" : "error-alert-content", "mb-4"]),
-              type: "error",
-              variant: "tonal",
-              role: "alert",
-              "aria-live": "polite"
-            }, {
-              default: u(() => [
-                n("div", j, [
-                  g(s.$slots, "icon", {}, () => [
-                    d(c) ? p("", !0) : (e(), o("svg", D, [...t[0] || (t[0] = [
-                      n("path", {
-                        d: "M16 2H8L2 8V16L8 22H16L22 16V8L16 2Z",
-                        stroke: "currentColor",
-                        "stroke-width": "2",
-                        "stroke-linecap": "round",
-                        "stroke-linejoin": "round"
-                      }, null, -1),
-                      n("path", {
-                        d: "M12 8V12",
-                        stroke: "currentColor",
-                        "stroke-width": "2",
-                        "stroke-linecap": "round",
-                        "stroke-linejoin": "round"
-                      }, null, -1),
-                      n("path", {
-                        d: "M12 16.0195V16",
-                        stroke: "currentColor",
-                        "stroke-width": "2",
-                        "stroke-linecap": "round",
-                        "stroke-linejoin": "round"
-                      }, null, -1)
-                    ])]))
-                  ], !0),
-                  n("div", null, [
-                    n("div", N, a(d(E)("form.includes_error")) + ": ", 1),
-                    l.errors.length ? (e(), o("ul", z, [
-                      (e(!0), o(w, null, y(l.errors, (r) => (e(), o("li", {
-                        key: r.inputId,
-                        class: "error-item"
-                      }, [
-                        n("div", null, [
-                          n("label", {
-                            for: r.inputId,
-                            class: "error-link"
-                          }, a(r.label), 9, G),
-                          t[1] || (t[1] = C(" " + a(" ") + " ", -1)),
-                          l.hideErrorDetails ? p("", !0) : (e(), o("div", {
-                            key: 0,
-                            class: v(["error-message", r.errors.length < 2 && "single-error"])
-                          }, [
-                            (e(), i(h(r.errors.length > 1 ? "ul" : "div"), { class: "error-list" }, {
-                              default: u(() => [
-                                (e(!0), o(w, null, y(r.errors, (f) => (e(), i(h(r.errors.length > 1 ? "li" : "span"), { key: f }, {
-                                  default: u(() => [
-                                    C(a(f), 1)
-                                  ]),
-                                  _: 2
-                                }, 1024))), 128))
-                              ]),
-                              _: 2
-                            }, 1024))
-                          ], 2))
-                        ])
-                      ]))), 128))
-                    ])) : (e(), o("span", H, a(m.value[0]), 1))
-                  ])
-                ])
-              ]),
-              _: 3
-            }, 8, ["class"]))
-          ], !0)
-        ])) : p("", !0)
-      ]),
-      _: 3
-    }));
-  }
-});
-export {
-  T as default
-};

package/dist/vue-components.es37.js

@@ -1,34 +0,0 @@
-import { defineComponent as m, createElementBlock as d, openBlock as u, withModifiers as f, createElementVNode as l, unref as s, renderSlot as a } from "vue";
-import { useStore as b } from "@tanstack/vue-form";
-import { usePreventClose as p } from "./vue-components.es11.js";
-import { getOmegaStore as c } from "./vue-components.es54.js";
-const S = ["disabled"], V = /* @__PURE__ */ m({
-  __name: "OmegaWrapper",
-  props: {
-    form: {},
-    disabled: { type: Boolean },
-    subscribe: {}
-  },
-  setup(o) {
-    const e = o, i = b(
-      e.form.store,
-      (t) => t.isSubmitting
-    ), n = c(
-      e.form,
-      e.subscribe
-    );
-    return e.form.ignorePreventCloseEvents || p(() => e.form.useStore((t) => t.isDirty)), (t, r) => (u(), d("form", {
-      novalidate: "",
-      onSubmit: r[0] || (r[0] = f((v) => o.form.handleSubmit(), ["prevent", "stop"]))
-    }, [
-      l("fieldset", {
-        disabled: s(i) || o.disabled
-      }, [
-        a(t.$slots, "default", { subscribedValues: s(n) }, void 0, !0)
-      ], 8, S)
-    ], 32));
-  }
-});
-export {
-  V as default
-};

package/dist/vue-components.es63.js

@@ -1,4 +0,0 @@
-var o = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {};
-export {
-  o as _globalThis
-};

package/src/components/OmegaForm/defaultAST.ts

@@ -1,191 +0,0 @@
-import { isObject } from "@vueuse/core"
-import { S } from "effect-app"
-import { isNullableOrUndefined } from "./OmegaFormStuff"
-
-export function deepMerge(target: any, source: any) {
-  for (const key in source) {
-    if (Array.isArray(source[key])) {
-      // Arrays should be copied directly, not deep merged
-      target[key] = source[key]
-    } else if (source[key] && isObject(source[key])) {
-      if (!target[key]) {
-        target[key] = {}
-      }
-      deepMerge(target[key], source[key])
-    } else {
-      target[key] = source[key]
-    }
-  }
-  return target
-}
-
-/**
- * Recursively makes all properties in a schema optional, including nested objects.
- * Unlike S.partial which only makes top-level properties optional, this utility
- * traverses the schema tree and applies partial transformation at every level.
- *
- * Handles:
- * - TypeLiteral (structs): Makes all properties optional and recursively processes nested types
- * - Union types: Recursively applies partial to each union member
- * - Transformation types: Applies partial to both 'from' and 'to' sides
- */
-const partialRecursive = <A, I, R>(schema: S.Schema<A, I, R>): S.Schema<Partial<A>, Partial<I>, R> => {
-  const ast = schema.ast
-
-  // Handle Refinement types (e.g., NonEmptyArray, filters on ExtendedClass)
-  if (ast._tag === "Refinement") {
-    const refinementAst = ast as any
-    // For refinements, bypass the filter and recursively apply partial to the underlying type
-    const fromSchema = S.make(refinementAst.from)
-    return partialRecursive(fromSchema as any)
-  }
-
-  // Handle Union types - recursively apply partial to each member
-  if (ast._tag === "Union") {
-    const partialMembers = (ast as any).types.map((memberAst: any) => {
-      const memberSchema = S.make(memberAst)
-      const partialMember = partialRecursive(memberSchema as any)
-      return partialMember.ast
-    })
-
-    const newAst = {
-      ...ast,
-      types: partialMembers
-    }
-
-    return S.make(newAst as any)
-  }
-
-  // Handle Transformation types (e.g., withDefaultConstructor, ExtendedClass)
-  if (ast._tag === "Transformation") {
-    const transformAst = ast as any
-
-    // Special handling for ExtendedClass (Declaration in 'to' side)
-    if (transformAst.to._tag === "Declaration") {
-      // For ExtendedClass, extract the TypeLiteral from the 'from' side
-      // and make that partial, bypassing the Declaration entirely
-      const fromSchema = S.make(transformAst.from)
-      return partialRecursive(fromSchema as any)
-    }
-
-    // For other transformations, apply partial to both sides
-    const fromSchema = S.make(transformAst.from)
-    const toSchema = S.make(transformAst.to)
-    const partialFrom = partialRecursive(fromSchema as any)
-    const partialTo = partialRecursive(toSchema as any)
-
-    const newAst = {
-      ...ast,
-      from: partialFrom.ast,
-      to: partialTo.ast
-    }
-
-    return S.make(newAst as any)
-  }
-
-  // If this is a TypeLiteral (struct), recursively apply partial to nested fields
-  if (ast._tag === "TypeLiteral") {
-    const fields = ast.propertySignatures.map((prop: any) => {
-      const propType = prop.type
-      let newType = propType
-
-      // Recursively handle nested complex types (structs, unions, transformations, refinements)
-      if (
-        propType._tag === "TypeLiteral" || propType._tag === "Union" || propType
-            ._tag === "Transformation" || propType
-            ._tag === "Refinement"
-      ) {
-        const nestedSchema = S.make(propType)
-        const recursivePartial = partialRecursive(nestedSchema as any)
-        newType = recursivePartial.ast
-      }
-
-      // Create a new property signature with isOptional: true
-      return {
-        ...prop,
-        type: newType,
-        isOptional: true
-      }
-    })
-
-    const newAst = {
-      ...ast,
-      propertySignatures: fields
-    }
-
-    return S.make(newAst as any)
-  }
-
-  // For other schema types (primitives, refinements, etc.), return as-is
-  // These types don't need to be made partial, and S.partial doesn't support them anyway
-  return schema as any
-}
-
-// Helper function to recursively extract default values from schema AST swag ast
-export const extractDefaultsFromAST = (schemaObj: any): any => {
-  const result: Record<string, any> = {}
-
-  // Check if this schema has fields (struct)
-  if (schemaObj?.fields && typeof schemaObj.fields === "object") {
-    for (const [key, fieldSchema] of Object.entries(schemaObj.fields)) {
-      // Check if this field has a default value in its AST
-      if ((fieldSchema as any)?.ast?.defaultValue) {
-        try {
-          const defaultValue = (fieldSchema as any).ast.defaultValue()
-          result[key] = defaultValue
-        } catch {
-          // Silently ignore if defaultValue() throws
-        }
-      } else {
-        // TODO Should we put to null/undefined only leaves?
-        const ast = (fieldSchema as any)?.ast
-        const nullableOrUndefined = isNullableOrUndefined(ast)
-        switch (nullableOrUndefined) {
-          case "null":
-            result[key] = null
-            break
-          case "undefined":
-            result[key] = undefined
-            break
-        }
-      }
-
-      // Recursively check nested fields for structs and unions
-      const nestedDefaults = extractDefaultsFromAST(fieldSchema as any)
-      if (Object.keys(nestedDefaults).length > 0) {
-        // If we already have a default value for this key, merge with nested
-        if (result[key] && typeof result[key] === "object") {
-          Object.assign(result[key], nestedDefaults)
-        } else if (!result[key]) {
-          // Only set nested defaults if we don't have a default value
-          result[key] = nestedDefaults
-        }
-      }
-    }
-  } else {
-    if (schemaObj?.from?.fields && typeof schemaObj?.from?.fields === "object") {
-      return extractDefaultsFromAST(schemaObj.from)
-    }
-  }
-
-  return result
-}
-
-// Extract default values from schema constructors (e.g., withDefaultConstructor) swag schema defaults
-export const extractSchemaDefaults = <From, To>(
-  schema: S.Schema<To, From, never>,
-  defaultValues: Partial<From> = {}
-) => {
-  let result: Partial<From> = {}
-
-  try {
-    const astDefaults = extractDefaultsFromAST(schema)
-    result = S.encodeSync(partialRecursive(schema))(astDefaults)
-  } catch (astError) {
-    if (window.location.hostname === "localhost") {
-      console.warn("Could not extract defaults from AST:", astError)
-    }
-  }
-
-  return deepMerge(result, defaultValues)
-}