@depup/apollo__client 4.1.6-depup.0

package/react/index.react-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.react-server.js","sourceRoot":"","sources":["../../src/react/index.react-server.ts"],"names":[],"mappings":"AAMA,SAAS,qBAAqB,CAC5B,OAAe,EACf,IAAuB;IAEvB,OAAO;QACL,CAAC,IAAI,CAAC;YACJ,MAAM,IAAI,KAAK,CACb,OAAO,OAAO,IAAI,IAAI,8EAA8E,CACrG,CAAC;QACJ,CAAC;KACF,CAAC,IAAI,CAAC,CAAC;AACV,CAAC;AAKD,kBAAkB;AAClB,MAAM,CAAC,MAAM,cAAc,GAAG,qBAAqB,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;AACnF,kBAAkB;AAClB,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,UAAU,EAAG,kBAAkB,CAAC,CAAC;AACvF,kBAAkB;AAClB,MAAM,CAAC,MAAM,oBAAoB,GAAG,qBAAqB,CAAC,UAAU,EAAC,sBAAsB,CAAC,CAAC;AAC7F,kBAAkB;AAClB,MAAM,CAAC,MAAM,eAAe,GAAG,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAChF,kBAAkB;AAClB,MAAM,CAAC,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,MAAM,EAAC,oBAAoB,CAAC,CAAC;AACrF,kBAAkB;AAClB,MAAM,CAAC,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AACxE,kBAAkB;AAClB,MAAM,CAAC,MAAM,YAAY,GAAG,qBAAqB,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAC1E,kBAAkB;AAClB,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,MAAM,EAAC,kBAAkB,CAAC,CAAC;AACjF,kBAAkB;AAClB,MAAM,CAAC,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AACxE,kBAAkB;AAClB,MAAM,CAAC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAClE,kBAAkB;AAClB,MAAM,CAAC,MAAM,mBAAmB,GAAG,qBAAqB,CAAC,MAAM,EAAC,qBAAqB,CAAC,CAAC;AACvF,kBAAkB;AAClB,MAAM,CAAC,MAAM,cAAc,GAAG,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAC9E,kBAAkB;AAClB,MAAM,CAAC,MAAM,YAAY,GAAG,qBAAqB,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAC1E,kBAAkB;AAClB,MAAM,CAAC,MAAM,eAAe,GAAG,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAChF,kBAAkB;AAClB,MAAM,CAAC,MAAM,mBAAmB,GAAG,qBAAqB,CAAC,MAAM,EAAC,qBAAqB,CAAC,CAAC;AACvF,kBAAkB;AAClB,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,MAAM,EAAC,kBAAkB,CAAC,CAAC;AAEjF,yGAAyG;AACzG,kFAAkF;AAClF,+BAA+B","sourcesContent":["type Exported = typeof import(\"./index.js\");\ntype ExportedFunctions = {\n  [K in keyof Exported]: Exported[K] extends (...args: any[]) => any ? K\n  : never;\n}[keyof Exported];\n\nfunction missingFeatureWarning(\n  feature: string,\n  name: ExportedFunctions\n): () => never {\n  return {\n    [name]() {\n      throw new Error(\n        `The ${feature} ${name} is not supported in React Server Components, but only in Client Components.`\n      );\n    },\n  }[name];\n}\n\n// eslint-disable-next-line no-restricted-syntax\nexport type * from \"./index.js\";\n\n// prettier-ignore\nexport const ApolloProvider = missingFeatureWarning(\"component\", \"ApolloProvider\");\n// prettier-ignore\nexport const getApolloContext = missingFeatureWarning(\"function\",  \"getApolloContext\");\n// prettier-ignore\nexport const createQueryPreloader = missingFeatureWarning(\"function\",\"createQueryPreloader\");\n// prettier-ignore\nexport const useApolloClient = missingFeatureWarning(\"hook\", \"useApolloClient\");\n// prettier-ignore\nexport const useBackgroundQuery = missingFeatureWarning(\"hook\",\"useBackgroundQuery\");\n// prettier-ignore\nexport const useFragment = missingFeatureWarning(\"hook\", \"useFragment\");\n// prettier-ignore\nexport const useLazyQuery = missingFeatureWarning(\"hook\", \"useLazyQuery\");\n// prettier-ignore\nexport const useLoadableQuery = missingFeatureWarning(\"hook\",\"useLoadableQuery\");\n// prettier-ignore\nexport const useMutation = missingFeatureWarning(\"hook\", \"useMutation\");\n// prettier-ignore\nexport const useQuery = missingFeatureWarning(\"hook\", \"useQuery\");\n// prettier-ignore\nexport const useQueryRefHandlers = missingFeatureWarning(\"hook\",\"useQueryRefHandlers\");\n// prettier-ignore\nexport const useReactiveVar = missingFeatureWarning(\"hook\", \"useReactiveVar\");\n// prettier-ignore\nexport const useReadQuery = missingFeatureWarning(\"hook\", \"useReadQuery\");\n// prettier-ignore\nexport const useSubscription = missingFeatureWarning(\"hook\", \"useSubscription\");\n// prettier-ignore\nexport const useSuspenseFragment = missingFeatureWarning(\"hook\",\"useSuspenseFragment\");\n// prettier-ignore\nexport const useSuspenseQuery = missingFeatureWarning(\"hook\",\"useSuspenseQuery\");\n\n// We cannot warn on import of `skipToken`, and there is nothing to \"execute\" giving us a moment to warn,\n// so we can only fully omit it from the bundle, leading to a bundling time error.\n// export const skipToken = {};\n"]}

package/react/internal/cache/FragmentReference.d.ts

@@ -0,0 +1,35 @@
+import type { ApolloClient, OperationVariables } from "@apollo/client";
+import type { MaybeMasked } from "@apollo/client/masking";
+import type { DecoratedPromise } from "@apollo/client/utilities/internal";
+import type { FragmentKey } from "./types.js";
+type FragmentRefPromise<TData> = DecoratedPromise<TData>;
+type Listener<TData> = (promise: FragmentRefPromise<TData>) => void;
+interface FragmentReferenceOptions {
+    autoDisposeTimeoutMs?: number;
+    onDispose?: () => void;
+}
+export declare class FragmentReference<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
+    readonly observable: ApolloClient.ObservableFragment<TData | null>;
+    readonly key: FragmentKey;
+    promise: FragmentRefPromise<MaybeMasked<TData>>;
+    private resolve;
+    private reject;
+    private subscription;
+    private listeners;
+    private autoDisposeTimeoutId?;
+    private references;
+    constructor(client: ApolloClient, watchFragmentOptions: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: string | null | Array<string | null>;
+    }, options: FragmentReferenceOptions);
+    listen(listener: Listener<MaybeMasked<TData>>): () => void;
+    retain(): () => void;
+    private dispose;
+    private onDispose;
+    private subscribeToFragment;
+    private handleNext;
+    private handleError;
+    private deliver;
+    private createPendingPromise;
+}
+export {};
+//# sourceMappingURL=FragmentReference.d.ts.map

package/react/internal/cache/FragmentReference.js

@@ -0,0 +1,112 @@
+import { equal } from "@wry/equality";
+import { createFulfilledPromise, decoratePromise, } from "@apollo/client/utilities/internal";
+export class FragmentReference {
+    observable;
+    key = {};
+    promise;
+    resolve;
+    reject;
+    subscription;
+    listeners = new Set();
+    autoDisposeTimeoutId;
+    references = 0;
+    constructor(client, watchFragmentOptions, options) {
+        this.dispose = this.dispose.bind(this);
+        this.handleNext = this.handleNext.bind(this);
+        this.handleError = this.handleError.bind(this);
+        this.observable = client.watchFragment(watchFragmentOptions);
+        if (options.onDispose) {
+            this.onDispose = options.onDispose;
+        }
+        const result = this.observable.getCurrentResult();
+        // Start a timer that will automatically dispose of the query if the
+        // suspended resource does not use this fragmentRef in the given time. This
+        // helps prevent memory leaks when a component has unmounted before the
+        // query has finished loading.
+        const startDisposeTimer = () => {
+            if (!this.references) {
+                this.autoDisposeTimeoutId = setTimeout(this.dispose, options.autoDisposeTimeoutMs ?? 30_000);
+            }
+        };
+        this.promise =
+            result.complete ?
+                createFulfilledPromise(result.data)
+                : this.createPendingPromise();
+        this.subscribeToFragment();
+        this.promise.then(startDisposeTimer, startDisposeTimer);
+    }
+    listen(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    retain() {
+        this.references++;
+        clearTimeout(this.autoDisposeTimeoutId);
+        let disposed = false;
+        return () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            this.references--;
+            setTimeout(() => {
+                if (!this.references) {
+                    this.dispose();
+                }
+            });
+        };
+    }
+    dispose() {
+        this.subscription.unsubscribe();
+    }
+    onDispose() {
+        // noop. overridable by options
+    }
+    subscribeToFragment() {
+        this.subscription = this.observable.subscribe(this.handleNext.bind(this), this.handleError.bind(this));
+        // call `onDispose` when the subscription is finalized, either because it is
+        // unsubscribed as a consequence of a `dispose` call or because the
+        // ObservableQuery completes because of a `ApolloClient.stop()` call.
+        this.subscription.add(this.onDispose);
+    }
+    handleNext(result) {
+        switch (this.promise.status) {
+            case "pending": {
+                if (result.complete) {
+                    return this.resolve?.(result.data);
+                }
+                this.deliver(this.promise);
+                break;
+            }
+            case "fulfilled": {
+                // This can occur when we already have a result written to the cache and
+                // we subscribe for the first time. We create a fulfilled promise in the
+                // constructor with a value that is the same as the first emitted value
+                // so we want to skip delivering it.
+                if (equal(this.promise.value, result.data)) {
+                    return;
+                }
+                this.promise =
+                    result.complete ?
+                        createFulfilledPromise(result.data)
+                        : this.createPendingPromise();
+                this.deliver(this.promise);
+            }
+        }
+    }
+    handleError(error) {
+        this.reject?.(error);
+    }
+    deliver(promise) {
+        this.listeners.forEach((listener) => listener(promise));
+    }
+    createPendingPromise() {
+        return decoratePromise(new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        }));
+    }
+}
+//# sourceMappingURL=FragmentReference.js.map

package/react/internal/cache/FragmentReference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FragmentReference.js","sourceRoot":"","sources":["../../../../src/react/internal/cache/FragmentReference.ts"],"names":[],"mappings":"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","sourcesContent":["import { equal } from \"@wry/equality\";\nimport type { Subscription } from \"rxjs\";\n\nimport type { ApolloClient, OperationVariables } from \"@apollo/client\";\nimport type { MaybeMasked } from \"@apollo/client/masking\";\nimport type { DecoratedPromise } from \"@apollo/client/utilities/internal\";\nimport {\n  createFulfilledPromise,\n  decoratePromise,\n} from \"@apollo/client/utilities/internal\";\n\nimport type { FragmentKey } from \"./types.js\";\n\ntype FragmentRefPromise<TData> = DecoratedPromise<TData>;\ntype Listener<TData> = (promise: FragmentRefPromise<TData>) => void;\n\ninterface FragmentReferenceOptions {\n  autoDisposeTimeoutMs?: number;\n  onDispose?: () => void;\n}\n\nexport class FragmentReference<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n> {\n  public readonly observable: ApolloClient.ObservableFragment<TData | null>;\n  public readonly key: FragmentKey = {};\n  public promise!: FragmentRefPromise<MaybeMasked<TData>>;\n\n  private resolve: ((result: MaybeMasked<TData>) => void) | undefined;\n  private reject: ((error: unknown) => void) | undefined;\n\n  private subscription!: Subscription;\n  private listeners = new Set<Listener<MaybeMasked<TData>>>();\n  private autoDisposeTimeoutId?: NodeJS.Timeout;\n\n  private references = 0;\n\n  constructor(\n    client: ApolloClient,\n    watchFragmentOptions: ApolloClient.WatchFragmentOptions<\n      TData,\n      TVariables\n    > & {\n      from: string | null | Array<string | null>;\n    },\n    options: FragmentReferenceOptions\n  ) {\n    this.dispose = this.dispose.bind(this);\n    this.handleNext = this.handleNext.bind(this);\n    this.handleError = this.handleError.bind(this);\n\n    this.observable = client.watchFragment(watchFragmentOptions);\n\n    if (options.onDispose) {\n      this.onDispose = options.onDispose;\n    }\n\n    const result = this.observable.getCurrentResult();\n\n    // Start a timer that will automatically dispose of the query if the\n    // suspended resource does not use this fragmentRef in the given time. This\n    // helps prevent memory leaks when a component has unmounted before the\n    // query has finished loading.\n    const startDisposeTimer = () => {\n      if (!this.references) {\n        this.autoDisposeTimeoutId = setTimeout(\n          this.dispose,\n          options.autoDisposeTimeoutMs ?? 30_000\n        );\n      }\n    };\n\n    this.promise =\n      result.complete ?\n        createFulfilledPromise(result.data)\n      : this.createPendingPromise();\n    this.subscribeToFragment();\n\n    this.promise.then(startDisposeTimer, startDisposeTimer);\n  }\n\n  listen(listener: Listener<MaybeMasked<TData>>) {\n    this.listeners.add(listener);\n\n    return () => {\n      this.listeners.delete(listener);\n    };\n  }\n\n  retain() {\n    this.references++;\n    clearTimeout(this.autoDisposeTimeoutId);\n    let disposed = false;\n\n    return () => {\n      if (disposed) {\n        return;\n      }\n\n      disposed = true;\n      this.references--;\n\n      setTimeout(() => {\n        if (!this.references) {\n          this.dispose();\n        }\n      });\n    };\n  }\n\n  private dispose() {\n    this.subscription.unsubscribe();\n  }\n\n  private onDispose() {\n    // noop. overridable by options\n  }\n\n  private subscribeToFragment() {\n    this.subscription = this.observable.subscribe(\n      this.handleNext.bind(this),\n      this.handleError.bind(this)\n    );\n    // call `onDispose` when the subscription is finalized, either because it is\n    // unsubscribed as a consequence of a `dispose` call or because the\n    // ObservableQuery completes because of a `ApolloClient.stop()` call.\n    this.subscription.add(this.onDispose);\n  }\n\n  private handleNext(result: ApolloClient.WatchFragmentResult<TData | null>) {\n    switch (this.promise.status) {\n      case \"pending\": {\n        if (result.complete) {\n          return this.resolve?.(result.data);\n        }\n\n        this.deliver(this.promise);\n        break;\n      }\n      case \"fulfilled\": {\n        // This can occur when we already have a result written to the cache and\n        // we subscribe for the first time. We create a fulfilled promise in the\n        // constructor with a value that is the same as the first emitted value\n        // so we want to skip delivering it.\n        if (equal(this.promise.value, result.data)) {\n          return;\n        }\n\n        this.promise =\n          result.complete ?\n            createFulfilledPromise(result.data)\n          : this.createPendingPromise();\n\n        this.deliver(this.promise);\n      }\n    }\n  }\n\n  private handleError(error: unknown) {\n    this.reject?.(error);\n  }\n\n  private deliver(promise: FragmentRefPromise<MaybeMasked<TData>>) {\n    this.listeners.forEach((listener) => listener(promise));\n  }\n\n  private createPendingPromise() {\n    return decoratePromise(\n      new Promise<MaybeMasked<TData>>((resolve, reject) => {\n        this.resolve = resolve;\n        this.reject = reject;\n      })\n    );\n  }\n}\n"]}

package/react/internal/cache/QueryReference.d.ts

@@ -0,0 +1,112 @@
+import type { DocumentTypeDecoration, ResultOf, VariablesOf } from "@graphql-typed-document-node/core";
+import type { ApolloClient, DataState, ObservableQuery, OperationVariables } from "@apollo/client";
+import type { MaybeMasked } from "@apollo/client/masking";
+import type { DecoratedPromise } from "@apollo/client/utilities/internal";
+import type { QueryKey } from "./types.js";
+type QueryRefPromise<TData, TStates extends DataState<TData>["dataState"]> = DecoratedPromise<ObservableQuery.Result<MaybeMasked<TData>, TStates>>;
+type Listener<TData, TStates extends DataState<TData>["dataState"]> = (promise: QueryRefPromise<TData, TStates>) => void;
+declare const QUERY_REFERENCE_SYMBOL: unique symbol;
+declare const PROMISE_SYMBOL: unique symbol;
+declare const QUERY_REF_BRAND: unique symbol;
+declare const PRELOADED_QUERY_REF_BRAND: unique symbol;
+/**
+ * A `QueryReference` is an opaque object returned by `useBackgroundQuery`.
+ * A child component reading the `QueryReference` via `useReadQuery` will
+ * suspend until the promise resolves.
+ */
+export interface QueryRef<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = "complete" | "streaming"> {
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    [QUERY_REF_BRAND]?(variables: TVariables): {
+        data: TData;
+        states: TStates;
+    };
+}
+export declare namespace QueryRef {
+    type ForQuery<Document extends DocumentTypeDecoration<any, any>, TStates extends DataState<ResultOf<Document>>["dataState"] = "complete" | "streaming"> = QueryRef<ResultOf<Document>, VariablesOf<Document>, TStates>;
+}
+/**
+* @internal
+* For usage in internal helpers only.
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+interface WrappedQueryRef<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = "complete" | "streaming"> extends QueryRef<TData, TVariables, TStates> {
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    readonly [QUERY_REFERENCE_SYMBOL]: InternalQueryReference<TData, TStates>;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    [PROMISE_SYMBOL]: QueryRefPromise<TData, TStates>;
+}
+/**
+* A `QueryReference` is an opaque object returned by `useBackgroundQuery`.
+* A child component reading the `QueryReference` via `useReadQuery` will
+* suspend until the promise resolves.
+*/
+export interface PreloadedQueryRef<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = "complete" | "streaming"> extends QueryRef<TData, TVariables, TStates> {
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    [PRELOADED_QUERY_REF_BRAND]: typeof PRELOADED_QUERY_REF_BRAND;
+}
+interface InternalQueryReferenceOptions {
+    onDispose?: () => void;
+    autoDisposeTimeoutMs?: number;
+}
+export declare function wrapQueryRef<TData, TVariables extends OperationVariables, TStates extends DataState<TData>["dataState"]>(internalQueryRef: InternalQueryReference<TData, TStates>): WrappedQueryRef<TData, TVariables, TStates>;
+export declare function assertWrappedQueryRef<TData, TVariables extends OperationVariables, TStates extends DataState<TData>["dataState"]>(queryRef: QueryRef<TData, TVariables, TStates>): asserts queryRef is WrappedQueryRef<TData, TVariables, TStates>;
+export declare function assertWrappedQueryRef<TData, TVariables extends OperationVariables, TStates extends DataState<TData>["dataState"]>(queryRef: QueryRef<TData, TVariables, TStates> | undefined | null): asserts queryRef is WrappedQueryRef<TData, TVariables, TStates> | undefined | null;
+export declare function getWrappedPromise<TData, TStates extends DataState<TData>["dataState"]>(queryRef: WrappedQueryRef<TData, any, TStates>): QueryRefPromise<TData, TStates>;
+export declare function unwrapQueryRef<TData, TStates extends DataState<TData>["dataState"]>(queryRef: WrappedQueryRef<TData, any, TStates>): InternalQueryReference<TData, TStates>;
+export declare function unwrapQueryRef<TData, TStates extends DataState<TData>["dataState"]>(queryRef: Partial<WrappedQueryRef<TData, any, TStates>>): undefined | InternalQueryReference<TData, TStates>;
+export declare function updateWrappedQueryRef<TData, TStates extends DataState<TData>["dataState"]>(queryRef: WrappedQueryRef<TData, any, TStates>, promise: QueryRefPromise<TData, TStates>): void;
+declare const OBSERVED_CHANGED_OPTIONS: readonly ["context", "errorPolicy", "fetchPolicy", "refetchWritePolicy", "returnPartialData"];
+type ObservedOptions = Pick<ApolloClient.WatchQueryOptions, (typeof OBSERVED_CHANGED_OPTIONS)[number]>;
+export declare class InternalQueryReference<TData = unknown, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> {
+    result: ObservableQuery.Result<MaybeMasked<TData>, TStates>;
+    readonly key: QueryKey;
+    readonly observable: ObservableQuery<TData>;
+    promise: QueryRefPromise<TData, TStates>;
+    private queue;
+    private subscription;
+    private listeners;
+    private autoDisposeTimeoutId?;
+    private resolve;
+    private reject;
+    private references;
+    private softReferences;
+    constructor(observable: ObservableQuery<TData, any>, options: InternalQueryReferenceOptions);
+    get disposed(): boolean;
+    get watchQueryOptions(): ObservableQuery.Options<TData, OperationVariables>;
+    reinitialize(): void;
+    retain(): () => void;
+    softRetain(): () => void;
+    didChangeOptions(watchQueryOptions: ObservedOptions): boolean;
+    applyOptions(watchQueryOptions: ObservedOptions): QueryRefPromise<TData, TStates>;
+    listen(listener: Listener<TData, TStates>): () => void;
+    refetch(variables: OperationVariables | undefined): Promise<ApolloClient.QueryResult<TData>>;
+    fetchMore(options: ObservableQuery.FetchMoreOptions<TData, any, any, any>): Promise<ApolloClient.QueryResult<TData>>;
+    private dispose;
+    private onDispose;
+    private handleNext;
+    private deliver;
+    private initiateFetch;
+    private subscribeToQuery;
+    private setResult;
+    private shouldReject;
+    private createPendingPromise;
+}
+export {};
+//# sourceMappingURL=QueryReference.d.ts.map

package/react/internal/cache/QueryReference.js

@@ -0,0 +1,305 @@
+import { equal } from "@wry/equality";
+import { filter } from "rxjs";
+import { createFulfilledPromise, createRejectedPromise, decoratePromise, } from "@apollo/client/utilities/internal";
+import { invariant } from "@apollo/client/utilities/invariant";
+const QUERY_REFERENCE_SYMBOL = Symbol.for("apollo.internal.queryRef");
+const PROMISE_SYMBOL = Symbol.for("apollo.internal.refPromise");
+export function wrapQueryRef(internalQueryRef) {
+    return {
+        [QUERY_REFERENCE_SYMBOL]: internalQueryRef,
+        [PROMISE_SYMBOL]: internalQueryRef.promise,
+    };
+}
+export function assertWrappedQueryRef(queryRef) {
+    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 27);
+}
+export function getWrappedPromise(queryRef) {
+    const internalQueryRef = unwrapQueryRef(queryRef);
+    return internalQueryRef.promise.status === "fulfilled" ?
+        internalQueryRef.promise
+        : queryRef[PROMISE_SYMBOL];
+}
+export function unwrapQueryRef(queryRef) {
+    return queryRef[QUERY_REFERENCE_SYMBOL];
+}
+export function updateWrappedQueryRef(queryRef, promise) {
+    queryRef[PROMISE_SYMBOL] = promise;
+}
+const OBSERVED_CHANGED_OPTIONS = [
+    "context",
+    "errorPolicy",
+    "fetchPolicy",
+    "refetchWritePolicy",
+    "returnPartialData",
+];
+export class InternalQueryReference {
+    result;
+    key = {};
+    observable;
+    promise;
+    queue;
+    subscription;
+    listeners = new Set();
+    autoDisposeTimeoutId;
+    resolve;
+    reject;
+    references = 0;
+    softReferences = 0;
+    constructor(observable, options) {
+        this.handleNext = this.handleNext.bind(this);
+        this.dispose = this.dispose.bind(this);
+        this.observable = observable;
+        if (options.onDispose) {
+            this.onDispose = options.onDispose;
+        }
+        this.setResult();
+        this.subscribeToQuery();
+        // Start a timer that will automatically dispose of the query if the
+        // suspended resource does not use this queryRef in the given time. This
+        // helps prevent memory leaks when a component has unmounted before the
+        // query has finished loading.
+        const startDisposeTimer = () => {
+            if (!this.references) {
+                this.autoDisposeTimeoutId = setTimeout(this.dispose, options.autoDisposeTimeoutMs ?? 30_000);
+            }
+        };
+        // We wait until the request has settled to ensure we don't dispose of the
+        // query ref before the request finishes, otherwise we would leave the
+        // promise in a pending state rendering the suspense boundary indefinitely.
+        this.promise.then(startDisposeTimer, startDisposeTimer);
+    }
+    get disposed() {
+        return this.subscription.closed;
+    }
+    get watchQueryOptions() {
+        return this.observable.options;
+    }
+    reinitialize() {
+        const { observable } = this;
+        const originalFetchPolicy = this.watchQueryOptions.fetchPolicy;
+        const avoidNetworkRequests = originalFetchPolicy === "no-cache" || originalFetchPolicy === "standby";
+        try {
+            if (avoidNetworkRequests) {
+                observable.applyOptions({ fetchPolicy: "standby" });
+            }
+            else {
+                observable.reset();
+                observable.applyOptions({ fetchPolicy: "cache-first" });
+            }
+            if (!avoidNetworkRequests) {
+                this.setResult();
+            }
+            this.subscribeToQuery();
+        }
+        finally {
+            observable.applyOptions({ fetchPolicy: originalFetchPolicy });
+        }
+    }
+    retain() {
+        this.references++;
+        clearTimeout(this.autoDisposeTimeoutId);
+        let disposed = false;
+        return () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            this.references--;
+            setTimeout(() => {
+                if (!this.references) {
+                    this.dispose();
+                }
+            });
+        };
+    }
+    softRetain() {
+        this.softReferences++;
+        let disposed = false;
+        return () => {
+            // Tracking if this has already been called helps ensure that
+            // multiple calls to this function won't decrement the reference
+            // counter more than it should. Subsequent calls just result in a noop.
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            this.softReferences--;
+            setTimeout(() => {
+                if (!this.softReferences && !this.references) {
+                    this.dispose();
+                }
+            });
+        };
+    }
+    didChangeOptions(watchQueryOptions) {
+        return OBSERVED_CHANGED_OPTIONS.some((option) => option in watchQueryOptions &&
+            !equal(this.watchQueryOptions[option], watchQueryOptions[option]));
+    }
+    applyOptions(watchQueryOptions) {
+        const { fetchPolicy: currentFetchPolicy } = this.watchQueryOptions;
+        // "standby" is used when `skip` is set to `true`. Detect when we've
+        // enabled the query (i.e. `skip` is `false`) to execute a network request.
+        if (currentFetchPolicy === "standby" &&
+            currentFetchPolicy !== watchQueryOptions.fetchPolicy) {
+            this.initiateFetch(this.observable.reobserve(watchQueryOptions));
+        }
+        else {
+            this.observable.applyOptions(watchQueryOptions);
+        }
+        return this.promise;
+    }
+    listen(listener) {
+        this.listeners.add(listener);
+        if (this.queue) {
+            this.deliver(this.queue);
+            this.queue = undefined;
+        }
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    refetch(variables) {
+        return this.initiateFetch(this.observable.refetch(variables));
+    }
+    fetchMore(options) {
+        return this.initiateFetch(this.observable.fetchMore(options));
+    }
+    dispose() {
+        this.subscription.unsubscribe();
+    }
+    onDispose() {
+        // noop. overridable by options
+    }
+    handleNext(result) {
+        switch (this.promise.status) {
+            case "pending": {
+                // Maintain the last successful `data` value if the next result does not
+                // have one.
+                // TODO: This can likely be removed once
+                // https://github.com/apollographql/apollo-client/issues/12667 is fixed
+                if (result.data === void 0) {
+                    result.data = this.result.data;
+                    if (result.data) {
+                        result.dataState = "complete";
+                    }
+                }
+                if (this.shouldReject(result)) {
+                    this.reject?.(result.error);
+                }
+                else {
+                    this.result = result;
+                    this.resolve?.(result);
+                }
+                break;
+            }
+            default: {
+                // This occurs when switching to a result that is fully cached when this
+                // class is instantiated. ObservableQuery will run reobserve when
+                // subscribing, which delivers a result from the cache.
+                if (result.data === this.result.data &&
+                    result.networkStatus === this.result.networkStatus) {
+                    return;
+                }
+                // Maintain the last successful `data` value if the next result does not
+                // have one.
+                if (result.data === void 0) {
+                    result.data = this.result.data;
+                }
+                if (this.shouldReject(result)) {
+                    this.promise = createRejectedPromise(result.error);
+                    this.deliver(this.promise);
+                }
+                else {
+                    this.result = result;
+                    this.promise = createFulfilledPromise(result);
+                    this.deliver(this.promise);
+                }
+                break;
+            }
+        }
+    }
+    deliver(promise) {
+        // Maintain a queue of the last item we tried to deliver so that we can
+        // deliver it as soon as we get the first listener. This helps in cases such
+        // as `@stream` where React may render a component and incremental results
+        // are loaded in between when the component renders and effects are run. If
+        // effects are run after the incremntal chunks are delivered, we'll have
+        // rendered a stale value. The queue ensures we can deliver the most
+        // up-to-date value as soon as the component is ready to listen for new
+        // values.
+        if (this.listeners.size === 0) {
+            this.queue = promise;
+        }
+        this.listeners.forEach((listener) => listener(promise));
+    }
+    initiateFetch(returnedPromise) {
+        this.promise = this.createPendingPromise();
+        this.promise.catch(() => { });
+        // If the data returned from the fetch is deeply equal to the data already
+        // in the cache, `handleNext` will not be triggered leaving the promise we
+        // created in a pending state forever. To avoid this situation, we attempt
+        // to resolve the promise if `handleNext` hasn't been run to ensure the
+        // promise is resolved correctly.
+        returnedPromise
+            .then(() => {
+            // In the case of `fetchMore`, this promise is resolved before a cache
+            // result is emitted due to the fact that `fetchMore` sets a `no-cache`
+            // fetch policy and runs `cache.batch` in its `.then` handler. Because
+            // the timing is different, we accidentally run this update twice
+            // causing an additional re-render with the `fetchMore` result by
+            // itself. By wrapping in `setTimeout`, this should provide a short
+            // delay to allow the `QueryInfo.notify` handler to run before this
+            // promise is checked.
+            // See https://github.com/apollographql/apollo-client/issues/11315 for
+            // more information
+            setTimeout(() => {
+                if (this.promise.status === "pending") {
+                    // Use the current result from the observable instead of the value
+                    // resolved from the promise. This avoids issues in some cases where
+                    // the raw resolved value should not be the emitted value, such as
+                    // when a `fetchMore` call returns an empty array after it has
+                    // reached the end of the list.
+                    //
+                    // See the following for more information:
+                    // https://github.com/apollographql/apollo-client/issues/11642
+                    this.result =
+                        this.observable.getCurrentResult();
+                    this.resolve?.(this.result);
+                }
+            });
+        })
+            .catch((error) => this.reject?.(error));
+        return returnedPromise;
+    }
+    subscribeToQuery() {
+        this.subscription = this.observable
+            .pipe(filter((result) => !equal(result, this.result)))
+            .subscribe(this.handleNext);
+        // call `onDispose` when the subscription is finalized, either because it is
+        // unsubscribed as a consequence of a `dispose` call or because the
+        // ObservableQuery completes because of a `ApolloClient.stop()` call.
+        this.subscription.add(this.onDispose);
+    }
+    setResult() {
+        const result = this.observable.getCurrentResult();
+        if (equal(result, this.result)) {
+            return;
+        }
+        this.result = result;
+        this.promise =
+            result.data ?
+                createFulfilledPromise(result)
+                : this.createPendingPromise();
+    }
+    shouldReject(result) {
+        const { errorPolicy = "none" } = this.watchQueryOptions;
+        return result.error && errorPolicy === "none";
+    }
+    createPendingPromise() {
+        return decoratePromise(new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        }));
+    }
+}
+//# sourceMappingURL=QueryReference.js.map