@effect-app/vue 4.0.0-beta.1 → 4.0.0-beta.100

package/src/{experimental/confirm.ts → confirm.ts}

@@ -1,8 +1,8 @@
-import { Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Effect, Layer } from "effect-app"
 import { I18n } from "./intl.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class Confirm extends ServiceMap.Service<Confirm>()("Confirm", {
+export class Confirm extends Context.Service<Confirm>()("Confirm", {
   make: Effect.gen(function*() {
     const { intl } = yield* I18n
 

package/src/form.ts

@@ -1,7 +1,6 @@
 import { createIntl, type IntlFormatters } from "@formatjs/intl"
 import type {} from "intl-messageformat"
 import { Cause, Exit, Option, pipe, S } from "effect-app"
-import type { Schema } from "effect-app/Schema"
 import type { Unbranded } from "effect-app/Schema/brand"
 import type { IsUnion } from "effect-app/utils"
 import { capitalize, ref } from "vue"
@@ -23,6 +22,7 @@ function getObjectsAST(ast: S.AST.AST): S.AST.Objects | null {
   return null
 }
 
+/** @deprecated Use OmegaForm instead */
 export function convertIn(v: string | null, type?: "text" | "float" | "int") {
   return v === null ? "" : type === "text" ? v : `${v}`
 }
@@ -31,8 +31,10 @@ export function convertIn(v: string | null, type?: "text" | "float" | "int") {
  * Makes sure our international number format is converted to js int/float format.
  * Right now assumes . for thousands and , for decimal.
  */
+/** @deprecated Use OmegaForm instead */
 export const prepareNumberForLocale = (v: string) => v.replace(/\./g, "").replace(/,/g, ".")
 
+/** @deprecated Use OmegaForm instead */
 export function convertOutInt(v: string, type?: "text" | "float" | "int") {
   v = v == null ? v : v.trim()
   const c = v === ""
@@ -50,6 +52,7 @@ export function convertOutInt(v: string, type?: "text" | "float" | "int") {
   return c
 }
 
+/** @deprecated Use OmegaForm instead */
 export function convertOut(v: string, set: (v: {} | null) => void, type?: "text" | "float" | "int") {
   return set(convertOutInt(v, type))
 }
@@ -122,7 +125,7 @@ function handlePropertySignature(
   switch (schema.ast._tag) {
     case "Objects": {
       return buildFieldInfoFromFieldsRoot(
-        schema as S.Schema<Record<PropertyKey, any>>
+        schema as S.Codec<Record<PropertyKey, any>>
       )
     }
     case "Union": {
@@ -144,10 +147,18 @@ function handlePropertySignature(
             const typeLiteral = getObjectsAST(ps.type)
 
             const tagPropertySignature = typeLiteral?.propertySignatures.find((_) => _.name === "_tag")
-            const tagLiteral = tagPropertySignature
-                && S.AST.isLiteral(tagPropertySignature.type)
-                && typeof tagPropertySignature.type.literal === "string"
-              ? tagPropertySignature.type.literal
+            // unwrap single-element Union to Literal (S.Struct({ _tag: S.Literal("x") }) wraps as Union([Literal("x")]))
+            const tagType = tagPropertySignature
+              ? S.AST.isUnion(tagPropertySignature.type)
+                  && tagPropertySignature.type.types.length === 1
+                  && S.AST.isLiteral(tagPropertySignature.type.types[0]!)
+                ? tagPropertySignature.type.types[0]
+                : tagPropertySignature.type
+              : undefined
+            const tagLiteral = tagType
+                && S.AST.isLiteral(tagType)
+                && typeof tagType.literal === "string"
+              ? tagType.literal
               : void 0
 
             const toRet = handlePropertySignature(ps)
@@ -190,21 +201,23 @@ function handlePropertySignature(
   }
 }
 
+/** @deprecated Use OmegaForm instead */
 export function buildFieldInfoFromFields<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>
 >(
-  schema: (Schema<To> | S.Codec<To, From>) & { fields?: S.Struct.Fields }
+  schema: (S.Codec<To, From>) & { fields?: S.Struct.Fields }
 ) {
   return buildFieldInfoFromFieldsRoot(schema).fields
 }
 
+/** @deprecated Use OmegaForm instead */
 export function buildFieldInfoFromFieldsRoot<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>,
   R
 >(
-  schema: (Schema<To> | S.Codec<To, From, R>) & { fields?: S.Struct.Fields }
+  schema: (S.Codec<To, From, R>) & { fields?: S.Struct.Fields }
 ): NestedFieldInfo<To> {
   const ast = getObjectsAST(schema.ast)
 
@@ -236,7 +249,9 @@ abstract class PhantomTypeParameter<
 
 const defaultIntl = createIntl({ locale: "en" })
 
+/** @deprecated Use OmegaForm instead */
 export const translate = ref<IntlFormatters["formatMessage"]>(defaultIntl.formatMessage)
+/** @deprecated Use OmegaForm instead */
 export const customSchemaErrors = ref<Map<S.AST.AST | string, (message: string, e: unknown, v: unknown) => string>>(
   new Map()
 )
@@ -245,9 +260,9 @@ function buildFieldInfo(
   property: S.AST.PropertySignature
 ): FieldInfo<any> {
   const propertyKey = property.name
-  const schema = S.make<S.Schema<unknown>>(property.type)
+  const schema = S.make<S.Codec<unknown>>(property.type)
   const metadata = getMetadataFromSchema(property.type)
-  const parse = S.decodeUnknownExit(schema as S.Schema<unknown> & { readonly DecodingServices: never })
+  const parse = S.decodeUnknownExit(schema as S.Codec<unknown> & { readonly DecodingServices: never })
 
   const nullableOrUndefined = S.AST.isUnion(property.type)
     && (property.type.types.includes(S.Null.ast) || property.type.types.some((_) => _._tag === "Undefined"))
@@ -270,7 +285,7 @@ function buildFieldInfo(
     }
 
     // parse specific error types for better translation support
-    const integerMatch = err.match(/Expected.*integer.*actual\s+(.+)/i)
+    const integerMatch = err.match(/Expected.*integer.*(?:actual|got)\s+([^)]+)/i)
     if (integerMatch) {
       return translate.value(
         { defaultMessage: "Expected an integer, actual {actualValue}", id: "validation.integer.expected" },
@@ -278,7 +293,7 @@ function buildFieldInfo(
       )
     }
 
-    const numberMatch = err.match(/Expected.*number.*actual\s+(.+)/i)
+    const numberMatch = err.match(/Expected.*number.*(?:actual|got)\s+([^)]+)/i)
     if (numberMatch) {
       return translate.value(
         { defaultMessage: "Expected a number, actual {actualValue}", id: "validation.number.expected" },
@@ -399,6 +414,7 @@ function buildFieldInfo(
   return info as any
 }
 
+/** @deprecated Use OmegaForm instead */
 export function getMetadataFromSchema(
   ast: S.AST.AST
 ): {
@@ -412,6 +428,27 @@ export function getMetadataFromSchema(
   required: boolean
   description?: string
 } {
+  const findJsonSchemaType = (
+    schema: any,
+    target: "number" | "integer"
+  ): boolean => {
+    if (!schema || typeof schema !== "object") {
+      return false
+    }
+
+    if (schema.type === target) {
+      return true
+    }
+
+    if (Array.isArray(schema.type) && schema.type.includes(target)) {
+      return true
+    }
+
+    return ["anyOf", "oneOf", "allOf"].some((key) =>
+      Array.isArray(schema[key]) && schema[key].some((member: any) => findJsonSchemaType(member, target))
+    )
+  }
+
   const nullable = S.AST.isUnion(ast) && ast.types.includes(S.Null.ast)
   const realSelf = nullable && S.AST.isUnion(ast)
     ? ast.types.filter((_) => _ !== S.Null.ast)[0]!
@@ -419,7 +456,7 @@ export function getMetadataFromSchema(
 
   let jschema: any
   try {
-    const doc = S.toJsonSchemaDocument(S.make<S.Schema<unknown>>(realSelf))
+    const doc = S.toJsonSchemaDocument(S.make<S.Codec<unknown>>(realSelf))
     jschema = doc.schema as any
     const defs = doc.definitions as Record<string, any>
     // resolve $ref against definitions
@@ -441,8 +478,8 @@ export function getMetadataFromSchema(
   //         "title": "Int"
   //     }
   // }
-  const isNumber = jschema.type === "number" || jschema.type === "integer"
-  const isInt = jschema.type === "integer"
+  const isInt = findJsonSchemaType(jschema, "integer")
+  const isNumber = isInt || findJsonSchemaType(jschema, "number")
   return {
     type: isInt ? "int" as const : isNumber ? "float" as const : "text" as const,
     minimum: jschema.minimum,

package/src/intl.ts

@@ -0,0 +1,12 @@
+import { Context } from "effect-app"
+import { accessCn, accessFn } from "effect-app/Context"
+import { type MakeIntlReturn } from "./makeIntl.js"
+
+type I18nShape = ReturnType<MakeIntlReturn<string>["useIntl"]>
+
+export class I18n extends Context.Opaque<I18n, I18nShape>()("I18n") {
+  static readonly locale = accessCn(this, "locale")
+  static readonly trans = accessFn(this, "trans")
+  static readonly formatMessage = accessFn(this, "formatMessage")
+  static readonly intl = accessCn(this, "intl")
+}