@effect/vitest 0.26.0 → 4.0.0-beta.0

package/package.json

@@ -1,51 +1,52 @@
 {
   "name": "@effect/vitest",
-  "version": "0.26.0",
-  "description": "A set of helpers for testing Effects with vitest",
+  "version": "4.0.0-beta.0",
+  "type": "module",
   "license": "MIT",
+  "description": "A set of helpers for testing Effects with vitest",
+  "homepage": "https://effect.website",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Effect-TS/effect.git",
+    "url": "https://github.com/Effect-TS/effect-smol.git",
     "directory": "packages/vitest"
   },
+  "bugs": {
+    "url": "https://github.com/Effect-TS/effect-smol/issues"
+  },
   "sideEffects": [],
-  "homepage": "https://effect.website",
-  "peerDependencies": {
-    "vitest": "^3.2.0",
-    "effect": "^3.18.0"
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js",
+    "./internal/*": null,
+    "./*/index": null
   },
+  "files": [
+    "src/**/*.ts",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map"
+  ],
   "publishConfig": {
+    "access": "public",
     "provenance": true
   },
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/dts/index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "types": "./dist/dts/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "default": "./dist/cjs/index.js"
-    },
-    "./index": {
-      "types": "./dist/dts/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "default": "./dist/cjs/index.js"
-    },
-    "./utils": {
-      "types": "./dist/dts/utils.d.ts",
-      "import": "./dist/esm/utils.js",
-      "default": "./dist/cjs/utils.js"
-    }
+  "peerDependencies": {
+    "vitest": "^3.0.0",
+    "effect": "^4.0.0-beta.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.0",
+    "vitest": "4.0.18",
+    "effect": "^4.0.0-beta.0"
   },
-  "typesVersions": {
-    "*": {
-      "index": [
-        "./dist/dts/index.d.ts"
-      ],
-      "utils": [
-        "./dist/dts/utils.d.ts"
-      ]
-    }
+  "scripts": {
+    "build": "tsc -b tsconfig.json && pnpm babel",
+    "build:tsgo": "tsgo -b tsconfig.json && pnpm babel",
+    "babel": "babel dist --plugins annotate-pure-calls --out-dir dist --source-maps",
+    "check": "tsc -b tsconfig.json",
+    "test": "vitest",
+    "coverage": "vitest --coverage"
   }
 }

package/src/index.ts

@@ -3,13 +3,12 @@
  */
 import type * as Duration from "effect/Duration"
 import type * as Effect from "effect/Effect"
-import type * as FC from "effect/FastCheck"
 import type * as Layer from "effect/Layer"
 import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
-import type * as TestServices from "effect/TestServices"
+import type * as FC from "effect/testing/FastCheck"
 import * as V from "vitest"
-import * as internal from "./internal/internal.js"
+import * as internal from "./internal/internal.ts"
 
 /**
  * @since 1.0.0
@@ -19,43 +18,7 @@ export * from "vitest"
 /**
  * @since 1.0.0
  */
-export type API =
-  & { scopedFixtures: V.TestAPI<{}>["scoped"] }
-  & { [K in keyof V.TestAPI<{}>]: K extends "scoped" ? unknown : V.TestAPI<{}>[K] }
-  & TestCollectorCallable
-
-interface TestCollectorCallable<C = object> {
-  /**
-   * @deprecated Use options as the second argument instead
-   */
-  <ExtraContext extends C>(
-    name: string | Function,
-    fn: V.TestFunction<ExtraContext>,
-    options: TestCollectorOptions
-  ): void
-  <ExtraContext extends C>(
-    name: string | Function,
-    fn?: V.TestFunction<ExtraContext>,
-    options?: number | TestCollectorOptions
-  ): void
-  <ExtraContext extends C>(
-    name: string | Function,
-    options?: TestCollectorOptions,
-    fn?: V.TestFunction<ExtraContext>
-  ): void
-}
-
-type TestCollectorOptions = {
-  concurrent?: boolean
-  sequential?: boolean
-  only?: boolean
-  skip?: boolean
-  todo?: boolean
-  fails?: boolean
-  timeout?: number
-  retry?: number
-  repeats?: number
-}
+export type API = V.TestAPI<{}>
 
 /**
  * @since 1.0.0
@@ -83,8 +46,8 @@ export namespace Vitest {
    * @since 1.0.0
    */
   export type Arbitraries =
-    | Array<Schema.Schema.Any | FC.Arbitrary<any>>
-    | { [K in string]: Schema.Schema.Any | FC.Arbitrary<any> }
+    | Array<Schema.Schema<any> | FC.Arbitrary<any>>
+    | { [K in string]: Schema.Schema<any> | FC.Arbitrary<any> }
 
   /**
    * @since 1.0.0
@@ -110,7 +73,11 @@ export namespace Vitest {
         E,
         R,
         [
-          { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
+          {
+            [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T
+              : Arbs[K] extends Schema.Schema<infer T> ? T
+              : never
+          },
           V.TestContext
         ]
       >,
@@ -118,7 +85,10 @@ export namespace Vitest {
         | number
         | V.TestOptions & {
           fastCheck?: FC.Parameters<
-            { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> }
+            {
+              [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Arbs[K] extends Schema.Schema<infer T> ? T
+              : never
+            }
           >
         }
     ) => void
@@ -127,22 +97,19 @@ export namespace Vitest {
   /**
    * @since 1.0.0
    */
-  export interface MethodsNonLive<R = never, ExcludeTestServices extends boolean = false> extends API {
-    readonly effect: Vitest.Tester<(ExcludeTestServices extends true ? never : TestServices.TestServices) | R>
+  export interface MethodsNonLive<R = never> extends API {
+    readonly effect: Vitest.Tester<R | Scope.Scope>
     readonly flakyTest: <A, E, R2>(
-      self: Effect.Effect<A, E, R2>,
+      self: Effect.Effect<A, E, R2 | Scope.Scope>,
       timeout?: Duration.DurationInput
     ) => Effect.Effect<A, never, R2>
-    readonly scoped: Vitest.Tester<
-      (ExcludeTestServices extends true ? never : TestServices.TestServices) | Scope.Scope | R
-    >
     readonly layer: <R2, E>(layer: Layer.Layer<R2, E, R>, options?: {
       readonly timeout?: Duration.DurationInput
     }) => {
-      (f: (it: Vitest.MethodsNonLive<R | R2, ExcludeTestServices>) => void): void
+      (f: (it: Vitest.MethodsNonLive<R | R2>) => void): void
       (
         name: string,
-        f: (it: Vitest.MethodsNonLive<R | R2, ExcludeTestServices>) => void
+        f: (it: Vitest.MethodsNonLive<R | R2>) => void
       ): void
     }
 
@@ -153,14 +120,20 @@ export namespace Vitest {
       name: string,
       arbitraries: Arbs,
       self: (
-        properties: { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
+        properties: {
+          [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Arbs[K] extends Schema.Schema<infer T> ? T
+          : never
+        },
         ctx: V.TestContext
       ) => void,
       timeout?:
         | number
         | V.TestOptions & {
           fastCheck?: FC.Parameters<
-            { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> }
+            {
+              [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Arbs[K] extends Schema.Schema<infer T> ? T
+              : never
+            }
           >
         }
     ) => void
@@ -170,8 +143,7 @@ export namespace Vitest {
    * @since 1.0.0
    */
   export interface Methods<R = never> extends MethodsNonLive<R> {
-    readonly live: Vitest.Tester<R>
-    readonly scopedLive: Vitest.Tester<Scope.Scope | R>
+    readonly live: Vitest.Tester<Scope.Scope | R>
   }
 }
 
@@ -183,22 +155,12 @@ export const addEqualityTesters: () => void = internal.addEqualityTesters
 /**
  * @since 1.0.0
  */
-export const effect: Vitest.Tester<TestServices.TestServices> = internal.effect
+export const effect: Vitest.Tester<Scope.Scope> = internal.effect
 
 /**
  * @since 1.0.0
  */
-export const scoped: Vitest.Tester<TestServices.TestServices | Scope.Scope> = internal.scoped
-
-/**
- * @since 1.0.0
- */
-export const live: Vitest.Tester<never> = internal.live
-
-/**
- * @since 1.0.0
- */
-export const scopedLive: Vitest.Tester<Scope.Scope> = internal.scopedLive
+export const live: Vitest.Tester<Scope.Scope> = internal.live
 
 /**
  * Share a `Layer` between multiple tests, optionally wrapping
@@ -208,13 +170,13 @@ export const scopedLive: Vitest.Tester<Scope.Scope> = internal.scopedLive
  *
  * ```ts
  * import { expect, layer } from "@effect/vitest"
- * import { Context, Effect, Layer } from "effect"
+ * import { Effect, Layer, ServiceMap } from "effect"
  *
- * class Foo extends Context.Tag("Foo")<Foo, "foo">() {
+ * class Foo extends ServiceMap.Service("Foo")<Foo, "foo">() {
  *   static Live = Layer.succeed(Foo, "foo")
  * }
  *
- * class Bar extends Context.Tag("Bar")<Bar, "bar">() {
+ * class Bar extends ServiceMap.Service("Bar")<Bar, "bar">() {
  *   static Live = Layer.effect(
  *     Bar,
  *     Effect.map(Foo, () => "bar" as const)
@@ -223,42 +185,40 @@ export const scopedLive: Vitest.Tester<Scope.Scope> = internal.scopedLive
  *
  * layer(Foo.Live)("layer", (it) => {
  *   it.effect("adds context", () =>
- *     Effect.gen(function* () {
+ *     Effect.gen(function*() {
  *       const foo = yield* Foo
  *       expect(foo).toEqual("foo")
- *     })
- *   )
+ *     }))
  *
  *   it.layer(Bar.Live)("nested", (it) => {
  *     it.effect("adds context", () =>
- *       Effect.gen(function* () {
+ *       Effect.gen(function*() {
  *         const foo = yield* Foo
  *         const bar = yield* Bar
  *         expect(foo).toEqual("foo")
  *         expect(bar).toEqual("bar")
- *       })
- *     )
+ *       }))
  *   })
  * })
  * ```
  */
-export const layer: <R, E, const ExcludeTestServices extends boolean = false>(
+export const layer: <R, E>(
   layer_: Layer.Layer<R, E>,
   options?: {
     readonly memoMap?: Layer.MemoMap
     readonly timeout?: Duration.DurationInput
-    readonly excludeTestServices?: ExcludeTestServices
+    readonly excludeTestServices?: boolean
   }
 ) => {
-  (f: (it: Vitest.MethodsNonLive<R, ExcludeTestServices>) => void): void
-  (name: string, f: (it: Vitest.MethodsNonLive<R, ExcludeTestServices>) => void): void
+  (f: (it: Vitest.MethodsNonLive<R>) => void): void
+  (name: string, f: (it: Vitest.MethodsNonLive<R>) => void): void
 } = internal.layer
 
 /**
  * @since 1.0.0
  */
 export const flakyTest: <A, E, R>(
-  self: Effect.Effect<A, E, R>,
+  self: Effect.Effect<A, E, R | Scope.Scope>,
   timeout?: Duration.DurationInput
 ) => Effect.Effect<A, never, R> = internal.flakyTest
 
@@ -272,20 +232,17 @@ export const prop: Vitest.Methods["prop"] = internal.prop
  */
 
 /** @ignored */
-const methods = { effect, live, flakyTest, scoped, scopedLive, layer, prop } as const
+const methods = { effect, live, flakyTest, layer, prop } as const
 
 /**
  * @since 1.0.0
  */
-export const it: Vitest.Methods = Object.assign(V.it, {
-  ...methods,
-  scopedFixtures: V.it.scoped.bind(V.it)
-})
+export const it: Vitest.Methods = Object.assign(V.it, methods)
 
 /**
  * @since 1.0.0
  */
-export const makeMethods: (it: API) => Vitest.Methods = internal.makeMethods
+export const makeMethods: (it: V.TestAPI) => Vitest.Methods = internal.makeMethods
 
 /**
  * @since 1.0.0