@apollo/client 4.0.0-alpha.12 → 4.0.0-alpha.14

package/core/ObservableQuery.d.ts

@@ -1,12 +1,12 @@
 import type { DocumentNode } from "graphql";
 import type { InteropObservable, Observer, Subscribable, Subscription } from "rxjs";
-import type { Observable } from "rxjs";
-import type { MissingFieldError } from "@apollo/client/cache";
+import { Observable } from "rxjs";
+import type { Cache, MissingFieldError } from "@apollo/client/cache";
 import type { MissingTree } from "@apollo/client/cache";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
 import type { QueryInfo } from "./QueryInfo.js";
 import type { QueryManager } from "./QueryManager.js";
-import type { ApolloQueryResult, DefaultContext, ErrorLike, OperationVariables, QueryResult, TypedDocumentNode } from "./types.js";
+import type { ApolloQueryResult, DefaultContext, OperationVariables, QueryResult, TypedDocumentNode } from "./types.js";
 import type { ErrorPolicy, FetchMoreQueryOptions, NextFetchPolicyContext, RefetchWritePolicy, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.js";
 export interface FetchMoreOptions<TData = unknown, TVariables = OperationVariables> {
     updateQuery?: (previousQueryResult: TData, options: {
@@ -129,15 +129,40 @@ export declare namespace ObservableQuery {
         */
         variables: TVariables;
     };
+    /**
+    * @internal
+    * This describes the `WatchOptions` used by `ObservableQuery` to
+    * subscribe to the cache.
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    interface CacheWatchOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Cache.WatchOptions<TData, TVariables> {
+        /**
+        * @internal
+        * We cannot suppress the broadcast completely, since that would
+        * result in external updates to be lost if we go from
+        * (external A) -> (own B) -> (external C) when A and C have the same
+        * value.
+        * Without the `own B` being broadcast, the `cache.watch` would swallow
+        * C.
+        * So instead we track the last "own diff" and suppress further processing
+        * in the callback.
+        * 
+        * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+        */
+        lastOwnDiff?: Cache.DiffResult<TData>;
+    }
 }
 export declare class ObservableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables> implements Subscribable<ApolloQueryResult<MaybeMasked<TData>>>, InteropObservable<ApolloQueryResult<MaybeMasked<TData>>> {
     /**
-     * @internal
-     * A slot used by the `useQuery` hook to indicate that `client.watchQuery`
-     * should not register the query immediately, but instead wait for the query to
-     * be started registered with the `QueryManager` when `useSyncExternalStore`
-     * actively subscribes to it.
-     */
+    * @internal
+    * A slot used by the `useQuery` hook to indicate that `client.watchQuery`
+    * should not register the query immediately, but instead wait for the query to
+    * be started registered with the `QueryManager` when `useSyncExternalStore`
+    * actively subscribes to it.
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     private static inactiveOnCreation;
     readonly options: ObservableQuery.Options<TData, TVariables>;
     readonly queryId: string;
@@ -147,19 +172,24 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * An object containing the variables that were provided for the query.
      */
     get variables(): TVariables;
+    private unsubscribeFromCache?;
+    private input;
     private subject;
     private readonly observable;
     private isTornDown;
     private queryManager;
     private subscriptions;
-    private waitForOwnResult;
-    private last?;
+    /**
+     * If an `ObservableQuery` is created with a `network-only` fetch policy,
+     * it should actually start receiving cache updates, but not before it has
+     * received the first result from the network.
+     */
+    private waitForNetworkResult;
     private lastQuery;
     private queryInfo;
     private linkSubscription?;
-    private linkObservable?;
     private pollingInfo?;
-    private networkStatus;
+    private get networkStatus();
     constructor({ queryManager, queryInfo, options, }: {
         queryManager: QueryManager;
         queryInfo: QueryInfo;
@@ -169,16 +199,17 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     pipe: Observable<ApolloQueryResult<MaybeMasked<TData>>>["pipe"];
     [Symbol.observable]: () => Subscribable<ApolloQueryResult<MaybeMasked<TData>>>;
     ["@@observable"]: () => Subscribable<ApolloQueryResult<MaybeMasked<TData>>>;
-    /** @internal */
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     resetDiff(): void;
+    private getCacheDiff;
     private getInitialResult;
-    private getCurrentFullResult;
-    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<MaybeMasked<TData>>;
-    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
-    private getLast;
-    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
-    getLastError(variablesMustMatch?: boolean): ErrorLike | undefined;
-    resetLastResults(): void;
+    private resubscribeCache;
+    private stableLastResult?;
+    getCurrentResult(): ApolloQueryResult<MaybeMasked<TData>>;
     /**
      * Update the variables of this observable query, and fetch the new results.
      * This method should be preferred over `setVariables` in most use cases.
@@ -202,7 +233,11 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * This function returns _another_ function that you can call to terminate the subscription.
      */
     subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
-    /** @internal */
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     silentSetOptions(newOptions: Partial<ObservableQuery.Options<TData, TVariables>>): void;
     /**
      * Update the variables of this observable query, and fetch the new results
@@ -241,28 +276,55 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     private fetch;
     private updatePolling;
     private cancelPolling;
-    private updateLastResult;
     /**
      * Reevaluate the query, optionally against new options. New options will be
      * merged with the current options when given.
      */
     reobserve(newOptions?: Partial<ObservableQuery.Options<TData, TVariables>>): Promise<QueryResult<MaybeMasked<TData>>>;
-    private observe;
-    private reportResult;
-    private reportError;
     hasObservers(): boolean;
     private tearDownQuery;
     private transformDocument;
     private maskResult;
     private dirty;
     private notifyTimeout?;
-    /** @internal */
-    protected resetNotifications(): void;
-    private cancelNotifyTimeout;
-    /** @internal */
-    protected scheduleNotify(): void;
-    /** @internal */
-    protected notify(): void;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    private resetNotifications;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    private scheduleNotify;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    notify(scheduled?: boolean): void;
+    private activeOperations;
+    private pushOperation;
+    private calculateNetworkStatus;
+    private abortActiveOperations;
+    /**
+    * @internal
+    * Called from `clearStore`.
+    * * resets the query to its initial state
+    * * cancels all active operations and their subscriptions
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    reset(): void;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    private setResult;
+    private operator;
     private reobserveCacheFirst;
     private getVariablesWithDefaults;
 }