@effect-app/vue-components 4.0.0-beta.310 → 4.0.0-beta.311

package/dist/vue-components14.es.js

@@ -1,15 +1,16 @@
 import * as e from "effect-app/Schema";
 //#region src/components/OmegaForm/meta/checks.ts
-var t = (e) => (e.checks ?? []).flatMap((e) => {
-	if (e._tag === "FilterGroup") return e.checks.flatMap((e) => {
-		let t = e.annotations?.meta;
-		return t && typeof t == "object" ? [t] : [];
-	});
-	let t = e.annotations?.meta;
-	return t && typeof t == "object" ? [t] : [];
-}), n = (n) => {
-	let r = { description: e.AST.resolveDescription(n) }, i = t(n);
-	if (e.AST.isString(n)) {
+var t = (e) => {
+	let t = e.annotations?.representation;
+	if (t && typeof t.id == "string") return [{
+		_tag: t.id.replace(/^effect\/schema\//, ""),
+		...t.payload !== null && typeof t.payload == "object" ? t.payload : {}
+	}];
+	let n = e.annotations?.meta;
+	return n && typeof n == "object" ? [n] : [];
+}, n = (e) => (e.checks ?? []).flatMap((e) => e._tag === "FilterGroup" ? e.checks.flatMap((e) => t(e)) : t(e)), r = (t) => {
+	let r = { description: e.AST.resolveDescription(t) }, i = n(t);
+	if (e.AST.isString(t)) {
 		r.type = "string";
 		for (let e of i) switch (e._tag) {
 			case "isMinLength":
@@ -19,8 +20,8 @@ var t = (e) => (e.checks ?? []).flatMap((e) => {
 				r.maxLength = e.maxLength;
 				break;
 		}
-		n.annotations?.format === "email" && (r.format = "email");
-	} else if (e.AST.isNumber(n)) {
+		t.annotations?.format === "email" && (r.format = "email");
+	} else if (e.AST.isNumber(t)) {
 		r.type = "number";
 		for (let e of i) switch (e._tag) {
 			case "isInt":
@@ -42,8 +43,8 @@ var t = (e) => (e.checks ?? []).flatMap((e) => {
 				r.exclusiveMaximum = e.exclusiveMaximum;
 				break;
 		}
-	} else e.AST.isBoolean(n) ? r.type = "boolean" : e.AST.isDeclaration(n) && n.annotations?.typeConstructor?._tag === "Date" ? r.type = "date" : r.type = "unknown";
+	} else e.AST.isBoolean(t) ? r.type = "boolean" : e.AST.isDeclaration(t) && t.annotations?.typeConstructor?._tag === "Date" ? r.type = "date" : r.type = "unknown";
 	return r;
 };
 //#endregion
-export { n as getFieldMetadataFromAst };
+export { r as getFieldMetadataFromAst };

package/dist/vue-components17.es.js

@@ -11,7 +11,7 @@ var a = (e) => {
 		return;
 	}
 }, o = (e) => {
-	let t = e.context?.defaultValue?.[0], n = a(t);
+	let t = e.context?.constructorDefault, n = a(t);
 	if (n !== void 0) return n;
 	let r = e.encoding?.[0];
 	if (r && e.context?.isOptional) return a(r);

package/dist/vue-components18.es.js

@@ -1,6 +1,10 @@
 import * as e from "effect-app/Schema";
 //#region src/components/OmegaForm/meta/redacted.ts
-var t = (t) => e.AST.isDeclaration(t) && t.annotations?.typeConstructor?._tag === "effect/Redacted" && !t.encoding, n = (n) => {
+var t = (t) => {
+	if (!e.AST.isDeclaration(t) || t.encoding) return !1;
+	let n = t.annotations;
+	return n?.representation?.id === "effect/schema/Redacted" || n?.typeConstructor?._tag === "effect/Redacted";
+}, n = (n) => {
 	let r = n.ast, i = e.AST.isObjects(r) ? r : e.AST.isDeclaration(r) ? e.AST.toEncoded(r) : null;
 	if (!i || !("propertySignatures" in i)) return n;
 	let a = !1, o = {};

package/dist/vue-components21.es.js

@@ -1,93 +1,105 @@
-import * as e from "effect-app/Option";
-import * as t from "effect-app/Schema";
+import * as e from "effect-app/Schema";
 //#region src/components/OmegaForm/validation/localized.ts
-var n = (n) => ({
-	leafHook: (r) => {
-		let i = r.annotations?.message;
+var t = (e) => {
+	let t = e.annotations?.representation;
+	return t && typeof t.id == "string" ? {
+		_tag: t.id.replace(/^effect\/schema\//, ""),
+		...t.payload !== null && typeof t.payload == "object" ? t.payload : {}
+	} : e.annotations?.meta ?? {};
+}, n = (t) => e.SchemaIssue.hasInput(t) ? t.input : void 0, r = (r) => ({
+	leafHook: (t) => {
+		let i = t.annotations?.message;
 		if (i !== void 0) return String(i);
-		switch (r._tag) {
-			case "MissingKey": return n("validation.empty");
+		switch (t._tag) {
+			case "MissingKey": return r("validation.empty");
 			case "InvalidType": {
-				let i = r.ast;
-				return e.isNone(r.actual) || e.isSome(r.actual) && r.actual.value === void 0 || t.AST.isString(i) ? n("validation.empty") : t.AST.isBoolean(i) ? n("validation.not_a_valid", { type: "boolean" }) : t.AST.isNumber(i) ? n("validation.number.expected", { actualValue: e.isSome(r.actual) ? String(r.actual.value) : "NaN" }) : n("validation.not_a_valid");
+				let i = t.ast, a = n(t);
+				return a === void 0 || e.AST.isString(i) ? r("validation.empty") : e.AST.isBoolean(i) ? r("validation.not_a_valid", { type: "boolean" }) : e.AST.isNumber(i) ? r("validation.number.expected", { actualValue: String(a) }) : r("validation.not_a_valid");
 			}
-			default: return n("validation.not_a_valid");
+			default: return r("validation.not_a_valid");
 		}
 	},
-	checkHook: (e) => {
-		if (e.filter.annotations?.identifier === "Email") return n("validation.email.invalid");
-		let r = e.filter.annotations?.meta ?? {};
-		switch (r._tag) {
-			case "isMinLength": return r.minLength === 1 ? n("validation.empty") : n("validation.string.minLength", { minLength: r.minLength });
-			case "isMaxLength": return n("validation.string.maxLength", { maxLength: r.maxLength });
-			case "isInt": return n("validation.integer.expected", { actualValue: e.actual === void 0 ? "NaN" : String(e.actual) });
-			case "isGreaterThanOrEqualTo": return n(r.minimum === 0 ? "validation.number.positive" : "validation.number.min", {
-				minimum: r.minimum,
+	checkHook: (i) => {
+		if (i.filter.annotations?.identifier === "Email") return r("validation.email.invalid");
+		let a = t(i.filter);
+		switch (a._tag) {
+			case "isMinLength": return a.minLength === 1 ? r("validation.empty") : r("validation.string.minLength", { minLength: a.minLength });
+			case "isMaxLength": return r("validation.string.maxLength", { maxLength: a.maxLength });
+			case "isInt": {
+				let e = n(i);
+				return r("validation.integer.expected", { actualValue: e === void 0 ? "NaN" : String(e) });
+			}
+			case "isGreaterThanOrEqualTo": return r(a.minimum === 0 ? "validation.number.positive" : "validation.number.min", {
+				minimum: a.minimum,
 				isExclusive: !0
 			});
-			case "isGreaterThan": return n(r.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min", {
-				minimum: r.exclusiveMinimum,
+			case "isGreaterThan": return r(a.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min", {
+				minimum: a.exclusiveMinimum,
 				isExclusive: !1
 			});
-			case "isLessThanOrEqualTo": return n("validation.number.max", {
-				maximum: r.maximum,
+			case "isLessThanOrEqualTo": return r("validation.number.max", {
+				maximum: a.maximum,
 				isExclusive: !0
 			});
-			case "isLessThan": return n("validation.number.max", {
-				maximum: r.exclusiveMaximum,
+			case "isLessThan": return r("validation.number.max", {
+				maximum: a.exclusiveMaximum,
 				isExclusive: !1
 			});
-			default: return t.SchemaIssue.defaultCheckHook(e);
+			default: return e.SchemaIssue.defaultCheckHook(i);
 		}
 	}
-}), r = (e, r) => {
-	let { checkHook: i, leafHook: a } = n(r);
-	return t.toStandardSchemaV1(e, {
+}), i = (t, n) => {
+	let { checkHook: i, leafHook: a } = r(n);
+	return e.toStandardSchemaV1(t, {
 		leafHook: a,
-		checkHook: i
+		checkHook: i,
+		parseOptions: {
+			reportInput: !0,
+			errors: "all"
+		}
 	});
-}, i = (e) => t.AST.isUnion(e) && e.types.every(t.AST.isLiteral), a = (e, n) => {
-	if (i(e)) {
-		if (e.annotations?.message !== void 0) return e;
-		let r = e.types.map((e) => e.literal);
-		return new t.AST.Union(e.types, e.mode, {
-			...e.annotations,
+}, a = (t) => e.AST.isUnion(t) && t.types.every(e.AST.isLiteral), o = (t, n) => {
+	if (a(t)) {
+		if (t.annotations?.message !== void 0) return t;
+		let r = t.types.map((e) => e.literal);
+		return new e.AST.Union(t.types, t.mode, {
+			...t.annotations,
 			message: n("validation.not_a_valid", {
 				type: "select",
 				message: r.join(", ")
 			})
-		}, e.checks, e.encoding, e.context);
+		}, t.checks, t.encoding, t.context);
 	}
-	if (t.AST.isUnion(e)) {
-		let r = e.types.map((e) => a(e, n));
-		return r.some((t, n) => t !== e.types[n]) ? new t.AST.Union(r, e.mode, e.annotations, e.checks, e.encoding, e.context) : e;
+	if (e.AST.isUnion(t)) {
+		let r = t.types.map((e) => o(e, n));
+		return r.some((e, n) => e !== t.types[n]) ? new e.AST.Union(r, t.mode, t.annotations, t.checks, t.encoding, t.context) : t;
 	}
-	if (t.AST.isArrays(e)) {
-		let r = e.rest.map((e) => a(e, n)), o = e.elements.map((e) => a(e, n)), s = e.annotations;
-		if (e.annotations?.message === void 0 && e.rest.length === 1 && i(e.rest[0])) {
-			let t = e.rest[0].types.map((e) => e.literal);
+	if (e.AST.isArrays(t)) {
+		let r = t.rest.map((e) => o(e, n)), i = t.elements.map((e) => o(e, n)), s = t.annotations;
+		if (t.annotations?.message === void 0 && t.rest.length === 1 && a(t.rest[0])) {
+			let e = t.rest[0].types.map((e) => e.literal);
 			s = {
-				...e.annotations,
+				...t.annotations,
 				message: n("validation.not_a_valid", {
 					type: "multiple",
-					message: t.join(", ")
+					message: e.join(", ")
 				})
 			};
 		}
-		let c = r.some((t, n) => t !== e.rest[n]), l = o.some((t, n) => t !== e.elements[n]);
-		return !c && !l && s === e.annotations ? e : new t.AST.Arrays(e.isMutable, o, r, s, e.checks, e.encoding, e.context);
+		let c = r.some((e, n) => e !== t.rest[n]), l = i.some((e, n) => e !== t.elements[n]);
+		return !c && !l && s === t.annotations ? t : new e.AST.Arrays(t.isMutable, i, r, s, t.checks, t.encoding, t.context);
 	}
-	if (t.AST.isObjects(e)) {
-		let r = e.propertySignatures.map((e) => {
-			let r = a(e.type, n);
-			return r === e.type ? e : new t.AST.PropertySignature(e.name, r);
+	if (e.AST.isObjects(t)) {
+		let r = t.propertySignatures.map((t) => {
+			let r = o(t.type, n);
+			return r === t.type ? t : new e.AST.PropertySignature(t.name, r);
 		});
-		return r.some((t, n) => t !== e.propertySignatures[n]) ? new t.AST.Objects(r, e.indexSignatures, e.annotations, e.checks, e.encoding, e.context) : e;
+		return r.some((e, n) => e !== t.propertySignatures[n]) ? new e.AST.Objects(r, t.indexSignatures, t.annotations, t.checks, t.encoding, t.context) : t;
 	}
-	return e;
-}, o = (e, n) => {
-	let r = a(e.ast, n);
-	return r === e.ast ? e : t.make(r);
+	return t;
+}, s = (t, n) => {
+	let r = o(t.ast, n);
+	return r === t.ast ? t : e.make(r);
 };
 //#endregion
-export { o as annotateLiteralUnionMessages, n as makeStandardSchemaV1Hooks, r as toLocalizedStandardSchemaV1 };
+export { s as annotateLiteralUnionMessages, r as makeStandardSchemaV1Hooks, i as toLocalizedStandardSchemaV1 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "4.0.0-beta.310",
+  "version": "4.0.0-beta.311",
   "repository": {
     "type": "git",
     "url": "https://github.com/effect-app/libs.git",
@@ -8,7 +8,7 @@
   },
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
-    "effect": "^4.0.0-beta.90",
+    "effect": "^4.0.0-beta.107",
     "intl-messageformat": "^11.2.7",
     "mdi-js": "^1.0.1",
     "primeflex": "^4.0.0",
@@ -62,8 +62,8 @@
     "highlight.js": "^11.11.1",
     "mitt": "^3.0.1",
     "vue3-highlightjs": "^1.0.5",
-    "@effect-app/vue": "4.0.0-beta.310",
-    "effect-app": "4.0.0-beta.310"
+    "@effect-app/vue": "4.0.0-beta.311",
+    "effect-app": "4.0.0-beta.311"
   },
   "scripts": {
     "check": "vue-tsc",

package/src/components/OmegaForm/meta/checks.ts

@@ -3,19 +3,41 @@ import * as S from "effect-app/Schema"
 import type * as Record from "effect/Record"
 import type { FieldMeta } from "./types"
 
+/**
+ * Normalise a filter annotation into the meta shape used by field metadata
+ * extractors (`{ _tag: "isMinLength", minLength: n }`, …).
+ *
+ * Since effect beta.91+, filters expose `annotations.representation`
+ * (`{ id: "effect/schema/isMinLength", payload: { minLength } }`) instead of
+ * the older `annotations.meta` bag.
+ */
+const metaFromFilter = (check: {
+  readonly annotations?: {
+    readonly meta?: unknown
+    readonly representation?: { readonly id?: string; readonly payload?: unknown }
+  }
+}): Array<Record<string, any>> => {
+  const rep = check.annotations?.representation
+  if (rep && typeof rep.id === "string") {
+    const tag = rep.id.replace(/^effect\/schema\//, "")
+    const payload = rep.payload !== null && typeof rep.payload === "object"
+      ? rep.payload as Record<string, any>
+      : {}
+    return [{ _tag: tag, ...payload }]
+  }
+
+  const meta = check.annotations?.meta
+  return meta && typeof meta === "object" ? [meta as Record<string, any>] : []
+}
+
 export const getCheckMetas = (property: S.AST.AST): Array<Record<string, any>> => {
   const checks = property.checks ?? []
 
   return checks.flatMap((check) => {
     if (check._tag === "FilterGroup") {
-      return check.checks.flatMap((inner) => {
-        const meta = inner.annotations?.meta
-        return meta && typeof meta === "object" ? [meta as Record<string, any>] : []
-      })
+      return check.checks.flatMap((inner) => metaFromFilter(inner))
     }
-
-    const meta = check.annotations?.meta
-    return meta && typeof meta === "object" ? [meta as Record<string, any>] : []
+    return metaFromFilter(check)
   })
 }
 

package/src/components/OmegaForm/meta/defaults.ts

@@ -16,8 +16,9 @@ const extractDefaultFromLink = (link: any): unknown | undefined => {
 }
 
 const getDefaultFromAst = (property: S.AST.AST) => {
-  // 1. Check withConstructorDefault (stored in context.defaultValue)
-  const constructorLink = property.context?.defaultValue?.[0]
+  // 1. Check withConstructorDefault (context.constructorDefault is a single Link since beta.107;
+  //    previously context.defaultValue was an Encoding tuple of Links)
+  const constructorLink = property.context?.constructorDefault
   const constructorDefault = extractDefaultFromLink(constructorLink)
   if (constructorDefault !== undefined) return constructorDefault
 

package/src/components/OmegaForm/meta/redacted.ts

@@ -4,12 +4,17 @@ import * as S from "effect-app/Schema"
  * Checks if an AST node is a S.Redacted Declaration without encoding.
  * These need to be swapped to S.RedactedFromValue for form usage
  * because S.Redacted expects Redacted objects, not plain strings.
+ *
+ * Detection uses `annotations.representation.id` (beta.107+); the older
+ * `typeConstructor._tag === "effect/Redacted"` path is kept as a fallback.
  */
-const isRedactedWithoutEncoding = (ast: S.AST.AST): boolean =>
-  S.AST.isDeclaration(ast)
+const isRedactedWithoutEncoding = (ast: S.AST.AST): boolean => {
+  if (!S.AST.isDeclaration(ast) || ast.encoding) return false
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Effect Schema AST annotations are loosely typed
-  && (ast.annotations as any)?.typeConstructor?._tag === "effect/Redacted"
-  && !ast.encoding
+  const annotations = ast.annotations as any
+  return annotations?.representation?.id === "effect/schema/Redacted"
+    || annotations?.typeConstructor?._tag === "effect/Redacted"
+}
 
 /*
  * Creates a form-compatible schema by replacing S.Redacted(X) with

package/src/components/OmegaForm/validation/localized.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { StandardSchemaV1 } from "@tanstack/vue-form"
-import * as Option from "effect-app/Option"
 import * as S from "effect-app/Schema"
 import type { useIntl } from "../../../utils"
 
@@ -16,6 +15,26 @@ type FilterMeta =
   | { readonly _tag: "isLessThan"; readonly exclusiveMaximum: number }
   | { readonly _tag?: undefined }
 
+/** Map filter annotations (representation since beta.107, legacy meta before) to FilterMeta. */
+const filterMetaOf = (filter: {
+  readonly annotations?: {
+    readonly meta?: unknown
+    readonly representation?: { readonly id?: string; readonly payload?: unknown }
+  }
+}): FilterMeta => {
+  const rep = filter.annotations?.representation
+  if (rep && typeof rep.id === "string") {
+    const tag = rep.id.replace(/^effect\/schema\//, "")
+    const payload = rep.payload !== null && typeof rep.payload === "object"
+      ? rep.payload as Record<string, unknown>
+      : {}
+    return { _tag: tag, ...payload } as FilterMeta
+  }
+  return (filter.annotations?.meta ?? {})
+}
+
+const reportedInput = (issue: S.SchemaIssue.Issue): unknown => S.SchemaIssue.hasInput(issue) ? issue.input : undefined
+
 export const makeStandardSchemaV1Hooks = (
   trans: TransFn
 ): {
@@ -31,14 +50,13 @@ export const makeStandardSchemaV1Hooks = (
       case "InvalidType": {
         const ast = issue.ast
         // Detect undefined/missing actual values across required leaves and return a uniform empty message.
-        const actualUndefined = Option.isNone(issue.actual)
-          || (Option.isSome(issue.actual) && issue.actual.value === undefined)
+        const input = reportedInput(issue)
+        const actualUndefined = input === undefined
         if (actualUndefined) return trans("validation.empty")
         if (S.AST.isString(ast)) return trans("validation.empty")
         if (S.AST.isBoolean(ast)) return trans("validation.not_a_valid", { type: "boolean" })
         if (S.AST.isNumber(ast)) {
-          const actual = Option.isSome(issue.actual) ? String(issue.actual.value) : "NaN"
-          return trans("validation.number.expected", { actualValue: actual })
+          return trans("validation.number.expected", { actualValue: String(input) })
         }
         return trans("validation.not_a_valid")
       }
@@ -48,13 +66,13 @@ export const makeStandardSchemaV1Hooks = (
   }
 
   const checkHook: S.SchemaIssue.CheckHook = (issue) => {
-    // S.Email's `refine(isValidEmail, ...)` has no `meta._tag` but carries
+    // S.Email's `refine(isValidEmail, ...)` has no representation meta but carries
     // `identifier: "Email"`. Localize it explicitly — otherwise the
     // formatter falls back to the generic "Expected <filter>, got <actual>".
     if (issue.filter.annotations?.identifier === "Email") {
       return trans("validation.email.invalid")
     }
-    const meta = (issue.filter.annotations?.meta ?? {}) as FilterMeta
+    const meta = filterMetaOf(issue.filter)
     switch (meta._tag) {
       case "isMinLength":
         return meta.minLength === 1
@@ -63,7 +81,8 @@ export const makeStandardSchemaV1Hooks = (
       case "isMaxLength":
         return trans("validation.string.maxLength", { maxLength: meta.maxLength })
       case "isInt": {
-        const actual = issue.actual !== undefined ? String(issue.actual) : "NaN"
+        const input = reportedInput(issue)
+        const actual = input !== undefined ? String(input) : "NaN"
         return trans("validation.integer.expected", { actualValue: actual })
       }
       case "isGreaterThanOrEqualTo":
@@ -97,7 +116,12 @@ export const toLocalizedStandardSchemaV1 = <To, From>(
   trans: TransFn
 ): StandardSchemaV1<From, To> => {
   const { checkHook, leafHook } = makeStandardSchemaV1Hooks(trans)
-  return S.toStandardSchemaV1(schema, { leafHook, checkHook })
+  // reportInput so leaf/check hooks can include the rejected value in messages
+  return S.toStandardSchemaV1(schema, {
+    leafHook,
+    checkHook,
+    parseOptions: { reportInput: true, errors: "all" }
+  })
 }
 
 /*