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

package/dist/query.js

@@ -2,123 +2,393 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { useQuery as useTanstackQuery, useQueryClient } from "@tanstack/vue-query";
-import { Array, Cause, Effect, Exit, flow, Option, S } from "effect-app";
-import { ServiceUnavailableError } from "effect-app/client/errors";
-import { isHttpClientError } from "effect/unstable/http/HttpClientError";
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { injectRegistry, useAtomValue } from "@effect/atom-vue";
+import * as Array from "effect-app/Array";
+import { makeQueryKey } from "effect-app/client";
+import * as Effect from "effect-app/Effect";
+import * as Option from "effect-app/Option";
+import * as Exit from "effect/Exit";
+import * as Stream from "effect/Stream";
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
-import { computed, ref, shallowRef, watch } from "vue";
-import { makeQueryKey, reportRuntimeError } from "./lib.js";
-export class KnownFiberFailure extends Error {
-    effectCause;
-    error;
-    constructor(effectCause) {
-        super("Query failed with cause: " + Cause.squash(effectCause));
-        this.effectCause = effectCause;
-        this.error = Cause.squash(effectCause);
+import * as Atom from "effect/unstable/reactivity/Atom";
+import { computed, effectScope, onBeforeUnmount, onMounted, onScopeDispose, ref, toValue } from "vue";
+import { awaitAtomResult, buildQueryFamily, buildStreamQueryFamily, disabledQueryAtom, isStaleResult, queryKeyForAtom, refreshAtomWithCurrentSpan, staleTimeMsOf, withQueryOptions } from "./atomQuery.js";
+import { latestDefined } from "./suspense.js";
+const useScopedSuspenseSetup = (setup) => {
+    const scope = effectScope();
+    const controller = new AbortController();
+    const value = scope.run(setup);
+    if (value === undefined) {
+        throw new Error("Internal Error: atom suspense setup scope did not initialize");
     }
-}
-export const makeQuery = (getRuntime) => {
-    const useQuery_ = (q) => (arg, 
-    // todo QueryKey type would be [string, ...string[]], but with I it would be [string, ...string[], I]
-    options
-    // TODO
-    ) => {
-        // 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 = !arg
-            ? undefined
-            : typeof arr === "function"
-                ? {
-                    get value() {
-                        return arr();
-                    }
-                }
-                : ref(arg);
-        const queryKey = makeQueryKey(q);
-        const handler = q.handler;
-        const defaultOptions = {
-            // we do not want to throw errors, because we turn the success and error responses into a Result type
-            // why don't we turn the error/success response into a Result type before returning to tanstack query? because we want to leverage tanstack query's retry and caching mechanism, which relies on throwing errors to trigger retries, and we don't want to interfere with that by catching the errors too early.
-            // but if we allow tanstack query to throw, it will trigger the error boundary in Vue - via a "watcher callback" error - which we currently report and log, which is not what we want.
-            // TODO: we might want to rethink the strategy of how to handle errors that happen after the initial load.
-            // For suspense, the initial load is captured by the suspense boundary.
-            // For subsequent loads (or non suspense use) we currently are required to use the QueryResult component to conditionally render error/loading/etc.
-            throwOnError: false
-        };
-        const r = useTanstackQuery(Effect.isEffect(handler)
-            ? {
-                ...defaultOptions,
-                ...options,
-                retry: (retryCount, error) => {
-                    if (error instanceof KnownFiberFailure) {
-                        if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
-                            return false;
-                        }
-                    }
-                    return retryCount < 5;
-                },
-                queryKey,
-                queryFn: ({ meta, signal }) => runPromise(handler
-                    .pipe(Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)), Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }), meta?.["span"] ? Effect.withParentSpan(meta["span"]) : (_) => _), { signal })
+    const isMounted = ref(true);
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        isMounted.value = false;
+        controller.abort();
+        scope.stop();
+    };
+    onBeforeUnmount(stop);
+    onScopeDispose(stop);
+    return [value, isMounted, controller.signal];
+};
+const queryFamilyCacheKey = (q) => `${makeQueryKey(q).join("/")}:${q.queryKeyProjectionHash ?? ""}`;
+// One atom family per request shape, keyed by the stable query key + projection hash (not the
+// handler object — `clientFor` returns a fresh proxy per call, so the object isn't shareable).
+// Module-level + key-indexed => the family is process-global, so the same request+input read
+// the same atom across components/pages => cross-page caching via the global registry.
+const queryFamilyByKey = new Map();
+const getQueryFamily = (rt, q) => {
+    const key = queryFamilyCacheKey(q);
+    let f = queryFamilyByKey.get(key);
+    if (!f) {
+        f = buildQueryFamily(rt, q);
+        queryFamilyByKey.set(key, f);
+    }
+    return f;
+};
+const streamQueryFamilyByKey = new Map();
+const getStreamQueryFamily = (rt, q) => {
+    const key = queryFamilyCacheKey(q);
+    let f = streamQueryFamilyByKey.get(key);
+    if (!f) {
+        f = buildStreamQueryFamily(rt, q);
+        streamQueryFamilyByKey.set(key, f);
+    }
+    return f;
+};
+const makeAtomQueryCacheUpdater = (warnIfMissing) => ({
+    update: (registry, query, input, updater) => {
+        const family = queryFamilyByKey.get(queryFamilyCacheKey(query));
+        if (!family) {
+            if (warnIfMissing) {
+                console.warn(`Query ${query.id} has not been used yet; nothing to update`);
             }
-            : {
-                ...defaultOptions,
-                ...options,
-                retry: (retryCount, error) => {
-                    if (error instanceof KnownFiberFailure) {
-                        if (!isHttpClientError(error.error) && !S.is(ServiceUnavailableError)(error.error)) {
-                            return false;
-                        }
-                    }
-                    return retryCount < 5;
-                },
-                queryKey: [...queryKey, req],
-                queryFn: ({ meta, signal }) => runPromise(handler(req.value)
-                    .pipe(Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)), Effect.withSpan(`query ${q.id}`, {}, { captureStackTrace: false }), meta?.["span"] ? Effect.withParentSpan(meta["span"]) : (_) => _), { signal })
-            });
-        const latestSuccess = shallowRef();
-        const result = computed(() => swrToQuery({
-            error: r.error.value ?? undefined,
-            data: r.data.value === undefined ? latestSuccess.value : r.data.value, // we fall back to existing data, as tanstack query might loose it when the key changes
-            isValidating: r.isFetching.value
-        }));
-        // not using `computed` here as we have a circular dependency
-        watch(result, (value) => latestSuccess.value = Option.getOrUndefined(AsyncResult.value(value)), { immediate: true });
-        return [
-            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, E>`
-            // and always ends up in the success channel, even when error..
-            (options) => Effect.currentSpan.pipe(Effect.orElseSucceed(() => null), Effect.flatMap((span) => Effect.promise(() => r.refetch({ ...options, updateMeta: { span } })))),
-            r
-        ];
+            return;
+        }
+        const atom = family(input);
+        const current = registry.get(atom);
+        const next = AsyncResult.map(current, updater);
+        registry.set(atom, next);
+    }
+});
+export const atomQueryCacheUpdater = makeAtomQueryCacheUpdater(true);
+export const optionalAtomQueryCacheUpdater = makeAtomQueryCacheUpdater(false);
+export const combineQueryCacheUpdaters = (first, second) => ({
+    update: (registry, query, input, updater) => {
+        first.update(registry, query, input, updater);
+        second.update(registry, query, input, updater);
+    }
+});
+let activeQueryCacheUpdater = atomQueryCacheUpdater;
+export const setQueryCacheUpdater = (updater) => {
+    activeQueryCacheUpdater = updater;
+};
+/**
+ * Layer TanStack `initialData` / `placeholderData` over a raw query result as a DISPLAY fallback.
+ * Only while the result is still `Initial` (pending, never settled): show `initialData` as resolved
+ * data, or `placeholderData` as provisional (`waiting: true`). Once real data exists the seed is
+ * dropped. Failures are never masked — including failures without `previousSuccess` (where
+ * `AsyncResult.value` is empty). `placeholderData` in function form receives the last seen concrete
+ * value for basic keep-previous across input changes. Returns the raw ref untouched when neither
+ * option is set. Neither value is written to the atom cache.
+ */
+export const withDataFallback = (
+// Structural read so both Ref and Readonly<Ref> from useAtomValue are accepted.
+rawResult, options) => {
+    const opts = options;
+    const initialData = opts?.initialData;
+    const placeholderData = opts?.placeholderData;
+    if (initialData === undefined && placeholderData === undefined) {
+        // Identity when no fallback options. Callers that need a real ComputedRef
+        // (e.g. useAtomValue's Readonly<Ref>) wrap before calling this helper.
+        return rawResult;
+    }
+    let lastData;
+    return computed(() => {
+        const r = rawResult.value;
+        const concrete = AsyncResult.value(r);
+        if (Option.isSome(concrete)) {
+            lastData = concrete.value;
+        }
+        // Fallback is pending-only. Failure (even without previousSuccess) and Success pass through.
+        if (!AsyncResult.isInitial(r)) {
+            return r;
+        }
+        if (initialData !== undefined) {
+            const v = typeof initialData === "function" ? initialData() : initialData;
+            return AsyncResult.success(v, { waiting: r.waiting });
+        }
+        const v = typeof placeholderData === "function"
+            ? placeholderData(lastData)
+            : placeholderData;
+        return v === undefined ? r : AsyncResult.success(v, { waiting: true });
+    });
+};
+const normalizeQueryOptions = (options) => {
+    const out = {};
+    if (options?.staleTime !== undefined)
+        out.staleTime = options.staleTime;
+    const gcTime = options?.idleTTL ?? options?.gcTime;
+    if (gcTime !== undefined)
+        out.gcTime = gcTime;
+    const revalidateOnFocus = options?.revalidateOnFocus ?? options?.refetchOnWindowFocus;
+    if (revalidateOnFocus !== undefined)
+        out.revalidateOnFocus = revalidateOnFocus;
+    if (options?.structuralSharing !== undefined)
+        out.structuralSharing = options.structuralSharing;
+    const refetchInterval = options?.refreshEvery ?? options?.refetchInterval;
+    if (refetchInterval !== undefined)
+        out.refetchInterval = refetchInterval;
+    if (options?.live !== undefined)
+        out.live = options.live;
+    if (options?.invalidation !== undefined)
+        out.invalidation = options.invalidation;
+    return out;
+};
+export const useAtomQuery = (atom) => {
+    const registry = injectRegistry();
+    const atomRef = computed(atom);
+    const atomResult = useAtomValue(() => atomRef.value);
+    const result = computed(() => atomResult.value);
+    const refresh = () => registry.refresh(atomRef.value);
+    const awaitResult = () => awaitAtomResult(registry, atomRef.value);
+    const refetch = () => Effect.gen(function* () {
+        yield* refreshAtomWithCurrentSpan(registry, atomRef.value);
+        return yield* awaitResult();
+    });
+    const data = computed(() => Option.getOrUndefined(AsyncResult.value(result.value)));
+    return {
+        result,
+        data,
+        awaitResult,
+        refetch,
+        refresh,
+        registry,
+        atom: atomRef
     };
-    function swrToQuery(r) {
-        if (r.error !== undefined) {
-            return AsyncResult.failureWithPrevious(r.error.effectCause, {
-                previous: r.data === undefined ? Option.none() : Option.some(AsyncResult.success(r.data)),
-                waiting: r.isValidating
-            });
+};
+export const useAtomSuspense = (atom) => {
+    const [{ view, data }, isMounted, signal] = useScopedSuspenseSetup(() => {
+        const view = useAtomQuery(atom);
+        const data = latestDefined(() => view.data.value, "atom suspense");
+        return { view, data };
+    });
+    const eff = Effect.gen(function* () {
+        const exit = yield* view.awaitResult().pipe(Effect.exit);
+        if (!isMounted.value) {
+            return yield* Effect.interrupt;
         }
-        if (r.data !== undefined) {
-            return AsyncResult.success(r.data, { waiting: r.isValidating });
+        if (Exit.isFailure(exit)) {
+            return yield* Exit.failCause(exit.cause);
         }
-        return AsyncResult.initial(r.isValidating);
+        const fetch = (_options) => view.refetch();
+        const handle = {
+            awaitResult: view.awaitResult,
+            refetch: view.refetch,
+            refresh: view.refresh,
+            registry: view.registry,
+            atom: view.atom
+        };
+        return Object.assign([
+            view.result,
+            data,
+            fetch,
+            handle
+        ], {
+            ...view,
+            data
+        });
+    });
+    return Effect.runPromise(eff, { signal });
+};
+export const useAtomStreamQuery = (atom) => {
+    const registry = injectRegistry();
+    const atomRef = computed(atom);
+    const atomResult = useAtomValue(() => atomRef.value);
+    const result = computed(() => atomResult.value);
+    const pull = () => registry.set(atomRef.value, void 0);
+    const refresh = () => registry.refresh(atomRef.value);
+    const awaitResult = () => awaitAtomResult(registry, atomRef.value);
+    const pullAndAwait = () => Effect.gen(function* () {
+        pull();
+        return yield* awaitResult();
+    });
+    const items = computed(() => Option.getOrElse(Option.map(AsyncResult.value(result.value), (_) => _.items), () => []));
+    const latest = computed(() => items.value.at(-1));
+    const done = computed(() => Option.getOrElse(Option.map(AsyncResult.value(result.value), (_) => _.done), () => false));
+    return {
+        result,
+        items,
+        latest,
+        done,
+        awaitResult,
+        pull,
+        pullAndAwait,
+        refresh,
+        registry,
+        atom: atomRef
+    };
+};
+const optionValue = (arr, options) => {
+    if (options?.mode === "optional") {
+        const getOption = typeof arr === "function"
+            ? arr
+            : () => arr.value;
+        return [
+            {
+                get value() {
+                    return Option.getOrUndefined(getOption());
+                }
+            },
+            computed(() => Option.isSome(getOption()))
+        ];
     }
-    const useQuery = (self) => {
-        const q = useQuery_(self);
-        return (argOrOptions, options) => Effect.isEffect(self.handler)
-            ? q(undefined, argOrOptions)
-            : q(argOrOptions, options);
+    const req = !arr
+        ? ({ value: undefined })
+        : typeof arr === "function"
+            ? ({
+                get value() {
+                    return arr();
+                }
+            })
+            : ref(arr);
+    const enabled = options?.enabled;
+    return [req, computed(() => enabled === undefined ? true : !!toValue(enabled))];
+};
+const observedAtom = (atom, options) => withQueryOptions(atom, normalizeQueryOptions(options), queryKeyForAtom(atom));
+const observedStreamAtom = (atom, options) => {
+    let next = atom;
+    const refetchInterval = options?.refreshEvery ?? options?.refetchInterval;
+    if (refetchInterval !== undefined)
+        next = Atom.withRefresh(refetchInterval)(next);
+    const gcTime = options?.idleTTL ?? options?.gcTime;
+    if (gcTime === "infinity")
+        return Atom.keepAlive(next);
+    if (gcTime !== undefined)
+        return Atom.setIdleTTL(next, gcTime);
+    return next;
+};
+const queryAtomFor = (rt, q, arg, options) => {
+    const family = getQueryFamily(rt, q);
+    return observedAtom(family(arg), options);
+};
+const makeQueryView = (getAtomRt, q, arg, options) => {
+    const atomRt = getAtomRt();
+    const registry = injectRegistry();
+    const [req, enabledRef] = optionValue(arg, options);
+    const family = getQueryFamily(atomRt, q);
+    const atomRef = computed(() => enabledRef.value ? observedAtom(family(req.value), options) : disabledQueryAtom);
+    // useAtomValue returns Readonly<Ref>, not ComputedRef — re-wrap before withDataFallback / QueryView.
+    const rawAtomResult = useAtomValue(() => atomRef.value);
+    const rawResult = computed(() => rawAtomResult.value);
+    // `initialData` / `placeholderData` display fallback (old `.query()` API). Applied only while the
+    // result is still Initial; Failures/Success pass through unmasked. Neither is written to cache
+    // (the base atom stays Initial, so the mount-staleness check still triggers the real fetch). The
+    // fallback runs PRE-select, matching TanStack (`initialData`/`placeholderData` are TQueryData).
+    const fallbackResult = withDataFallback(rawResult, options);
+    const select = options?.select;
+    const result = (select
+        ? computed(() => AsyncResult.map(fallbackResult.value, select))
+        : fallbackResult);
+    const refresh = () => registry.refresh(atomRef.value);
+    const awaitResult = () => select
+        ? awaitAtomResult(registry, atomRef.value).pipe(Effect.map(select))
+        : awaitAtomResult(registry, atomRef.value);
+    const refetch = () => Effect.gen(function* () {
+        yield* refreshAtomWithCurrentSpan(registry, atomRef.value);
+        return yield* awaitResult();
+    });
+    const staleMs = staleTimeMsOf(normalizeQueryOptions(options));
+    onMounted(() => {
+        if (!enabledRef.value)
+            return;
+        if (isStaleResult(registry.get(atomRef.value), staleMs))
+            refresh();
+    });
+    const data = computed(() => Option.getOrUndefined(AsyncResult.value(result.value)));
+    return {
+        result,
+        data,
+        awaitResult,
+        refetch,
+        refresh,
+        registry,
+        atom: atomRef
     };
+};
+export const makeQueryFamily = (_getRuntime, getAtomRt) => {
+    const useQueryFamily = (q) => getQueryFamily(getAtomRt(), q);
+    return useQueryFamily;
+};
+export const makeQueryAtom = (_getRuntime, getAtomRt) => {
+    const useQueryAtom = (q) => (arg, options) => queryAtomFor(getAtomRt(), q, arg, options);
+    return useQueryAtom;
+};
+export const makeQueryNew = (_getRuntime, getAtomRt) => {
+    const useQueryNew = (q) => (arg, options) => makeQueryView(getAtomRt, q, arg, options);
+    return useQueryNew;
+};
+export const makeQuery = (_getRuntime, getAtomRt) => {
+    const useQuery_ = (q) => (arg, options) => {
+        const view = makeQueryView(getAtomRt, q, arg, options);
+        // 4th element is internal-only; the public `.suspense()` Promise boundary lives in makeClient.
+        const handle = {
+            awaitResult: view.awaitResult,
+            refetch: view.refetch,
+            refresh: view.refresh,
+            registry: view.registry,
+            atom: view.atom
+        };
+        return [
+            view.result,
+            view.data,
+            (_options) => view.refetch(),
+            handle
+        ];
+    };
+    const useQuery = ((self) => {
+        const q = useQuery_(self);
+        return (arg, options) => q(arg, options);
+    });
     return useQuery;
 };
+const streamQueryAtomFor = (rt, q, arg, options) => {
+    const family = getStreamQueryFamily(rt, q);
+    return observedStreamAtom(family(arg), options);
+};
+export const makeStreamQueryFamily = (_getRuntime, getAtomRt) => {
+    const useStreamQueryFamily = (q) => getStreamQueryFamily(getAtomRt(), q);
+    return useStreamQueryFamily;
+};
+export const makeStreamQueryAtom = (_getRuntime, getAtomRt) => {
+    const useStreamQueryAtom = (q) => (arg, options) => streamQueryAtomFor(getAtomRt(), q, arg, options);
+    return useStreamQueryAtom;
+};
+export const makeStreamQueryNew = (_getRuntime, getAtomRt) => {
+    const useStreamQueryNew = (q) => (arg, options) => useAtomStreamQuery(() => streamQueryAtomFor(getAtomRt(), q, toValue(arg), options));
+    return useStreamQueryNew;
+};
+export const makeStreamQuery = (getRuntime, getAtomRt) => {
+    const query = makeQuery(getRuntime, getAtomRt);
+    // A stream query is an ordinary atom query over an effect that collects the whole stream
+    // into an array (`Stream.runCollect`). It reuses all the atom machinery (family cache, swr,
+    // invalidation, structural sharing). Note: unlike the old tanstack `streamedQuery`, the result
+    // appears once the stream completes, not incrementally (stream queries are not used today).
+    const streamQuery_ = (q) => {
+        const hook = query({
+            id: q.id,
+            options: q.options,
+            handler: (i) => Stream.runCollect(q.handler(i)).pipe(Effect.map((chunk) => [...chunk]))
+        });
+        return (arg) => hook(arg);
+    };
+    return streamQuery_;
+};
 function orPrevious(result) {
     return AsyncResult.isFailure(result) && Option.isSome(result.previousSuccess)
         ? AsyncResult.success(result.previousSuccess.value, { waiting: result.waiting })
@@ -148,20 +418,8 @@ export function composeQueries(results, renderPreviousOnFailure) {
     return AsyncResult.success(r, { waiting: isRefreshing });
 }
 export const useUpdateQuery = () => {
-    const queryClient = useQueryClient();
-    const f = (query, updateOrInput, updaterMaybe) => {
-        const updater = updaterMaybe !== undefined ? updaterMaybe : updateOrInput;
-        const key = updaterMaybe !== undefined
-            ? [...makeQueryKey(query), updateOrInput]
-            : makeQueryKey(query);
-        const data = queryClient.getQueryData(key);
-        if (data) {
-            queryClient.setQueryData(key, updater);
-        }
-        else {
-            console.warn(`Query data for key ${key} not found`, key);
-        }
-    };
+    const registry = injectRegistry();
+    const f = (query, input, updater) => activeQueryCacheUpdater.update(registry, query, input, updater);
     return f;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"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"}

package/dist/queryLifetime.d.ts

@@ -0,0 +1,25 @@
+import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import * as Atom from "effect/unstable/reactivity/Atom";
+/**
+ * Per-query observer count + invalidation flag. Lives on the family atom so
+ * invalidate can mark stale and refetch only when someone is looking
+ * (TanStack refetchType: "active").
+ */
+export interface QueryLifetime {
+    observers: number;
+    invalidated: boolean;
+}
+export declare const queryLifetimeOf: (atom: Atom.Atom<any>) => QueryLifetime | undefined;
+export declare const attachQueryLifetime: <A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => QueryLifetime;
+/**
+ * Count this subscription as an observer of `family`. On remount, consume a
+ * pending invalidation and refresh the family atom.
+ */
+export declare const observeQueryAtom: <A, E>(family: Atom.Atom<AsyncResult.AsyncResult<A, E>>) => Atom.Atom<AsyncResult.AsyncResult<A, E>>;
+/**
+ * Idle queries with a lifetime are marked stale. Queries that still have
+ * observers (or have no lifetime, e.g. ad-hoc registry mounts of a raw
+ * effect atom) are refetched now.
+ */
+export declare const atomsToRefetch: <A, E>(atoms: ReadonlyArray<Atom.Atom<AsyncResult.AsyncResult<A, E>>>) => ReadonlyArray<Atom.Atom<AsyncResult.AsyncResult<A, E>>>;
+//# sourceMappingURL=queryLifetime.d.ts.map

package/dist/queryLifetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryLifetime.d.ts","sourceRoot":"","sources":["../src/queryLifetime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,WAAW,MAAM,wCAAwC,CAAA;AAC1E,OAAO,KAAK,IAAI,MAAM,iCAAiC,CAAA;AAEvD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,OAAO,CAAA;CACrB;AAYD,eAAO,MAAM,eAAe,SAAU,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAG,aAAa,GAAG,SACnB,CAAA;AAEpD,eAAO,MAAM,mBAAmB,GAAI,CAAC,EAAE,CAAC,QAChC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAC7C,aAOF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,UAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAC/C,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAazC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,SAC1B,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAC7D,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAQxD,CAAA"}