@effect-app/vue-components 2.9.2 → 2.10.0

package/dist/vue-components.es61.js

@@ -1,4 +1,46 @@
-var r = "1.9.0";
+import { VERSION as d } from "./vue-components.es60.js";
+var h = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function s(c) {
+  var m = /* @__PURE__ */ new Set([c]), f = /* @__PURE__ */ new Set(), t = c.match(h);
+  if (!t)
+    return function() {
+      return !1;
+    };
+  var e = {
+    major: +t[1],
+    minor: +t[2],
+    patch: +t[3],
+    prerelease: t[4]
+  };
+  if (e.prerelease != null)
+    return function(r) {
+      return r === c;
+    };
+  function a(n) {
+    return f.add(n), !1;
+  }
+  function p(n) {
+    return m.add(n), !0;
+  }
+  return function(r) {
+    if (m.has(r))
+      return !0;
+    if (f.has(r))
+      return !1;
+    var i = r.match(h);
+    if (!i)
+      return a(r);
+    var u = {
+      major: +i[1],
+      minor: +i[2],
+      patch: +i[3],
+      prerelease: i[4]
+    };
+    return u.prerelease != null || e.major !== u.major ? a(r) : e.major === 0 ? e.minor === u.minor && e.patch <= u.patch ? p(r) : a(r) : e.minor <= u.minor ? p(r) : a(r);
+  };
+}
+var v = s(d);
 export {
-  r as VERSION
+  s as _makeCompatibilityCheck,
+  v as isCompatible
 };

package/dist/vue-components.es62.js

@@ -1,46 +1,4 @@
-import { VERSION as d } from "./vue-components.es61.js";
-var h = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
-function s(c) {
-  var m = /* @__PURE__ */ new Set([c]), f = /* @__PURE__ */ new Set(), t = c.match(h);
-  if (!t)
-    return function() {
-      return !1;
-    };
-  var e = {
-    major: +t[1],
-    minor: +t[2],
-    patch: +t[3],
-    prerelease: t[4]
-  };
-  if (e.prerelease != null)
-    return function(r) {
-      return r === c;
-    };
-  function a(n) {
-    return f.add(n), !1;
-  }
-  function p(n) {
-    return m.add(n), !0;
-  }
-  return function(r) {
-    if (m.has(r))
-      return !0;
-    if (f.has(r))
-      return !1;
-    var i = r.match(h);
-    if (!i)
-      return a(r);
-    var u = {
-      major: +i[1],
-      minor: +i[2],
-      patch: +i[3],
-      prerelease: i[4]
-    };
-    return u.prerelease != null || e.major !== u.major ? a(r) : e.major === 0 ? e.minor === u.minor && e.patch <= u.patch ? p(r) : a(r) : e.minor <= u.minor ? p(r) : a(r);
-  };
-}
-var v = s(d);
+var o = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {};
 export {
-  s as _makeCompatibilityCheck,
-  v as isCompatible
+  o as _globalThis
 };

package/dist/vue-components.es7.js

@@ -1,7 +1,7 @@
 (function(){"use strict";try{if(typeof document<"u"){var i=document.createElement("style");if(i.appendChild(document.createTextNode(".omega-input .v-input__details:has(.v-messages:empty){grid-template-rows:0fr;transition:all .2s}.omega-input .v-messages:empty{min-height:0}.omega-input .v-input__details:has(.v-messages){transition:all .2s;overflow:hidden;min-height:0;display:grid;grid-template-rows:1fr}.omega-input .v-messages{transition:all .2s}.omega-input .v-messages>*{transition-duration:0s!important}.omega-input [role=alert]:has(.v-messages:empty){padding:0}.omega-input .v-btn{cursor:pointer;width:auto;appearance:none;box-shadow:none;display:block;min-width:auto;height:auto;padding:.5em .5em .5em 1em}")),document.head.appendChild(i),window.customElements){const e=window.customElements.define;window.customElements.define=function(s,t){const n=t.prototype.connectedCallback;return t.prototype.connectedCallback=function(){if(n&&n.call(this),this.shadowRoot){const a=document.createElement("style");a.appendChild(document.createTextNode(".omega-input .v-input__details:has(.v-messages:empty){grid-template-rows:0fr;transition:all .2s}.omega-input .v-messages:empty{min-height:0}.omega-input .v-input__details:has(.v-messages){transition:all .2s;overflow:hidden;min-height:0;display:grid;grid-template-rows:1fr}.omega-input .v-messages{transition:all .2s}.omega-input .v-messages>*{transition-duration:0s!important}.omega-input [role=alert]:has(.v-messages:empty){padding:0}.omega-input .v-btn{cursor:pointer;width:auto;appearance:none;box-shadow:none;display:block;min-width:auto;height:auto;padding:.5em .5em .5em 1em}")),this.shadowRoot.appendChild(a)}},e.call(window.customElements,s,t)}}}}catch(e){console.error("vite-plugin-css-injected-by-js",e)}})();
 import { defineComponent as $, computed as n, getCurrentInstance as N, useAttrs as S, useSlots as k, useId as q, renderSlot as u, normalizeProps as s, guardReactiveProps as d, createElementVNode as B, normalizeClass as w, createBlock as I, createCommentVNode as L, unref as A, openBlock as F, mergeProps as O, createSlots as R, withCtx as V } from "vue";
 import { useStore as z } from "@tanstack/vue-form";
-import T from "./vue-components.es39.js";
+import T from "./vue-components.es30.js";
 
 const H = /* @__PURE__ */ $({
   inheritAttrs: !1,

package/dist/vue-components.es9.js

@@ -1,8 +1,5 @@
-import { defineComponent as l, watch as f, renderSlot as d, createCommentVNode as u, normalizeProps as c, mergeProps as p } from "vue";
-import { S as i } from "effect-app";
-import { getTransformationFrom as h } from "./vue-components.es3.js";
-import { extractSchemaDefaults as S } from "./vue-components.es17.js";
-const b = /* @__PURE__ */ l({
+import { defineComponent as m, watch as r, renderSlot as s, createCommentVNode as o, normalizeProps as i, mergeProps as f } from "vue";
+const d = /* @__PURE__ */ m({
   __name: "OmegaTaggedUnionInternal",
   props: {
     state: {},
@@ -10,35 +7,15 @@ const b = /* @__PURE__ */ l({
     name: {},
     form: {}
   },
-  setup(r) {
-    const e = r, s = e.form.useStore(({ values: t }) => t);
-    return f(() => e.state, (t, o) => {
-      if (t === null && e.field.setValue(null), t !== o) {
-        if (e.name === void 0 && i.AST.isUnion(e.form._schema.ast)) {
-          const n = e.form._schema.ast.types.map((a, m) => ({ original: m, unwrapped: h(a) })).flatMap(
-            (a) => i.AST.isTypeLiteral(a.unwrapped) || i.AST.isTransformation(a.unwrapped) ? a.unwrapped.propertySignatures.filter((m) => i.AST.isLiteral(m.type) && m.type.literal === t).length > 0 ? [a.original] : [] : []
-          )[0];
-          if (n != null && "members" in e.form._schema && Array.isArray(e.form._schema.members)) {
-            const a = Object.assign(
-              S(
-                e.form._schema.members[n],
-                s.value
-              ),
-              { _tag: t }
-            );
-            e.form.reset(a), setTimeout(() => {
-              e.field.validate("change");
-            }, 0);
-            return;
-          }
-        }
-        e.form.reset(s.value), setTimeout(() => {
-          e.field.validate("change");
-        }, 0);
-      }
-    }, { immediate: !0 }), (t, o) => r.state ? d(t.$slots, `${r.name ? `${r.name}.` : ""}${r.state}`, c(p({ key: 0 }, { field: r.field, state: r.state }))) : u("", !0);
+  setup(e) {
+    const a = e, l = a.form.useStore(({ values: t }) => t);
+    return r(() => a.state, (t, n) => {
+      t === null && a.field.setValue(null), t !== n && (a.form.reset(l.value), setTimeout(() => {
+        a.field.validate("change");
+      }, 0));
+    }, { immediate: !0 }), (t, n) => e.state ? s(t.$slots, `${e.name ? `${e.name}.` : ""}${e.state}`, i(f({ key: 0 }, { field: e.field, state: e.state }))) : o("", !0);
   }
 });
 export {
-  b as default
+  d as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "2.9.2",
+  "version": "2.10.0",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "effect": "^3.19.3",

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -2,6 +2,7 @@ import { type Effect, Option, type Record, S } from "effect-app"
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { getMetadataFromSchema } from "@effect-app/vue/form"
 import { type DeepKeys, type DeepValue, type FieldAsyncValidateOrFn, type FieldValidateOrFn, type FormApi, type FormAsyncValidateOrFn, type FormOptions, type FormState, type FormValidateOrFn, type StandardSchemaV1, type VueFormApi } from "@tanstack/vue-form"
+import { isObject } from "@vueuse/core"
 import { type RuntimeFiber } from "effect/Fiber"
 import { getTransformationFrom, useIntl } from "../../utils"
 import { type OmegaFieldInternalApi } from "./InputProps"
@@ -685,14 +686,15 @@ export const createMeta = <T = any>(
   return acc
 }
 
-const flattenMeta = <From, To>(
+const metadataFromAst = <From, To>(
   schema: S.Schema<To, From, never>
-): MetaRecord<To> => {
+): { meta: MetaRecord<To>; defaultValues: Record<string, any> } => {
   const ast = schema.ast
-  const result: MetaRecord<To> = {}
+  const newMeta: MetaRecord<To> = {}
+  const defaultValues: Record<string, any> = {}
 
   if (ast._tag === "Transformation" || ast._tag === "Refinement") {
-    return flattenMeta(S.make(ast.from))
+    return metadataFromAst(S.make(ast.from))
   }
 
   // Handle root-level Union types (discriminated unions)
@@ -730,20 +732,20 @@ const flattenMeta = <From, To>(
           })
 
           // Merge into result
-          Object.assign(result, memberMeta)
+          Object.assign(newMeta, memberMeta)
         }
       }
 
       // Create metadata for the discriminator field
       if (discriminatorValues.length > 0) {
-        result["_tag" as DeepKeys<To>] = {
+        newMeta["_tag" as DeepKeys<To>] = {
           type: "select",
           members: discriminatorValues,
           required: true
         } as FieldMeta
       }
 
-      return result
+      return { meta: newMeta, defaultValues }
     }
   }
 
@@ -753,7 +755,7 @@ const flattenMeta = <From, To>(
     })
 
     if (Object.values(meta).every((value) => value && "type" in value)) {
-      return meta as MetaRecord<To>
+      return { meta: meta as MetaRecord<To>, defaultValues }
     }
 
     const flattenObject = (
@@ -763,7 +765,7 @@ const flattenMeta = <From, To>(
       for (const key in obj) {
         const newKey = parentKey ? `${parentKey}.${key}` : key
         if (obj[key] && typeof obj[key] === "object" && "type" in obj[key]) {
-          result[newKey as DeepKeys<To>] = obj[key] as FieldMeta
+          newMeta[newKey as DeepKeys<To>] = obj[key] as FieldMeta
         } else if (obj[key] && typeof obj[key] === "object") {
           flattenObject(obj[key], newKey)
         }
@@ -773,7 +775,7 @@ const flattenMeta = <From, To>(
     flattenObject(meta)
   }
 
-  return result
+  return { meta: newMeta, defaultValues }
 }
 
 export const duplicateSchema = <From, To>(
@@ -788,7 +790,7 @@ export const generateMetaFromSchema = <From, To>(
   schema: S.Schema<To, From, never>
   meta: MetaRecord<To>
 } => {
-  const meta = flattenMeta(schema)
+  const { meta } = metadataFromAst(schema)
 
   return { schema, meta }
 }
@@ -976,3 +978,164 @@ const supportedInputs = [
 export type SupportedInputs = typeof supportedInputs[number]
 export const getInputType = (input: string): SupportedInputs =>
   (supportedInputs as readonly string[]).includes(input) ? input as SupportedInputs : "text"
+
+export function deepMerge(target: any, source: any) {
+  const result = { ...target }
+  for (const key in source) {
+    if (Array.isArray(source[key])) {
+      // Arrays should be copied directly, not deep merged
+      result[key] = source[key]
+    } else if (source[key] && isObject(source[key])) {
+      result[key] = deepMerge(result[key], source[key])
+    } else {
+      result[key] = source[key]
+    }
+  }
+  return result
+}
+
+// Type definitions for schemas with fields and members
+type SchemaWithFields = {
+  fields: Record<string, S.Schema<any>>
+}
+
+type SchemaWithMembers = {
+  members: readonly S.Schema<any>[]
+}
+
+// Type guards to check schema types
+function hasFields(schema: any): schema is SchemaWithFields {
+  return schema && "fields" in schema && typeof schema.fields === "object"
+}
+
+function hasMembers(schema: any): schema is SchemaWithMembers {
+  return schema && "members" in schema && Array.isArray(schema.members)
+}
+
+// Internal implementation with WeakSet tracking
+export const defaultsValueFromSchema = (
+  schema: S.Schema<any>,
+  record: Record<string, any> = {}
+): any => {
+  const ast: any = schema.ast
+
+  if (ast?.defaultValue) {
+    return ast.defaultValue()
+  }
+
+  if (isNullableOrUndefined(schema.ast) === "null") {
+    return null
+  }
+  if (isNullableOrUndefined(schema.ast) === "undefined") {
+    return undefined
+  }
+
+  // Check if schema has fields directly
+  if (hasFields(schema)) {
+    // Process fields and extract default values
+    const result: Record<string, any> = {}
+
+    for (const [key, fieldSchema] of Object.entries(schema.fields)) {
+      // Check if this field has a defaultValue in its AST
+      const fieldAst = (fieldSchema as any)?.ast
+      if (fieldAst?.defaultValue) {
+        try {
+          result[key] = fieldAst.defaultValue()
+          continue
+        } catch {
+          // If defaultValue() throws, fall through to recursive processing
+        }
+      }
+
+      // Recursively process the field
+      const fieldValue = defaultsValueFromSchema(fieldSchema as any, record[key] || {})
+      if (fieldValue !== undefined) {
+        result[key] = fieldValue
+      }
+    }
+
+    return { ...result, ...record }
+  }
+
+  // Check if schema has fields in from (for ExtendedClass and similar transformations)
+  if ((schema as any)?.from && hasFields((schema as any).from)) {
+    return defaultsValueFromSchema((schema as any).from, record)
+  }
+
+  if (hasMembers(schema)) {
+    // Merge all member fields, giving precedence to fields with default values
+    const mergedMembers = schema.members.reduce((acc, member) => {
+      if (hasFields(member)) {
+        // Check each field and give precedence to ones with default values
+        Object.entries(member.fields).forEach(([key, fieldSchema]) => {
+          const fieldAst: any = fieldSchema.ast
+          const existingFieldAst: any = acc[key]?.ast
+
+          // If field doesn't exist yet, or new field has default and existing doesn't, use new field
+          if (!acc[key] || (fieldAst?.defaultValue && !existingFieldAst?.defaultValue)) {
+            acc[key] = fieldSchema
+          }
+          // If both have defaults or neither have defaults, keep the first one (existing)
+        })
+        return acc
+      }
+      return acc
+    }, {} as Record<string, any>)
+
+    // Use reduce to properly accumulate the merged fields
+    return Object.entries(mergedMembers).reduce((acc, [key, value]) => {
+      acc[key] = defaultsValueFromSchema(value, record[key] || {})
+      return acc
+    }, record)
+  }
+
+  if (Object.keys(record).length === 0) {
+    switch (schema.ast._tag) {
+      case "Refinement":
+        return defaultsValueFromSchema(S.make(schema.ast.from), record)
+      case "Transformation": {
+        // For all transformations, just process the 'from' side to get the base defaults
+        const fromSchema = S.make(schema.ast.from)
+        return defaultsValueFromSchema(fromSchema, record)
+      }
+      case "TypeLiteral": {
+        // Process TypeLiteral fields directly to build the result object
+        const result: Record<string, any> = { ...record }
+
+        for (const prop of ast.propertySignatures) {
+          const key = prop.name.toString()
+          const propType = prop.type
+
+          // Check if the property type itself is a Transformation with defaultValue
+          if (propType._tag === "Transformation" && propType.defaultValue) {
+            result[key] = propType.defaultValue()
+            continue
+          }
+
+          // Check if property type has defaultValue directly on the AST
+          if (propType.defaultValue) {
+            result[key] = propType.defaultValue()
+            continue
+          }
+
+          // Create a schema from the property type and get its defaults
+          const propSchema = S.make(propType)
+
+          // Recursively process the property - don't pas for prop processing
+          // to allow proper unwrapping of nested structures
+          const propValue = defaultsValueFromSchema(propSchema, record[key] || {})
+
+          if (propValue !== undefined) {
+            result[key] = propValue
+          }
+        }
+
+        return result
+      }
+      case "StringKeyword":
+        return ""
+      case "BooleanKeyword":
+        return false
+    }
+  }
+}

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

@@ -6,12 +6,11 @@ import { type DeepKeys, DeepValue, type FormAsyncValidateOrFn, type FormValidate
 import { Array, Data, Effect, Fiber, Option, Order, S } from "effect-app"
 import { runtimeFiberAsPromise } 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"
@@ -174,6 +173,8 @@ export type OmegaConfig<T> = {
   preventWindowExit?: "prevent" | "prevent-and-reset" | "nope"
 
   input?: any
+
+  defaultFromSchema?: "only" | "nope" | "merge"
 }
 
 export interface OF<From, To> extends OmegaFormApi<From, To> {
@@ -706,13 +707,20 @@ export const useOmegaForm = <
     // to be sure we have a valid object at the end of the gathering process
     defValuesPatch ??= {}
 
+    const defaultValuesFromSchema = (() => {
+      if (omegaConfig?.defaultFromSchema === "only") {
+        return defaultsValueFromSchema(schema)
+      }
+      if (omegaConfig?.defaultFromSchema === "nope") {
+        return tanstackFormOptions?.defaultValues || {}
+      }
+      return deepMerge(defaultsValueFromSchema(schema), tanstackFormOptions?.defaultValues || {})
+    })()
+
     // we just return what we gathered from the query/storage
-    return extractSchemaDefaults(
-      schema,
-      omegaConfig?.persistency?.overrideDefaultValues
-        ? deepMerge(tanstackFormOptions?.defaultValues || {}, defValuesPatch)
-        : deepMerge(defValuesPatch, tanstackFormOptions?.defaultValues || {})
-    )
+    return omegaConfig?.persistency?.overrideDefaultValues
+      ? deepMerge(defaultValuesFromSchema, defValuesPatch)
+      : deepMerge(defValuesPatch, defaultValuesFromSchema)
   })
 
   const wrapWithSpan = (span: api.Span | undefined, toWrap: () => any) => {

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.es31.js

@@ -1,6 +0,0 @@
-import "vue";
-typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
-const t = Object.prototype.toString, c = (o) => t.call(o) === "[object Object]";
-export {
-  c as isObject
-};

package/dist/vue-components.es36.js

@@ -1,9 +0,0 @@
-const s = (t, e) => {
-  const o = t.__vccOpts || t;
-  for (const [r, c] of e)
-    o[r] = c;
-  return o;
-};
-export {
-  s as default
-};