@effect-app/vue 1.26.1 → 1.26.4

package/src/makeClient2.ts

@@ -1,62 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { flow, pipe, tuple } from "@effect-app/core/Function"
-import type { MutationResult } from "@effect-app/vue"
-import { Result } from "@effect-app/vue"
 import * as Sentry from "@sentry/browser"
-import { type MaybeRefOrGetter, type Pausable, useIntervalFn, type UseIntervalFnOptions } from "@vueuse/core"
-import { Array, Cause, Effect, Exit, Match, Option, S } from "effect-app"
-import { type SupportedErrors } from "effect-app/client"
+import { Cause, Effect, Exit, Match, Option, S } from "effect-app"
 import { Failure, Success } from "effect-app/Operations"
 import { dropUndefinedT } from "effect-app/utils"
 import { computed, type ComputedRef } from "vue"
+import type { Opts, ResponseErrors } from "./makeClient.js"
 import type { MakeIntlReturn } from "./makeIntl.js"
-import type { MakeMutation2, MutationOptions } from "./mutate2.js"
-
-/**
- * Use this after handling an error yourself, still continueing on the Error track, but the error will not be reported.
- */
-export class SuppressErrors extends Cause.YieldableError {
-  readonly _tag = "SuppressErrors"
-}
-
-export type ResponseErrors = S.ParseResult.ParseError | SupportedErrors | SuppressErrors
-
-export function pauseWhileProcessing(
-  iv: Pausable,
-  pmf: () => Promise<unknown>
-) {
-  return Promise
-    .resolve(iv.pause())
-    .then(() => pmf())
-    .finally(() => iv.resume())
-}
-
-export function useIntervalPauseWhileProcessing(
-  pmf: () => Promise<unknown>,
-  interval?: MaybeRefOrGetter<number>,
-  options?: Omit<UseIntervalFnOptions, "immediateCallback">
-) {
-  const iv = useIntervalFn(
-    () => pauseWhileProcessing(iv, pmf),
-    interval,
-    options ? { ...options, immediateCallback: false } : options
-  )
-  return {
-    isActive: iv.isActive
-  }
-}
-
-export interface Opts<A> extends MutationOptions {
-  suppressErrorToast?: boolean
-  suppressSuccessToast?: boolean
-  successToast?: (a: A) => any
-}
-
-export interface Res<A, E> {
-  readonly loading: boolean
-  readonly data: A | undefined
-  readonly error: E | undefined
-}
+import { mutationResultToVue } from "./mutate.js"
+import type { Res } from "./mutate.js"
+import type { MakeMutation2 } from "./mutate2.js"
 
 type WithAction<A> = A & {
   action: string
@@ -74,33 +27,6 @@ type ActResp<E, A, R> = readonly [
   WithAction<() => Effect<A, E, R>>
 ]
 
-export function mutationResultToVue<A, E>(
-  mutationResult: MutationResult<A, E>
-): Res<A, E> {
-  switch (mutationResult._tag) {
-    case "Loading": {
-      return { loading: true, data: undefined, error: undefined }
-    }
-    case "Success": {
-      return {
-        loading: false,
-        data: mutationResult.data,
-        error: undefined
-      }
-    }
-    case "Error": {
-      return {
-        loading: false,
-        data: undefined,
-        error: mutationResult.error
-      }
-    }
-    case "Initial": {
-      return { loading: false, data: undefined, error: undefined }
-    }
-  }
-}
-
 export const makeClient2 = <Locale extends string, R>(
   useIntl: MakeIntlReturn<Locale>["useIntl"],
   useToast: () => {
@@ -271,19 +197,13 @@ export const makeClient2 = <Locale extends string, R>(
    * Returns a tuple with state ref and execution function which reports errors as Toast.
    */
   const useAndHandleMutation: {
-    <I, E extends ResponseErrors, A, R>(
-      self: {
-        handler: (i: I) => Effect<A, E, R>
-        name: string
-      },
+    <I, E extends ResponseErrors, A, R, Request extends S.TaggedRequest.Any>(
+      self: RequestHandlerWithInput<I, A, E, R, Request>,
       action: string,
       options?: Opts<A>
     ): Resp<I, A, E, R>
-    <E extends ResponseErrors, A, R>(
-      self: {
-        handler: Effect<A, E, R>
-        name: string
-      },
+    <E extends ResponseErrors, A, R, Request extends S.TaggedRequest.Any>(
+      self: RequestHandler<A, E, R, Request>,
       action: string,
       options?: Opts<A>
     ): ActResp<E, A, R>
@@ -291,6 +211,7 @@ export const makeClient2 = <Locale extends string, R>(
     const handleRequestWithToast = useHandleRequestWithToast()
     const [a, b] = useSafeMutation(
       {
+        ...self,
         handler: Effect.isEffect(self.handler)
           ? (pipe(
             Effect.annotateCurrentSpan({ action }),
@@ -300,8 +221,7 @@ export const makeClient2 = <Locale extends string, R>(
             pipe(
               Effect.annotateCurrentSpan({ action }),
               Effect.andThen(self.handler(...args))
-            ),
-        name: self.name
+            )
       },
       dropUndefinedT({
         queryInvalidation: options?.queryInvalidation
@@ -319,37 +239,27 @@ export const makeClient2 = <Locale extends string, R>(
   ) {
     return ((self: any, action: any, options: any) => {
       return useAndHandleMutation(
-        {
-          handler: self.handler,
-          name: self.name
-        },
+        self,
         action,
         { ...defaultOptions, ...options }
       )
     }) as {
-      <I, E extends ResponseErrors, A, R>(
-        self: {
-          handler: (i: I) => Effect<A, E, R>
-          name: string
-        },
+      <I, E extends ResponseErrors, A, R, Request extends S.TaggedRequest.Any>(
+        self: RequestHandlerWithInput<I, A, E, R, Request>,
         action: string,
         options?: Opts<A>
       ): Resp<I, A, E, R>
-      <E extends ResponseErrors, A>(
-        self: {
-          handler: Effect<A, E, R>
-          name: string
-        },
+      <E extends ResponseErrors, A, Request extends S.TaggedRequest.Any>(
+        self: RequestHandler<A, E, R, Request>,
         action: string,
         options?: Opts<A>
       ): ActResp<E, A, R>
     }
   }
 
-  const useSafeMutationWithState = <I, E, A>(self: {
-    handler: (i: I) => Effect<A, E, R>
-    name: string
-  }) => {
+  const useSafeMutationWithState = <I, E, A, Request extends S.TaggedRequest.Any>(
+    self: RequestHandlerWithInput<I, A, E, R, Request>
+  ) => {
     const [a, b] = useSafeMutation(self)
 
     return tuple(
@@ -366,80 +276,14 @@ export const makeClient2 = <Locale extends string, R>(
   }
 }
 
-export const mapHandler: {
-  <I, E, R, A, E2, A2, R2>(
-    self: {
-      handler: (i: I) => Effect<A, E, R>
-      name: string
-      mapPath: (i: I) => string
-    },
-    map: (i: I) => (handler: Effect<A, E, R>) => Effect<A2, E2, R2>
-  ): {
-    handler: (i: I) => Effect<A2, E2, R2>
-    name: string
-    mapPath: (i: I) => string
-  }
-  <E, A, R, E2, A2, R2>(
-    self: {
-      handler: Effect<A, E, R>
-      name: string
-      mapPath: string
-    },
-    map: (handler: Effect<A, E, R>) => Effect<A2, E2, R2>
-  ): {
-    handler: Effect<A2, E2, R2>
-    name: string
-    mapPath: string
-  }
-} = (self: any, map: any): any => ({
-  ...self,
-  handler: typeof self.handler === "function"
-    ? (i: any) => map(i)((self.handler as (i: any) => Effect<any, any, any>)(i))
-    : map(self.handler)
-})
-
-export function composeQueries<
-  R extends Record<string, Result.Result<any, any>>
->(
-  results: R,
-  renderPreviousOnFailure?: boolean
-): Result.Result<
-  {
-    [Property in keyof R]: R[Property] extends Result.Result<infer A, any> ? A
-      : never
-  },
-  {
-    [Property in keyof R]: R[Property] extends Result.Result<any, infer E> ? E
-      : never
-  }[keyof R]
-> {
-  const values = renderPreviousOnFailure
-    ? Object.values(results).map(orPrevious)
-    : Object.values(results)
-  const error = values.find(Result.isFailure)
-  if (error) {
-    return error
-  }
-  const initial = Array.findFirst(values, (x) => x._tag === "Initial" ? Option.some(x) : Option.none())
-  if (initial.value !== undefined) {
-    return initial.value
-  }
-  const loading = Array.findFirst(values, (x) => Result.isInitial(x) && x.waiting ? Option.some(x) : Option.none())
-  if (loading.value !== undefined) {
-    return loading.value
-  }
-
-  const isRefreshing = values.some((x) => x.waiting)
-
-  const r = Object.entries(results).reduce((prev, [key, value]) => {
-    prev[key] = Result.value(value).value
-    return prev
-  }, {} as any)
-  return Result.success(r, isRefreshing)
+export interface RequestHandler<A, E, R, Request extends S.TaggedRequest.Any> {
+  handler: Effect<A, E, R>
+  name: string
+  Request: Request
 }
 
-function orPrevious<E, A>(result: Result.Result<A, E>) {
-  return Result.isFailure(result) && Option.isSome(result.previousValue)
-    ? Result.success(result.previousValue.value, result.waiting)
-    : result
+export interface RequestHandlerWithInput<I, A, E, R, Request extends S.TaggedRequest.Any> {
+  handler: (i: I) => Effect<A, E, R>
+  name: string
+  Request: Request
 }

package/src/mutate.ts

@@ -69,13 +69,13 @@ export interface MutationOptions<A, I = void> {
   onSuccess?: (a: A, i: I) => Promise<unknown>
 }
 
-export const getQueryKey = (name: string) => {
-  const key = makeQueryKey(name)
+export const getQueryKey = (h: { name: string }) => {
+  const key = makeQueryKey(h)
   const ns = key.filter((_) => _.startsWith("$"))
   // we invalidate the parent namespace e.g $project/$configuration.get, we invalidate $project
   // for $project/$configuration/$something.get, we invalidate $project/$configuration
   const k = ns.length ? ns.length > 1 ? ns.slice(0, ns.length - 1) : ns : undefined
-  if (!k) throw new Error("empty query key for: " + name)
+  if (!k) throw new Error("empty query key for: " + h.name)
   return k
 }
 // TODO: more efficient invalidation, including args etc
@@ -180,7 +180,7 @@ export const makeMutation = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
             Effect.tap(() =>
               Effect
                 .suspend(() => {
-                  const queryKey = getQueryKey(self.name)
+                  const queryKey = getQueryKey(self)
 
                   if (options?.queryInvalidation) {
                     const opts = options.queryInvalidation(queryKey, self.name)
@@ -225,3 +225,36 @@ export const makeMutation = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MakeMutation<R> extends ReturnType<typeof makeMutation<R>> {}
+
+export function mutationResultToVue<A, E>(
+  mutationResult: MutationResult<A, E>
+): Res<A, E> {
+  switch (mutationResult._tag) {
+    case "Loading": {
+      return { loading: true, data: undefined, error: undefined }
+    }
+    case "Success": {
+      return {
+        loading: false,
+        data: mutationResult.data,
+        error: undefined
+      }
+    }
+    case "Error": {
+      return {
+        loading: false,
+        data: undefined,
+        error: mutationResult.error
+      }
+    }
+    case "Initial": {
+      return { loading: false, data: undefined, error: undefined }
+    }
+  }
+}
+
+export interface Res<A, E> {
+  readonly loading: boolean
+  readonly data: A | undefined
+  readonly error: E | undefined
+}

package/src/mutate2.ts

@@ -3,10 +3,12 @@ import { tuple } from "@effect-app/core/Function"
 import * as Result from "@effect-rx/rx/Result"
 import type { InvalidateOptions, InvalidateQueryFilters } from "@tanstack/vue-query"
 import { useQueryClient } from "@tanstack/vue-query"
+import type { S } from "effect-app"
 import { Cause, Effect, Exit, Option } from "effect-app"
 import type { ComputedRef, Ref } from "vue"
 import { computed, ref, shallowRef } from "vue"
 import { reportRuntimeError } from "./internal.js"
+import type { RequestHandler, RequestHandlerWithInput } from "./makeClient2.js"
 import { getQueryKey } from "./mutate.js"
 
 export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T)
@@ -78,35 +80,27 @@ export interface MutationOptions {
                 */
 
 export const makeMutation2 = () => {
-  type HandlerWithInput<I, A, E, R> = {
-    handler: (i: I) => Effect<A, E, R>
-    name: string
-  }
-  type Handler<A, E, R> = { handler: Effect<A, E, R>; name: string }
-
   /**
    * Pass a function that returns an Effect, e.g from a client action, or an Effect
    * Returns a tuple with state ref and execution function which reports errors as Toast.
    */
   const useSafeMutation: {
-    <I, E, A, R>(
-      self: HandlerWithInput<I, A, E, R>,
+    <I, E, A, R, Request extends S.TaggedRequest.Any>(
+      self: RequestHandlerWithInput<I, A, E, R, Request>,
       options?: MutationOptions
     ): readonly [
       Readonly<Ref<MutationResult<A, E>>>,
       (i: I) => Effect<A, E, R>
     ]
-    <E, A, R>(self: Handler<A, E, R>, options?: MutationOptions): readonly [
+    <E, A, R, Request extends S.TaggedRequest.Any>(
+      self: RequestHandler<A, E, R, Request>,
+      options?: MutationOptions
+    ): readonly [
       Readonly<Ref<MutationResult<A, E>>>,
       () => Effect<A, E, R> // TODO: remove () =>
     ]
-  } = <I, E, A, R>(
-    self: {
-      handler:
-        | HandlerWithInput<I, A, E, R>["handler"]
-        | Handler<A, E, R>["handler"]
-      name: string
-    },
+  } = <I, E, A, R, Request extends S.TaggedRequest.Any>(
+    self: RequestHandlerWithInput<I, A, E, R, Request> | RequestHandler<A, E, R, Request>,
     options?: MutationOptions
   ) => {
     const queryClient = useQueryClient()
@@ -133,7 +127,7 @@ export const makeMutation2 = () => {
     }
 
     const invalidateCache = Effect.suspend(() => {
-      const queryKey = getQueryKey(self.name)
+      const queryKey = getQueryKey(self)
 
       if (options?.queryInvalidation) {
         const opts = options.queryInvalidation(queryKey, self.name)

package/src/query.ts

@@ -12,7 +12,7 @@ import type {
   UseQueryReturnType
 } from "@tanstack/vue-query"
 import { useQuery } from "@tanstack/vue-query"
-import { Cause, Effect, Option, Runtime, S } from "effect-app"
+import { Array, Cause, Effect, Option, Runtime, S } from "effect-app"
 import { ServiceUnavailableError } from "effect-app/client"
 import { computed, ref } from "vue"
 import type { ComputedRef, Ref, WatchSource } from "vue"
@@ -49,7 +49,6 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
           E,
           R
         >
-        mapPath: (req: I) => string
         name: string
       }
       | {
@@ -58,7 +57,6 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
           E,
           R
         >
-        mapPath: string
         name: string
       },
     arg?: I | WatchSource<I>,
@@ -75,7 +73,7 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
         }
       } as any)
       : ref(arg)
-    const queryKey = makeQueryKey(q.name)
+    const queryKey = makeQueryKey(q)
     const handler = q.handler
     const r = useQuery<unknown, KnownFiberFailure<E>, A>(
       Effect.isEffect(handler)
@@ -162,7 +160,6 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
   function useSafeQuery<E, A>(
     self: {
       handler: Effect<A, E, R>
-      mapPath: string
       name: string
     },
     options?: QueryObserverOptionsCustom // TODO
@@ -175,7 +172,6 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
   function useSafeQuery<Arg, E, A>(
     self: {
       handler: (arg: Arg) => Effect<A, E, R>
-      mapPath: (arg: Arg) => string
       name: string
     },
     arg: Arg | WatchSource<Arg>,
@@ -198,7 +194,6 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
         E,
         R
       >
-      mapPath: (req: I) => string
       name: string
     }
     | {
@@ -207,7 +202,6 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
         E,
         R
       >
-      mapPath: string
       name: string
     },
   */
@@ -223,3 +217,49 @@ export const makeQuery = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MakeQuery<R> extends ReturnType<typeof makeQuery<R>> {}
+
+export function composeQueries<
+  R extends Record<string, Result.Result<any, any>>
+>(
+  results: R,
+  renderPreviousOnFailure?: boolean
+): Result.Result<
+  {
+    [Property in keyof R]: R[Property] extends Result.Result<infer A, any> ? A
+      : never
+  },
+  {
+    [Property in keyof R]: R[Property] extends Result.Result<any, infer E> ? E
+      : never
+  }[keyof R]
+> {
+  const values = renderPreviousOnFailure
+    ? Object.values(results).map(orPrevious)
+    : Object.values(results)
+  const error = values.find(Result.isFailure)
+  if (error) {
+    return error
+  }
+  const initial = Array.findFirst(values, (x) => x._tag === "Initial" ? Option.some(x) : Option.none())
+  if (initial.value !== undefined) {
+    return initial.value
+  }
+  const loading = Array.findFirst(values, (x) => Result.isInitial(x) && x.waiting ? Option.some(x) : Option.none())
+  if (loading.value !== undefined) {
+    return loading.value
+  }
+
+  const isRefreshing = values.some((x) => x.waiting)
+
+  const r = Object.entries(results).reduce((prev, [key, value]) => {
+    prev[key] = Result.value(value).value
+    return prev
+  }, {} as any)
+  return Result.success(r, isRefreshing)
+}
+
+function orPrevious<E, A>(result: Result.Result<A, E>) {
+  return Result.isFailure(result) && Option.isSome(result.previousValue)
+    ? Result.success(result.previousValue.value, result.waiting)
+    : result
+}

package/src/query2.ts

@@ -17,6 +17,7 @@ import { ServiceUnavailableError } from "effect-app/client"
 import { computed, ref } from "vue"
 import type { ComputedRef, Ref, WatchSource } from "vue"
 import { makeQueryKey, reportRuntimeError } from "./internal.js"
+import type { RequestHandler, RequestHandlerWithInput } from "./makeClient2.js"
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface QueryObserverOptionsCustom<
@@ -39,28 +40,10 @@ export const makeQuery2 = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
   // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
   // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryDefinedReturnType<TData, TError>;
   // declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, queryClient?: QueryClient): UseQueryReturnType<TData, TError>;
-  const useSafeQuery_ = <I, A, E>(
+  const useSafeQuery_ = <I, A, E, Request extends S.TaggedRequest.Any>(
     q:
-      | {
-        readonly handler: (
-          req: I
-        ) => Effect<
-          A,
-          E,
-          R
-        >
-        mapPath: (req: I) => string
-        name: string
-      }
-      | {
-        readonly handler: Effect<
-          A,
-          E,
-          R
-        >
-        mapPath: string
-        name: string
-      },
+      | RequestHandlerWithInput<I, A, E, R, Request>
+      | RequestHandler<A, E, R, Request>,
     arg?: I | WatchSource<I>,
     options: QueryObserverOptionsCustom<unknown, KnownFiberFailure<E>, A> = {} // TODO
   ) => {
@@ -75,7 +58,7 @@ export const makeQuery2 = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
         }
       } as any)
       : ref(arg)
-    const queryKey = makeQueryKey(q.name)
+    const queryKey = makeQueryKey(q)
     const handler = q.handler
     const r = useQuery<unknown, KnownFiberFailure<E>, A>(
       Effect.isEffect(handler)
@@ -141,6 +124,8 @@ export const makeQuery2 = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
       result,
       latestSuccess,
       // 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>>`
+      // and always ends up in the success channel, even when error..
       (options?: RefetchOptions) => Effect.promise(() => r.refetch(options)),
       r
     ] as const
@@ -165,12 +150,8 @@ export const makeQuery2 = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
     return Result.initial(r.isValidating)
   }
 
-  function useSafeQuery<E, A>(
-    self: {
-      handler: Effect<A, E, R>
-      mapPath: string
-      name: string
-    },
+  function useSafeQuery<E, A, Request extends S.TaggedRequest.Any>(
+    self: RequestHandler<A, E, R, Request>,
     options?: QueryObserverOptionsCustom // TODO
   ): readonly [
     ComputedRef<Result.Result<A, E>>,
@@ -178,12 +159,8 @@ export const makeQuery2 = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
     (options?: RefetchOptions) => Effect<QueryObserverResult<A, KnownFiberFailure<E>>>,
     UseQueryReturnType<any, any>
   ]
-  function useSafeQuery<Arg, E, A>(
-    self: {
-      handler: (arg: Arg) => Effect<A, E, R>
-      mapPath: (arg: Arg) => string
-      name: string
-    },
+  function useSafeQuery<Arg, E, A, Request extends S.TaggedRequest.Any>(
+    self: RequestHandlerWithInput<Arg, A, E, R, Request>,
     arg: Arg | WatchSource<Arg>,
     options?: QueryObserverOptionsCustom // TODO
   ): readonly [
@@ -194,29 +171,6 @@ export const makeQuery2 = <R>(runtime: Ref<Runtime.Runtime<R>>) => {
   ]
   function useSafeQuery(
     self: any,
-    /*
-  q:
-    | {
-      handler: (
-        req: I
-      ) => Effect<
-        A,
-        E,
-        R
-      >
-      mapPath: (req: I) => string
-      name: string
-    }
-    | {
-      handler: Effect<
-        A,
-        E,
-        R
-      >
-      mapPath: string
-      name: string
-    },
-  */
     argOrOptions?: any,
     options?: any
   ) {

package/dist/hooks.d.ts

@@ -1,3 +0,0 @@
-export * from "./mutate.js";
-export * from "./query.js";
-//# sourceMappingURL=hooks.d.ts.map

package/dist/index.d.ts

@@ -1,7 +0,0 @@
-export * as Result from "@effect-rx/rx/Result";
-export * from "./hooks.js";
-export * from "./makeClient.js";
-export * from "./makeContext.js";
-export * from "./makeIntl.js";
-export * from "./runtime.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/makeContext.d.ts

@@ -1,5 +0,0 @@
-export declare const makeContext: <T>(def: T) => {
-    use: () => T;
-    provide: (locale: T) => void;
-};
-//# sourceMappingURL=makeContext.d.ts.map