@effect-app/vue 2.93.8 → 4.0.0-beta.0

package/src/query.ts

@@ -3,13 +3,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import * as Result from "@effect-atom/atom/Result"
-import { isHttpClientError } from "@effect/platform/HttpClientError"
 import { type DefaultError, type Enabled, type InitialDataFunction, type NonUndefinedGuard, type PlaceholderDataFunction, type QueryKey, type QueryObserverOptions, type QueryObserverResult, type RefetchOptions, useQuery as useTanstackQuery, useQueryClient, type UseQueryDefinedReturnType, type UseQueryReturnType } from "@tanstack/vue-query"
-import { Array, Cause, Effect, Option, Runtime, S } from "effect-app"
+import { Array, Cause, Effect, Exit, flow, Option, S, type ServiceMap } from "effect-app"
 import { type Req } from "effect-app/client"
 import type { RequestHandler, RequestHandlerWithInput } from "effect-app/client/clientFor"
 import { ServiceUnavailableError } from "effect-app/client/errors"
 import { type Span } from "effect/Tracer"
+import { isHttpClientError } from "effect/unstable/http/HttpClientError"
 import { computed, type ComputedRef, type MaybeRefOrGetter, ref, shallowRef, watch, type WatchSource } from "vue"
 import { makeQueryKey, reportRuntimeError } from "./lib.js"
 
@@ -74,11 +74,15 @@ export interface CustomDefinedPlaceholderQueryOptions<
     | PlaceholderDataFunction<NonFunctionGuard<TQueryData>, TError, NonFunctionGuard<TQueryData>, TQueryKey>
 }
 
-export interface KnownFiberFailure<E> extends Runtime.FiberFailure {
-  readonly [Runtime.FiberFailureCauseId]: Cause.Cause<E>
+export class KnownFiberFailure<E> extends Error {
+  readonly error: unknown
+  constructor(public effectCause: Cause.Cause<E>) {
+    super("Query failed with cause: " + Cause.squash(effectCause))
+    this.error = Cause.squash(effectCause)
+  }
 }
 
-export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
+export const makeQuery = <R>(getRuntime: () => ServiceMap.ServiceMap<R>) => {
   const useQuery_: {
     <I, A, E, Request extends Req, Name extends string>(
       q:
@@ -126,7 +130,14 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
     options?: any
     // TODO
   ) => {
-    const runPromise = Runtime.runPromise(getRuntime())
+    // we wrap into KnownFiberFailure because we want to keep the full cause of the failure.
+    const runPromise = flow(Effect.runPromiseExitWith(getRuntime()), (_) =>
+      _.then(
+        Exit.match({
+          onFailure: (cause) => Promise.reject(new KnownFiberFailure(cause)),
+          onSuccess: (value) => Promise.resolve(value)
+        })
+      ))
     const arr = arg
     const req: { value: I } = !arg
       ? undefined
@@ -145,10 +156,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         ? {
           ...options,
           retry: (retryCount, error) => {
-            if (Runtime.isFiberFailure(error)) {
-              const cause = error[Runtime.FiberFailureCauseId]
-              const sq = Cause.squash(cause)
-              if (!isHttpClientError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+            if (error instanceof KnownFiberFailure) {
+              if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
                 return false
               }
             }
@@ -160,8 +169,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
             runPromise(
               handler
                 .pipe(
-                  Effect.tapDefect(reportRuntimeError),
-                  Effect.withSpan(`query ${q.id}`, { captureStackTrace: false }),
+                  Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)),
+                  Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }),
                   meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
                 ),
               { signal }
@@ -170,10 +179,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
         : {
           ...options,
           retry: (retryCount, error) => {
-            if (Runtime.isFiberFailure(error)) {
-              const cause = error[Runtime.FiberFailureCauseId]
-              const sq = Cause.squash(cause)
-              if (!isHttpClientError(sq) && !S.is(ServiceUnavailableError)(sq)) {
+            if (error instanceof KnownFiberFailure) {
+              if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
                 return false
               }
             }
@@ -185,8 +192,8 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
             runPromise(
               handler(req.value)
                 .pipe(
-                  Effect.tapDefect(reportRuntimeError),
-                  Effect.withSpan(`query ${q.id}`, { captureStackTrace: false }),
+                  Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)),
+                  Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }),
                   meta?.["span"] ? Effect.withParentSpan(meta["span"] as Span) : (_) => _
                 ),
               { signal }
@@ -209,7 +216,7 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
       result,
       computed(() => latestSuccess.value),
       // one thing to keep in mind is that span will be disconnected as Context does not pass from outside.
-      // TODO: consider how we should handle the Result here which is `QueryObserverResult<A, KnownFiberFailure<E>>`
+      // TODO: consider how we should handle the Result here which is `QueryObserverResult<A, E>`
       // and always ends up in the success channel, even when error..
       (options?: RefetchOptions) =>
         Effect.currentSpan.pipe(
@@ -225,9 +232,9 @@ export const makeQuery = <R>(getRuntime: () => Runtime.Runtime<R>) => {
     data: A | undefined
     isValidating: boolean
   }): Result.Result<A, E> {
-    if (r.error) {
+    if (r.error !== undefined) {
       return Result.failureWithPrevious(
-        r.error[Runtime.FiberFailureCauseId],
+        r.error.effectCause,
         {
           previous: r.data === undefined ? Option.none() : Option.some(Result.success(r.data)),
           waiting: r.isValidating

package/src/routeParams.ts

@@ -12,34 +12,18 @@ export function getQueryParam(search: ParsedQuery, param: string) {
   return v ?? null
 }
 
-export const getQueryParamO = flow(getQueryParam, Option.fromNullable)
+export const getQueryParamO = flow(getQueryParam, Option.fromNullishOr)
 
-export const parseOpt = <E, A>(t: S.Schema<A, E, never>) => {
-  const dec = flow(S.decodeUnknownEither(t), (x) =>
-    x._tag === "Right"
-      ? Option.some(x.right)
-      : Option.none())
-  return dec
-}
-
-export const parseOptUnknown = <E, A>(t: S.Schema<A, E, never>) => {
-  const dec = flow(S.decodeUnknownEither(t), (x) =>
-    x._tag === "Right"
-      ? Option.some(x.right)
-      : Option.none())
-  return dec
-}
-
-export function parseRouteParamsOption<NER extends Record<string, Schema<any, any, never>>>(
-  query: Record<string, any>,
-  t: NER // enforce non empty
+export function parseRouteParamsOption<NER extends Record<string, S.Codec<any, any>>>(query: Record<string, any>, t: NER // enforce non empty
 ): {
   [K in keyof NER]: Option.Option<Schema.Type<NER[K]>>
 } {
   return typedKeysOf(t).reduce(
     (prev, cur) => {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      prev[cur] = getQueryParamO(query, cur as string).pipe(Option.flatMap(parseOpt(t[cur]!)))
+      prev[cur] = getQueryParamO(query, cur as string).pipe(
+        Option.flatMap(S.decodeUnknownOption(t[cur]!))
+      )
 
       return prev
     },
@@ -49,7 +33,7 @@ export function parseRouteParamsOption<NER extends Record<string, Schema<any, an
   )
 }
 
-export function parseRouteParams<NER extends Record<string, Schema<any, any, never>>>(
+export function parseRouteParams<NER extends Record<string, S.Codec<any, any>>>(
   query: Record<string, any>,
   t: NER // enforce non empty
 ): {
@@ -58,7 +42,9 @@ export function parseRouteParams<NER extends Record<string, Schema<any, any, nev
   return typedKeysOf(t).reduce(
     (prev, cur) => {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      prev[cur] = S.decodeUnknownSync(t[cur]!)((query as any)[cur])
+      prev[cur] = S.decodeUnknownSync(t[cur]!)(
+        (query as any)[cur]
+      )
 
       return prev
     },

package/src/runtime.ts

@@ -3,12 +3,12 @@ import { Effect, Layer, Logger } from "effect-app"
 
 export function makeAppRuntime<A, E>(layer: Layer.Layer<A, E>) {
   return Effect.gen(function*() {
-    layer = layer.pipe(
-      Layer.provide(Logger.replace(Logger.defaultLogger, Logger.withSpanAnnotations(Logger.prettyLogger())))
-    )
-    const mrt = ManagedRuntime.make(layer)
-    yield* mrt.runtimeEffect
-    return Object.assign(mrt as ManagedRuntime.ManagedRuntime<A, never>, {
+    const l = layer.pipe(
+      Layer.provide(Logger.layer([Logger.consolePretty()]))
+    ) as Layer.Layer<A, never>
+    const mrt = ManagedRuntime.make(l)
+    yield* mrt.servicesEffect
+    return Object.assign(mrt, {
       [Symbol.dispose]() {
         return Effect.runSync(mrt.disposeEffect)
       },

package/test/Mutation.test.ts

@@ -1,12 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { it } from "@effect/vitest"
 import { Cause, Effect, Exit, Fiber, Option } from "effect-app"
-import { type RuntimeFiber } from "effect/Fiber"
 import { CommandContext, DefaultIntl } from "../src/experimental/commander.js"
 import { Result } from "../src/lib.js"
 import { useExperimental } from "./stubs.js"
 
-const unwrap = <A, E>(r: RuntimeFiber<Exit.Exit<A, E>, never>) => Fiber.join(r).pipe(Effect.flatten)
+const unwrap = <A, E>(r: Fiber.Fiber<Exit.Exit<A, E>, never>) => Fiber.join(r).pipe(Effect.flatten)
 
 // declare const mutation: {
 //   name: "myMutation"
@@ -72,9 +71,9 @@ describe("alt2", () => {
               expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
             })),
             Effect.tap(() =>
-              Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+              Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
             ),
-            Effect.tap(() => executed = true)
+            Effect.tap(() => Effect.sync(() => executed = true))
           )
         )
 
@@ -126,9 +125,9 @@ it.live("works", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
         ),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       expect(command.action).toBe("Test Action")
       expect(command.id).toBe("Test Action")
@@ -176,9 +175,9 @@ it.live("works non-gen", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
         ),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       expect(command.action).toBe("Test Action")
 
@@ -211,7 +210,7 @@ it.live("has custom action name", () =>
           expect(yield* CommandContext).toMatchObject({ action: "Test Action Translated", id: "Test Action" })
           return "test-value"
         },
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       expect(command.action).toBe("Test Action Translated")
       const r = yield* unwrap(command.handle())
@@ -235,7 +234,7 @@ it.live("can map the result", () =>
           return "test-value"
         },
         Effect.map((_) => _ + _),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       const r = yield* unwrap(command.handle())
 
@@ -257,7 +256,7 @@ it.live("can receive and use input", () =>
 
           return { input1, input2 }
         },
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       const r = yield* unwrap(command.handle(1))
 
@@ -285,8 +284,8 @@ it.live("can replace the result", () =>
 
           return "test-value"
         },
-        Effect.zipRight(Effect.succeed(42)),
-        Effect.tap(() => executed = true)
+        Effect.andThen(Effect.succeed(42)),
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
       const r = yield* unwrap(command.handle())
 
@@ -318,7 +317,7 @@ it.live("with toasts", () =>
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
         })),
         Effect.tap(() =>
-          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
         ),
         // WithToast.handle({
         //   onFailure: "failed",
@@ -326,7 +325,7 @@ it.live("with toasts", () =>
         //   onWaiting: null
         // }),
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* unwrap(command.handle())
@@ -352,16 +351,16 @@ it.live("interrupted", () =>
           return "test-value"
         },
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we were interrupted after all :)
-      expect(Exit.isInterrupted(r)).toBe(true) // to confirm that the initial function has interrupted
+      expect(Exit.hasInterrupts(r)).toBe(true) // to confirm that the initial function has interrupted
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isInterrupted(Result.toExit(command.result))).toBe(true)
+      expect(Exit.hasInterrupts(Result.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(0) // toast is removed on interruption. TODO: maybe a nicer user experience can be had?
     }))
 
@@ -378,13 +377,13 @@ it.live("fail", () =>
           return yield* Effect.fail({ message: "Boom!" })
         },
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we failed after all :)
-      expect(Exit.isFailure(r) && Cause.isFailure(r.cause)).toBe(true) // to confirm that the initial function has failed
+      expect(Exit.isFailure(r) && Cause.hasFails(r.cause)).toBe(true) // to confirm that the initial function has failed
 
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)
@@ -404,9 +403,9 @@ it.live("fail and recover", () =>
           expect(toasts.length).toBe(1)
           return yield* Effect.fail({ message: "Boom!" })
         },
-        Effect.catchAll(() => Effect.succeed("recovered")), // we recover from the error here, so the final result is success
+        Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* unwrap(command.handle())
@@ -433,14 +432,14 @@ it.live("defect", () =>
           return yield* Effect.die({ message: "Boom!" })
         },
         Command.withDefaultToast(),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       )
 
       const r = yield* Fiber.join(command.handle())
       // TODO: confirm we reported error
 
       expect(executed).toBe(false) // we died after all :)
-      expect(Exit.isFailure(r) && Cause.isDie(r.cause)).toBe(true) // to confirm that the initial function has died
+      expect(Exit.isFailure(r) && Cause.hasDies(r.cause)).toBe(true) // to confirm that the initial function has died
 
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)
@@ -472,9 +471,9 @@ it.live("works with alt", () =>
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
           })),
           Effect.tap(() =>
-            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
           ),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
       expect(command.action).toBe("Test Action")
@@ -509,7 +508,7 @@ it.live("has custom action name with alt", () =>
             expect(yield* CommandContext).toMatchObject({ action: "Test Action Translated", id: "Test Action" })
             return "test-value"
           },
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
       expect(command.action).toBe("Test Action Translated")
@@ -534,7 +533,7 @@ it.live("can map the result with alt", () =>
           return "test-value"
         },
         Effect.map((_) => _ + _),
-        Effect.tap(() => executed = true)
+        Effect.tap(() => Effect.sync(() => executed = true))
       ))
       const r = yield* unwrap(command.handle())
 
@@ -560,7 +559,7 @@ it.live("can receive and use input with alt", () =>
             }
           )
           .pipe(
-            Effect.tap(() => executed = true)
+            Effect.tap(() => Effect.sync(() => executed = true))
           )
       )
       const r = yield* unwrap(command.handle(1))
@@ -590,8 +589,8 @@ it.live("can replace the result with alt", () =>
 
             return "test-value"
           },
-          Effect.zipRight(Effect.succeed(42)),
-          Effect.tap(() => executed = true)
+          Effect.andThen(Effect.succeed(42)),
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
       const r = yield* unwrap(command.handle())
@@ -625,10 +624,10 @@ it.live("with toasts with alt", () =>
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
           })),
           Effect.tap(() =>
-            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+            Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => Effect.sync(() => expect(_).toBe("Test Action"))))
           ),
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
@@ -657,17 +656,17 @@ it.live("interrupted with alt", () =>
             return "test-value"
           },
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we were interrupted after all :)
-      expect(Exit.isInterrupted(r)).toBe(true) // to confirm that the initial function has interrupted
+      expect(Exit.hasInterrupts(r)).toBe(true) // to confirm that the initial function has interrupted
 
       expect(command.waiting).toBe(false)
-      expect(Exit.isInterrupted(Result.toExit(command.result))).toBe(true)
+      expect(Exit.hasInterrupts(Result.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(0) // toast is removed on interruption. TODO: maybe a nicer user experience can be had?
     }))
 
@@ -685,14 +684,14 @@ it.live("fail with alt", () =>
             return yield* Effect.fail({ message: "Boom!" })
           },
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
       const r = yield* Fiber.join(command.handle())
 
       expect(executed).toBe(false) // we failed after all :)
-      expect(Exit.isFailure(r) && Cause.isFailure(r.cause)).toBe(true) // to confirm that the initial function has failed
+      expect(Exit.isFailure(r) && Cause.hasFails(r.cause)).toBe(true) // to confirm that the initial function has failed
 
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)
@@ -713,9 +712,9 @@ it.live("fail and recover with alt", () =>
             expect(toasts.length).toBe(1)
             return yield* Effect.fail({ message: "Boom!" })
           },
-          Effect.catchAll(() => Effect.succeed("recovered")), // we recover from the error here, so the final result is success
+          Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
@@ -744,7 +743,7 @@ it.live("defect with alt", () =>
             return yield* Effect.die({ message: "Boom!" })
           },
           Command.withDefaultToast(),
-          Effect.tap(() => executed = true)
+          Effect.tap(() => Effect.sync(() => executed = true))
         )
       )
 
@@ -752,7 +751,7 @@ it.live("defect with alt", () =>
       // TODO: confirm we reported error
 
       expect(executed).toBe(false) // we died after all :)
-      expect(Exit.isFailure(r) && Cause.isDie(r.cause)).toBe(true) // to confirm that the initial function has died
+      expect(Exit.isFailure(r) && Cause.hasDies(r.cause)).toBe(true) // to confirm that the initial function has died
 
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(Result.toExit(command.result))).toBe(true)

package/test/dist/form.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"form.test.d.ts","sourceRoot":"","sources":["../form.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGtC,qBAAa,YAAa,SAAQ,iBAShC;CAAG;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAK/B;CAAG;;;;;;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;;;;;;;;AAEL,cAAM,QAAS,SAAQ,aAGrB;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG"}
+{"version":3,"file":"form.test.d.ts","sourceRoot":"","sources":["../form.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;AAGtC,qBAAa,YAAa,SAAQ,iBAShC;CAAG;;;;AAEL,qBAAa,mBAAoB,SAAQ,wBAEvC;CAAG;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAK/B;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;AAEL,cAAM,MAAO,SAAQ,WAEnB;CAAG;;;;;;;;;;;AAEL,cAAM,QAAS,SAAQ,aAGrB;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG"}