chore: upgrade TSTyche (#4877)

Author: mrazauskas

package.json

@@ -69,7 +69,7 @@
     "playwright": "^1.52.0",
     "prettier": "^3.5.3",
     "rimraf": "^6.0.1",
-    "tstyche": "^4.0.0-beta.9",
+    "tstyche": "^4.0.0-rc.0",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vite": "^6.1.1",

packages/effect/dtslint/Function.tst.ts

@@ -1,5 +1,5 @@
 import { flow, Function, identity, Option, pipe } from "effect"
-import { describe, it } from "tstyche"
+import { describe, expect, it } from "tstyche"
 
 describe("Function", () => {
   describe("pipe", () => {
@@ -37,17 +37,14 @@ describe("Function", () => {
     const arg2 = (a: string, b: number) => `${a}${b}`
     const arg3 = (a: number) => a
 
-    const _a1: number = apply1(countArgs)
-    const _a2: string = apply1(arg1)
-    // @ts-expect-error: Target signature provides too few arguments. Expected 2 or more, but got 1.
-    apply1(arg2)
-    // @ts-expect-error: Type 'string' is not assignable to type 'number'.
-    apply1(arg3)
+    expect(apply1(countArgs)).type.toBe<number>()
+    expect(apply1(arg1)).type.toBe<string>()
+    expect(apply1).type.not.toBeCallableWith(arg2)
+    expect(apply1).type.not.toBeCallableWith(arg3)
 
-    const _b1: number = apply2(countArgs)
-    const _b2: string = apply2(arg1)
-    const _b3: string = apply2(arg2)
-    // @ts-expect-error: Type 'string' is not assignable to type 'number'.
-    apply1(arg3)
+    expect(apply2(countArgs)).type.toBe<number>()
+    expect(apply2(arg1)).type.toBe<string>()
+    expect(apply2(arg2)).type.toBe<string>()
+    expect(apply1).type.not.toBeCallableWith(arg3)
   })
 })

packages/effect/dtslint/Option.tst.ts

@@ -187,8 +187,7 @@ describe("Option", () => {
       expect(Option.firstSomeOf<number>).type.not.toBeCallableWith(
         [number, string]
       )
-      pipe(
-        // @ts-expect-error: Type 'string' is not assignable to type 'number'
+      expect(pipe).type.not.toBeCallableWith(
         [number, string],
         Option.firstSomeOf<number>
       )

packages/effect/dtslint/Schema/Brand.tst.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { pipe, Schema } from "effect"
-import { describe, it } from "tstyche"
+import { describe, expect, it } from "tstyche"
 
 const Int1 = Symbol.for("Int")
 const Int2 = Symbol.for("Int")
@@ -11,12 +11,9 @@ const schema2 = pipe(Schema.Number, Schema.int(), Schema.brand(Int2))
 type A1 = Schema.Schema.Type<typeof schema1>
 type A2 = Schema.Schema.Type<typeof schema2>
 
-declare const a2: A2
-declare const f: (int: A1) => void
-
 describe("SchemaBrand", () => {
-  it("We should only have one error for the missing definition", () => {
-    // @ts-expect-error
-    f(a2)
+  it("should differentiate between branded schema types", () => {
+    expect<A1>().type.not.toBeAssignableTo<A2>()
+    expect<A2>().type.not.toBeAssignableTo<A1>()
   })
 })

packages/effect/dtslint/Schema/Schema.tst.ts

@@ -2412,17 +2412,15 @@ describe("Schema", () => {
   })
 
   it("withDecodingDefault", () => {
-    S.Struct({
-      a: S.optional(S.String).pipe(
+    when(S.Struct).isCalledWith({
+      a: when(S.optional(S.String).pipe).isCalledWith(
         S.withConstructorDefault(() => undefined),
-        // @ts-expect-error
-        S.withDecodingDefault(() => "")
+        expect(S.withDecodingDefault).type.not.toBeCallableWith(() => "")
       )
     })
-    S.Struct({
-      a: S.optional(S.String).pipe(
-        // @ts-expect-error
-        S.withDecodingDefault(() => undefined)
+    when(S.Struct).isCalledWith({
+      a: when(S.optional(S.String).pipe).isCalledWith(
+        expect(S.withDecodingDefault).type.not.toBeCallableWith(() => undefined)
       )
     })
     expect(
@@ -2435,12 +2433,10 @@ describe("Schema", () => {
   })
 
   it("withDefaults", () => {
-    S.Struct({
-      a: S.optional(S.String).pipe(
-        S.withDefaults({
-          // @ts-expect-error
+    when(S.Struct).isCalledWith({
+      a: when(S.optional(S.String).pipe).isCalledWith(
+        expect(S.withDefaults).type.not.toBeCallableWith({
           decoding: () => undefined,
-          // @ts-expect-error
           constructor: () => undefined
         })
       )
@@ -2753,9 +2749,8 @@ describe("Schema", () => {
         // should allow generic context
         const _f1 = <A extends string>(schema: S.Schema<A>) => schema.pipe(S.maxLength(5))
         const _f2 = <A extends string>(schema: S.Schema<A>) =>
-          schema.pipe(
-            // @ts-expect-error: Type 'string' is not assignable to type 'number'
-            S.greaterThan(5)
+          when(schema.pipe).isCalledWith(
+            expect(S.greaterThan).type.not.toBeCallableWith(5)
           )
         // should allow string subtypes
         pipe(
@@ -3540,12 +3535,8 @@ describe("Schema", () => {
       >(schema: S.Schema<A, I>) => S.DataFromSelf(schema)
       const _f3 = <A extends Readonly<Record<string, unknown>> | ReadonlyArray<unknown>, I extends number>(
         schema: S.Schema<A, I>
-      ) =>
-        // @ts-expect-error: Type 'number' is not assignable to type 'Readonly<Record<string, unknown>>'
-        S.DataFromSelf(schema)
-      const _f4 = <A extends string>(schema: S.Schema<A>) =>
-        // @ts-expect-error: Type 'string' is not assignable to type 'Readonly<Record<string, unknown>>'
-        S.DataFromSelf(schema)
+      ) => expect(S.DataFromSelf).type.not.toBeCallableWith(schema)
+      const _f4 = <A extends string>(schema: S.Schema<A>) => expect(S.DataFromSelf).type.not.toBeCallableWith(schema)
 
       // should allow mutable arguments
       S.DataFromSelf(S.mutable(S.Struct({ a: S.NumberFromString })))
@@ -4105,8 +4096,7 @@ describe("Schema", () => {
     })
 
     it("head", () => {
-      // @ts-expect-error: Type 'string' is not assignable to type 'readonly unknown[]'
-      S.String.pipe(S.head)
+      expect(S.String.pipe).type.not.toBeCallableWith(S.head)
 
       const schema = S.head(S.Array(S.NumberFromString))
 
@@ -4120,8 +4110,7 @@ describe("Schema", () => {
     })
 
     it("headNonEmpty", () => {
-      // @ts-expect-error: Type 'string' is not assignable to type 'readonly [unknown, ...unknown[]]'
-      S.String.pipe(S.headNonEmpty)
+      expect(S.String.pipe).type.not.toBeCallableWith(S.headNonEmpty)
 
       const schema = S.headNonEmpty(S.NonEmptyArray(S.Number))
       expect(S.asSchema(schema)).type.toBe<S.Schema<number, readonly [number, ...Array<number>]>>()
@@ -4134,8 +4123,7 @@ describe("Schema", () => {
     })
 
     it("headOrElse", () => {
-      // @ts-expect-error: Type 'string' is not assignable to type 'readonly unknown[]'
-      S.String.pipe(S.headOrElse())
+      expect(S.String.pipe).type.not.toBeCallableWith(S.headOrElse())
       expect(S.headOrElse).type.not.toBeCallableWith(S.Array(S.Number), () => "a")
       when(S.Array(S.Number).pipe).isCalledWith(expect(S.headOrElse).type.not.toBeCallableWith(() => "a"))