@effect-app/vue 4.0.0-beta.33 → 4.0.0-beta.36

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @effect-app/vue
 
+## 4.0.0-beta.36
+
+### Patch Changes
+
+- effect-app@4.0.0-beta.36
+
+## 4.0.0-beta.35
+
+### Patch Changes
+
+- effect-app@4.0.0-beta.35
+
+## 4.0.0-beta.34
+
+### Patch Changes
+
+- 8c645d5: update to latest effect
+- Updated dependencies [8c645d5]
+  - effect-app@4.0.0-beta.34
+
 ## 4.0.0-beta.33
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue",
-  "version": "4.0.0-beta.33",
+  "version": "4.0.0-beta.36",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/effect-ts-app/libs/tree/main/packages/vue",
@@ -11,23 +11,23 @@
     "@vueuse/core": "^14.2.1",
     "change-case": "^5.4.4",
     "query-string": "^9.3.1",
-    "effect-app": "4.0.0-beta.33"
+    "effect-app": "4.0.0-beta.36"
   },
   "peerDependencies": {
-    "@effect/atom-vue": "^4.0.0-beta.37",
-    "@effect/platform-browser": "^4.0.0-beta.37",
+    "@effect/atom-vue": "^4.0.0-beta.40",
+    "@effect/platform-browser": "^4.0.0-beta.40",
     "@sentry/browser": "^10.42.0",
-    "effect": "^4.0.0-beta.37",
+    "effect": "^4.0.0-beta.40",
     "vue": "^3.5.29"
   },
   "devDependencies": {
-    "@effect/vitest": "^4.0.0-beta.37",
+    "@effect/vitest": "^4.0.0-beta.40",
     "@formatjs/icu-messageformat-parser": "^3.5.1",
     "@types/node": "25.3.3",
     "@vitejs/plugin-vue": "^6.0.4",
     "intl-messageformat": "^11.1.2",
     "json5": "^2.2.3",
-    "typescript": "~5.9.3",
+    "typescript": "~6.0.2",
     "vite": "^7.3.1",
     "vitest": "^4.0.18",
     "@effect-app/eslint-shared-config": "0.5.7-beta.2"

package/tsconfig.json

@@ -32,7 +32,6 @@
     "outDir": "build/dist",
     "resolveJsonModule": true,
     "moduleResolution": "Node16",
-    "downlevelIteration": true,
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true,
     "types": [

package/test/form-validation-errors.test.ts

@@ -1,158 +0,0 @@
-import { Effect, S } from "effect-app"
-import { buildFieldInfoFromFieldsRoot, translate } from "../src/form.js"
-
-// test schema with integer field
-class TestSchema extends S.Class<TestSchema>("TestSchema")({
-  integerField: S.Int,
-  numberField: S.Finite,
-  stringField: S.String
-}) {}
-
-// translation dictionaries
-const translations: Record<string, Record<string, string>> = {
-  en: {
-    "validation.integer.expected": "Expected an integer, actual {actualValue}",
-    "validation.number.expected": "Expected a number, actual {actualValue}"
-  },
-  de: {
-    "validation.integer.expected": "Es wird eine ganze Zahl erwartet, tatsächlich: {actualValue}",
-    "validation.number.expected": "Es wird eine Zahl erwartet, tatsächlich: {actualValue}"
-  }
-}
-
-// mock translate function to capture translation calls and return actual translated string
-const translationCalls: Array<{ id: string; defaultMessage: string; params?: any }> = []
-let currentLocale = "en"
-
-const mockTranslate = (msg: { id: string; defaultMessage: string }, params?: any) => {
-  translationCalls.push({ id: msg.id, defaultMessage: msg.defaultMessage, params })
-
-  // get the translation template
-  const template = translations[currentLocale]?.[msg.id] || msg.defaultMessage
-
-  // replace parameters in the template
-  if (params) {
-    return Object.entries(params).reduce((result, [key, value]) => {
-      return result.replace(`{${key}}`, String(value))
-    }, template)
-  }
-
-  return template
-}
-
-beforeEach(() => {
-  translationCalls.length = 0
-  currentLocale = "en"
-  translate.value = mockTranslate as any
-})
-
-it("validates integer field with decimal value (English)", () =>
-  Effect
-    .gen(function*() {
-      currentLocale = "en"
-      const fieldInfo = buildFieldInfoFromFieldsRoot(TestSchema)
-      const integerFieldInfo = fieldInfo.fields.integerField
-
-      expect(integerFieldInfo._tag).toBe("FieldInfo")
-      expect(integerFieldInfo.type).toBe("int")
-
-      // test validation rules with a decimal value
-      const result = integerFieldInfo.rules[1] ? integerFieldInfo.rules[1]("59.5") : undefined
-
-      console.log("Validation result (EN):", result)
-      console.log("Translation calls:", translationCalls)
-
-      // the validation should fail
-      expect(result).not.toBe(true)
-      expect(typeof result).toBe("string")
-
-      // check if the correct translation key was called
-      const integerErrorCall = translationCalls.find((call) => call.id === "validation.integer.expected")
-      expect(integerErrorCall).toBeDefined()
-      expect(integerErrorCall?.params).toHaveProperty("actualValue")
-      expect(integerErrorCall?.params.actualValue).toBe("59.5")
-
-      // MOST IMPORTANT: verify the actual translated string returned
-      expect(result).toBe("Expected an integer, actual 59.5")
-    })
-    .pipe(Effect.runPromise))
-
-it("validates integer field with decimal value (German)", () =>
-  Effect
-    .gen(function*() {
-      currentLocale = "de"
-      const fieldInfo = buildFieldInfoFromFieldsRoot(TestSchema)
-      const integerFieldInfo = fieldInfo.fields.integerField
-
-      expect(integerFieldInfo._tag).toBe("FieldInfo")
-      expect(integerFieldInfo.type).toBe("int")
-
-      // test validation rules with a decimal value
-      const result = integerFieldInfo.rules[1] ? integerFieldInfo.rules[1]("59.5") : undefined
-
-      console.log("Validation result (DE):", result)
-
-      // the validation should fail
-      expect(result).not.toBe(true)
-      expect(typeof result).toBe("string")
-
-      // MOST IMPORTANT: verify the actual German translated string returned
-      expect(result).toBe("Es wird eine ganze Zahl erwartet, tatsächlich: 59.5")
-    })
-    .pipe(Effect.runPromise))
-
-it("validates string field parsed as number", () =>
-  Effect
-    .gen(function*() {
-      const fieldInfo = buildFieldInfoFromFieldsRoot(TestSchema)
-      const stringFieldInfo = fieldInfo.fields.stringField
-
-      expect(stringFieldInfo._tag).toBe("FieldInfo")
-      expect(stringFieldInfo.type).toBe("text")
-
-      // test validation rules with a number that should fail string validation
-      const result = stringFieldInfo.rules[0] ? stringFieldInfo.rules[0]("123") : undefined
-
-      console.log("Validation result for string field:", result)
-
-      // string field should accept "123" as a valid string
-      expect(result).toBe(true)
-    })
-    .pipe(Effect.runPromise))
-
-it("validates integer field with valid integer", () =>
-  Effect
-    .gen(function*() {
-      const fieldInfo = buildFieldInfoFromFieldsRoot(TestSchema)
-      const integerFieldInfo = fieldInfo.fields.integerField
-
-      // test validation rules with a valid integer
-      const result = integerFieldInfo.rules[1] ? integerFieldInfo.rules[1]("42") : undefined
-
-      console.log("Validation result for valid integer:", result)
-
-      // the validation should pass
-      expect(result).toBe(true)
-    })
-    .pipe(Effect.runPromise))
-
-it("error message format matches regex pattern", () => {
-  // test the actual error message format from Effect Schema
-  const errorMessage = `Int
-└─ From side refinement failure
-   └─ Int
-      └─ Predicate refinement failure
-         └─ Expected an integer, actual 59.5`
-
-  const integerMatch = errorMessage.match(/Expected.*integer.*actual\s+(.+)/i)
-  expect(integerMatch).toBeTruthy()
-  expect(integerMatch![1]).toBe("59.5")
-
-  const numberErrorMessage = `Number
-└─ Type side transformation failure
-   └─ Expected a number, actual "not-a-number"`
-
-  const numberMatch = numberErrorMessage.match(/Expected.*number.*actual\s+(.+)/i)
-  expect(numberMatch).toBeTruthy()
-  expect(numberMatch![1]).toBe("\"not-a-number\"")
-})

package/test/form.test.ts

@@ -1,261 +0,0 @@
-import { Effect, S } from "effect-app"
-import { buildFieldInfoFromFieldsRoot, type DiscriminatedUnionFieldInfo, type FieldInfo, type NestedFieldInfo, type UnionFieldInfo } from "../src/form.js"
-
-export class NestedSchema extends S.Class<NestedSchema>("NestedSchema")({
-  shallow: S.String,
-  nested: S.Struct({
-    deep: S.NonEmptyString,
-    nested: S.Struct({
-      deepest: S.Finite
-    })
-  }),
-  age: S.Struct({ nfs: S.FiniteFromString.pipe(S.decodeTo(S.PositiveInt)) })
-}) {}
-
-export class SchemaContainsClass extends S.Class<SchemaContainsClass>("SchemaContainsClass")({
-  inner: NestedSchema
-}) {}
-
-export class UnionSchema extends S.Class<UnionSchema>("UnionSchema")({
-  generalUnion: S.Union([S.String, S.Struct({ unionNested: NestedSchema })]),
-  structsUnion: S.Union([NestedSchema, SchemaContainsClass]),
-  optional: S.optional(S.String),
-  nullable: S.NullOr(S.String)
-}) {}
-
-class Circle extends S.TaggedClass<Circle>()("Circle", {
-  radius: S.PositiveInt
-}) {}
-
-class Square extends S.TaggedClass<Square>()("Square", {
-  sideLength: S.PositiveInt
-}) {}
-
-class Triangle extends S.TaggedClass<Triangle>()("Triangle", {
-  base: S.PositiveInt,
-  height: S.Finite
-}) {}
-
-const CircleStruct = S.Struct({
-  _tag: S.Literal("CircleStruct"),
-  radius: S.PositiveInt
-})
-
-const SquareStruct = S.Struct({
-  _tag: S.Literal("SquareStruct"),
-  sideLength: S.PositiveInt
-})
-
-const TriangleStruct = S.Struct({
-  _tag: S.Literal("TriangleStruct"),
-  base: S.PositiveInt,
-  height: S.Finite
-})
-
-const ShapeWithStructs = S.Union([CircleStruct, SquareStruct, TriangleStruct])
-const ShapeWithClasses = S.Union([Circle, Square, Triangle])
-
-export class ShapeContainer extends S.Class<ShapeContainer>("ShapeContainer")({
-  shapeWithStruct: ShapeWithStructs,
-  shapeWithClasses: ShapeWithClasses
-}) {}
-
-function testFieldInfo<T>(fi: FieldInfo<T>) {
-  expect(fi).toBeInstanceOf(Object)
-  expect(fi._tag).toBe("FieldInfo")
-  expect(["text", "float", "int"]).toContain(fi.type)
-  expect(fi.rules).toBeInstanceOf(Array)
-  fi.rules.forEach((r) => {
-    expect(r).toBeInstanceOf(Function)
-  })
-  expect(fi.metadata).toBeInstanceOf(Object)
-  expect(fi.metadata.maxLength === void 0 || typeof fi.metadata.maxLength === "number").toBeTruthy()
-  expect(fi.metadata.minLength === void 0 || typeof fi.metadata.minLength === "number").toBeTruthy()
-  expect(typeof fi.metadata.required === "boolean").toBeTruthy()
-}
-
-function testUnionFieldInfo<T>(ufi: UnionFieldInfo<T[]>) {
-  expect(ufi).toBeInstanceOf(Object)
-  expect(ufi._tag).toBe("UnionFieldInfo")
-  expect(ufi.members).toBeInstanceOf(Array)
-  ufi.members.forEach(
-    (
-      i: any
-    ) => {
-      switch (i._tag) {
-        case "FieldInfo":
-          testFieldInfo(i as FieldInfo<any>)
-          break
-        case "NestedFieldInfo":
-          testNestedFieldInfo(i as NestedFieldInfo<any>)
-          break
-        case "UnionFieldInfo":
-          testUnionFieldInfo(i as UnionFieldInfo<any>)
-          break
-        case "DiscriminatedUnionFieldInfo":
-          testDiscriminatedUnionFieldInfo(i as DiscriminatedUnionFieldInfo<any>)
-          break
-      }
-    }
-  )
-}
-
-function testNestedFieldInfo<T extends Record<PropertyKey, any>>(nfi: NestedFieldInfo<T>) {
-  expect(nfi).toBeInstanceOf(Object)
-  expect(nfi._tag).toBe("NestedFieldInfo")
-  expect(nfi.fields).toBeInstanceOf(Object)
-
-  // remove the value of _infoTag from the object when it is undefined
-  // when it isn't undefined, the followin switch will ignore it
-  Object.values(nfi).filter(Boolean).forEach(
-    (
-      i: any
-    ) => {
-      switch (i._tag) {
-        case "FieldInfo":
-          testFieldInfo(i as FieldInfo<any>)
-          break
-        case "NestedFieldInfo":
-          testNestedFieldInfo(i as NestedFieldInfo<any>)
-          break
-        case "UnionFieldInfo":
-          testUnionFieldInfo(i as UnionFieldInfo<any>)
-          break
-        case "DiscriminatedUnionFieldInfo":
-          testDiscriminatedUnionFieldInfo(i as DiscriminatedUnionFieldInfo<any>)
-          break
-      }
-    }
-  )
-}
-
-function testDiscriminatedUnionFieldInfo<T extends Record<PropertyKey, any>>(dufi: DiscriminatedUnionFieldInfo<T>) {
-  expect(dufi).toBeInstanceOf(Object)
-  expect(dufi._tag).toBe("DiscriminatedUnionFieldInfo")
-  expect(dufi.members).toBeInstanceOf(Object)
-
-  Object.values(dufi.members).forEach(
-    (
-      i: any
-    ) => {
-      switch (i._tag) {
-        case "FieldInfo":
-          testFieldInfo(i as FieldInfo<any>)
-          break
-        case "NestedFieldInfo":
-          testNestedFieldInfo(i as NestedFieldInfo<any>)
-          break
-        case "UnionFieldInfo":
-          testUnionFieldInfo(i as UnionFieldInfo<any>)
-          break
-        case "DiscriminatedUnionFieldInfo":
-          testDiscriminatedUnionFieldInfo(i as DiscriminatedUnionFieldInfo<any>)
-          break
-      }
-    }
-  )
-}
-
-it("buildFieldInfo", () =>
-  Effect
-    .gen(function*() {
-      const nestedFieldinfo = buildFieldInfoFromFieldsRoot(NestedSchema)
-      expectTypeOf(nestedFieldinfo).toEqualTypeOf<NestedFieldInfo<NestedSchema>>()
-      expectTypeOf(nestedFieldinfo.fields.shallow).toEqualTypeOf<FieldInfo<string>>()
-      expectTypeOf(nestedFieldinfo.fields.age).toEqualTypeOf<NestedFieldInfo<NestedSchema["age"]>>()
-      // TODO: v4 migration - type inference changed with S.decodeTo, investigate if this is correct
-      // expectTypeOf(nestedFieldinfo.fields.age.fields.nfs).toEqualTypeOf<FieldInfo<number & S.PositiveIntBrand>>()
-      expectTypeOf(nestedFieldinfo.fields.nested).toEqualTypeOf<NestedFieldInfo<NestedSchema["nested"]>>()
-      expectTypeOf(nestedFieldinfo.fields.nested.fields.deep).toEqualTypeOf<FieldInfo<string & S.NonEmptyStringBrand>>()
-      expectTypeOf(nestedFieldinfo.fields.nested.fields.nested).toEqualTypeOf<
-        NestedFieldInfo<NestedSchema["nested"]["nested"]>
-      >()
-      expectTypeOf(nestedFieldinfo.fields.nested.fields.nested.fields.deepest).toEqualTypeOf<FieldInfo<number>>()
-
-      // it's a recursive check on actual runtime structure
-      testNestedFieldInfo(nestedFieldinfo)
-      testNestedFieldInfo(nestedFieldinfo.fields.nested)
-      testNestedFieldInfo(nestedFieldinfo.fields.age)
-    })
-    .pipe(Effect.runPromise))
-
-it("buildFieldInfo schema containing class", () =>
-  Effect
-    .gen(function*() {
-      const fieldinfo = buildFieldInfoFromFieldsRoot(SchemaContainsClass)
-
-      // the type system says that these are NestedFieldInfo<NestedSchema>s
-      // are they really? let's check
-      testNestedFieldInfo(fieldinfo.fields.inner)
-      testNestedFieldInfo(fieldinfo.fields.inner.fields.nested.fields.nested)
-    })
-    .pipe(Effect.runPromise))
-
-it("buildFieldInfo with simple union", () =>
-  Effect
-    .gen(function*() {
-      const unionFieldinfo = buildFieldInfoFromFieldsRoot(UnionSchema)
-      expectTypeOf(unionFieldinfo).toEqualTypeOf<NestedFieldInfo<UnionSchema>>()
-      expectTypeOf(unionFieldinfo.fields.nullable).toEqualTypeOf<
-        FieldInfo<string | null>
-      >()
-      expectTypeOf(unionFieldinfo.fields.optional).toEqualTypeOf<
-        FieldInfo<string | undefined>
-      >()
-      expectTypeOf(unionFieldinfo.fields.structsUnion).toEqualTypeOf<
-        UnionFieldInfo<(NestedFieldInfo<NestedSchema> | NestedFieldInfo<SchemaContainsClass>)[]>
-      >()
-      expectTypeOf(unionFieldinfo.fields.generalUnion).toEqualTypeOf<
-        FieldInfo<
-          string | {
-            readonly unionNested: NestedSchema
-          }
-        >
-      >
-
-      // it's a recursive check on actual runtime structure
-      testNestedFieldInfo(unionFieldinfo)
-      testFieldInfo(unionFieldinfo.fields.nullable)
-      testFieldInfo(unionFieldinfo.fields.optional)
-      console.log({ asd: unionFieldinfo.fields.structsUnion })
-      testUnionFieldInfo(unionFieldinfo.fields.structsUnion)
-      testFieldInfo(unionFieldinfo.fields.generalUnion)
-    })
-    .pipe(Effect.runPromise))
-
-it("buildFieldInfo with tagged unions", () =>
-  Effect
-    .gen(function*() {
-      const shapeFieldinfo = buildFieldInfoFromFieldsRoot(ShapeContainer)
-
-      // check at runtime if the structure is really an union
-      testDiscriminatedUnionFieldInfo(shapeFieldinfo.fields.shapeWithClasses)
-      testDiscriminatedUnionFieldInfo(shapeFieldinfo.fields.shapeWithStruct)
-
-      testNestedFieldInfo(shapeFieldinfo.fields.shapeWithClasses.members.Square)
-      expect(shapeFieldinfo.fields.shapeWithClasses.members.Square._infoTag).toBe("Square")
-      testFieldInfo(shapeFieldinfo.fields.shapeWithClasses.members.Square.fields.sideLength)
-
-      testNestedFieldInfo(shapeFieldinfo.fields.shapeWithClasses.members.Triangle)
-      expect(shapeFieldinfo.fields.shapeWithClasses.members.Triangle._infoTag).toBe("Triangle")
-      testFieldInfo(shapeFieldinfo.fields.shapeWithClasses.members.Triangle.fields.base)
-      testFieldInfo(shapeFieldinfo.fields.shapeWithClasses.members.Triangle.fields.height)
-
-      testNestedFieldInfo(shapeFieldinfo.fields.shapeWithClasses.members.Circle)
-      expect(shapeFieldinfo.fields.shapeWithClasses.members.Circle._infoTag).toBe("Circle")
-      testFieldInfo(shapeFieldinfo.fields.shapeWithClasses.members.Circle.fields.radius)
-
-      testNestedFieldInfo(shapeFieldinfo.fields.shapeWithStruct.members.SquareStruct)
-      expect(shapeFieldinfo.fields.shapeWithStruct.members.SquareStruct._infoTag).toBe("SquareStruct")
-      testFieldInfo(shapeFieldinfo.fields.shapeWithStruct.members.SquareStruct.fields.sideLength)
-
-      testNestedFieldInfo(shapeFieldinfo.fields.shapeWithStruct.members.TriangleStruct)
-      expect(shapeFieldinfo.fields.shapeWithStruct.members.TriangleStruct._infoTag).toBe("TriangleStruct")
-      testFieldInfo(shapeFieldinfo.fields.shapeWithStruct.members.TriangleStruct.fields.base)
-      testFieldInfo(shapeFieldinfo.fields.shapeWithStruct.members.TriangleStruct.fields.height)
-
-      testNestedFieldInfo(shapeFieldinfo.fields.shapeWithStruct.members.CircleStruct)
-      expect(shapeFieldinfo.fields.shapeWithStruct.members.CircleStruct._infoTag).toBe("CircleStruct")
-      testFieldInfo(shapeFieldinfo.fields.shapeWithStruct.members.CircleStruct.fields.radius)
-    })
-    .pipe(Effect.runPromise))