@effect-app/vue-components 2.7.11 → 2.9.0

package/dist/vue-components.es60.js

@@ -1,4 +1,44 @@
-var r = "1.9.0";
+import { ROOT_CONTEXT as l } from "./vue-components.es42.js";
+var c = function(t, o) {
+  var n = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!n) return t;
+  var e = n.call(t), a, r = [], u;
+  try {
+    for (; (o === void 0 || o-- > 0) && !(a = e.next()).done; ) r.push(a.value);
+  } catch (i) {
+    u = { error: i };
+  } finally {
+    try {
+      a && !a.done && (n = e.return) && n.call(e);
+    } finally {
+      if (u) throw u.error;
+    }
+  }
+  return r;
+}, p = function(t, o, n) {
+  if (n || arguments.length === 2) for (var e = 0, a = o.length, r; e < a; e++)
+    (r || !(e in o)) && (r || (r = Array.prototype.slice.call(o, 0, e)), r[e] = o[e]);
+  return t.concat(r || Array.prototype.slice.call(o));
+}, y = (
+  /** @class */
+  (function() {
+    function t() {
+    }
+    return t.prototype.active = function() {
+      return l;
+    }, t.prototype.with = function(o, n, e) {
+      for (var a = [], r = 3; r < arguments.length; r++)
+        a[r - 3] = arguments[r];
+      return n.call.apply(n, p([e], c(a), !1));
+    }, t.prototype.bind = function(o, n) {
+      return n;
+    }, t.prototype.enable = function() {
+      return this;
+    }, t.prototype.disable = function() {
+      return this;
+    }, t;
+  })()
+);
 export {
-  r as VERSION
+  y as NoopContextManager
 };

package/dist/vue-components.es61.js

@@ -1,46 +1,4 @@
-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);
+var r = "1.9.0";
 export {
-  s as _makeCompatibilityCheck,
-  v as isCompatible
+  r as VERSION
 };

package/dist/vue-components.es62.js

@@ -1,4 +1,46 @@
-var o = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {};
+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);
 export {
-  o as _globalThis
+  s as _makeCompatibilityCheck,
+  v as isCompatible
 };

package/dist/vue-components.es63.js

@@ -0,0 +1,4 @@
+var o = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {};
+export {
+  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.es38.js";
+import T from "./vue-components.es39.js";
 
 const H = /* @__PURE__ */ $({
   inheritAttrs: !1,

package/dist/vue-components.es9.js

@@ -1,5 +1,8 @@
-import { defineComponent as s, watch as m, renderSlot as o, createCommentVNode as r, normalizeProps as f, mergeProps as i } from "vue";
-const d = /* @__PURE__ */ s({
+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({
   __name: "OmegaTaggedUnionInternal",
   props: {
     state: {},
@@ -7,15 +10,35 @@ const d = /* @__PURE__ */ s({
     name: {},
     form: {}
   },
-  setup(e) {
-    const a = e, l = a.form.useStore(({ values: t }) => t);
-    return m(() => a.state, (t, n) => {
-      t === null && a.field.setValue(null), t !== n && (a.form.reset(l.value), setTimeout(() => {
-        a.field.validate("change");
-      }, 0));
-    }), (t, n) => e.state ? o(t.$slots, `${e.name ? `${e.name}.` : ""}${e.state}`, f(i({ key: 0 }, { field: e.field, state: e.state }))) : r("", !0);
+  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);
   }
 });
 export {
-  d as default
+  b as default
 };

package/package.json

@@ -1,39 +1,39 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "2.7.11",
+  "version": "2.9.0",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
-    "effect": "^3.18.0",
-    "intl-messageformat": "^10.7.16",
+    "effect": "^3.19.3",
+    "intl-messageformat": "^10.7.18",
     "mdi-js": "^1.0.1",
     "primeflex": "^4.0.0",
     "primeicons": "^7.0.0",
-    "primevue": "^4.3.9",
-    "vue": "^3.5.22",
-    "vuetify": "^3.10.3"
+    "primevue": "^4.4.1",
+    "vue": "^3.5.24",
+    "vuetify": "^3.10.9"
   },
   "devDependencies": {
-    "@storybook/vue3": "^9.1.9",
-    "@storybook/vue3-vite": "^9.1.9",
-    "@types/node": "^24.6.0",
+    "@storybook/vue3": "^10.0.6",
+    "@storybook/vue3-vite": "^10.0.6",
+    "@types/node": "^24.10.0",
     "@vitejs/plugin-vue": "^6.0.1",
     "@vue/test-utils": "^2.4.6",
-    "@vueuse/core": "^13.9.0",
+    "@vueuse/core": "^14.0.0",
     "dprint": "^0.50.2",
-    "jsdom": "^27.0.0",
-    "rimraf": "^6.0.1",
-    "sass": "^1.93.2",
-    "storybook": "^9.1.9",
-    "typescript": "~5.9.2",
-    "vite": "^7.1.7",
+    "jsdom": "^27.1.0",
+    "rimraf": "^6.1.0",
+    "sass": "^1.94.0",
+    "storybook": "^10.0.6",
+    "typescript": "~5.9.3",
+    "vite": "^7.2.2",
     "vite-plugin-css-injected-by-js": "^3.5.2",
     "vitepress": "^1.6.4",
-    "vitest": "^3.2.4",
-    "vue-router": "^4.5.1",
+    "vitest": "^4.0.8",
+    "vue-router": "^4.6.3",
     "vue-toastification": "^2.0.0-rc.5",
-    "vue-tsc": "^3.1.0",
-    "vuetify": "^3.10.3",
-    "@effect-app/eslint-shared-config": "0.3.4"
+    "vue-tsc": "^3.1.3",
+    "vuetify": "^3.10.9",
+    "@effect-app/eslint-shared-config": "0.4.0"
   },
   "files": [
     "src",
@@ -53,8 +53,8 @@
     "highlight.js": "^11.11.1",
     "mitt": "^3.0.1",
     "vue3-highlightjs": "^1.0.5",
-    "@effect-app/vue": "2.92.2",
-    "effect-app": "3.12.0"
+    "@effect-app/vue": "2.93.0",
+    "effect-app": "3.13.0"
   },
   "scripts": {
     "build": "pnpm build:run",

package/src/components/OmegaForm/OmegaTaggedUnionInternal.vue

@@ -16,7 +16,10 @@
 "
 >
 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"
 
@@ -34,11 +37,57 @@ watch(() => props.state, (newTag, oldTag) => {
   if (newTag === null) {
     props.field.setValue(null as DeepValue<From, Name>)
   }
+
   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")
     }, 0)
   }
-})
+}, { immediate: true })
 </script>

package/src/components/OmegaForm/defaultAST.ts

@@ -0,0 +1,191 @@
+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)
+}