Tolerate undefined concast.sources if complete called early.

Fixes issue #10262, since `this.sources.shift()` throws when `complete`
is called called before the `Promise` that should have initialized
`this.sources` resolves, which can happen when the directive combination
`@client @export(as: ...)` is used, because `@export` usage causes a
`Promise<Observable[]>` to be passed to the `Concast` constructor
instead of the `Observable[]` itself.

Although passing a `Promise` to the `Concast` constructor should work,
we only exercise that code path in one place, and the additional wrinkle
of calling `complete` before the `Promise` resolves was never tested:
https://github.com/apollographql/apollo-client/blob/015a1ffff3febe4604956f4bb137a3111f3d8257/src/core/QueryManager.ts#L1226-L1241

src/utilities/observables/Concast.ts

@@ -85,9 +85,12 @@ export class Concast<T> extends Observable<T> {
     }
   }
 
-  // A consumable array of source observables, incrementally consumed
-  // each time this.handlers.complete is called.
-  private sources: Source<T>[];
+  // A consumable array of source observables, incrementally consumed each time
+  // this.handlers.complete is called. This private field is not initialized
+  // until the concast.start method is called, which can happen asynchronously
+  // if a Promise is passed to the Concast constructor, so undefined is a
+  // possible value for this.sources before concast.start is called.
+  private sources: Source<T>[] | undefined;
 
   private start(sources: ConcastSourcesIterable<T>) {
     if (this.sub !== void 0) return;
@@ -185,9 +188,14 @@ export class Concast<T> extends Observable<T> {
     },
 
     complete: () => {
-      const { sub } = this;
+      const { sub, sources = [] } = this;
       if (sub !== null) {
-        const value = this.sources.shift();
+        // If complete is called before concast.start, this.sources may be
+        // undefined, so we use a default value of [] for sources. That works
+        // here because it falls into the if (!value) {...} block, which
+        // appropriately terminates the Concast, even if this.sources might
+        // eventually have been initialized to a non-empty array.
+        const value = sources.shift();
         if (!value) {
           if (sub) setTimeout(() => sub.unsubscribe());
           this.sub = null;

src/utilities/observables/__tests__/Concast.ts

@@ -1,6 +1,6 @@
 import { itAsync } from "../../../testing/core";
 import { Observable } from "../Observable";
-import { Concast } from "../Concast";
+import { Concast, ConcastSourcesIterable } from "../Concast";
 
 describe("Concast Observable (similar to Behavior Subject in RxJS)", () => {
   itAsync("can concatenate other observables", (resolve, reject) => {
@@ -30,6 +30,36 @@ describe("Concast Observable (similar to Behavior Subject in RxJS)", () => {
     });
   });
 
+  itAsync("Can tolerate being completed before input Promise resolves", (resolve, reject) => {
+    let resolvePromise: (sources: ConcastSourcesIterable<number>) => void;
+    const delayPromise = new Promise<ConcastSourcesIterable<number>>(resolve => {
+      resolvePromise = resolve;
+    });
+
+    const concast = new Concast<number>(delayPromise);
+    const observer = {
+      next() {
+        reject(new Error("should not have called observer.next"));
+      },
+      error: reject,
+      complete() {
+        reject(new Error("should not have called observer.complete"));
+      },
+    };
+
+    concast.addObserver(observer);
+    concast.removeObserver(observer);
+
+    return concast.promise.then(finalResult => {
+      expect(finalResult).toBeUndefined();
+      resolvePromise([]);
+      return delayPromise;
+    }).then(delayedPromiseResult => {
+      expect(delayedPromiseResult).toEqual([]);
+      resolve();
+    }).catch(reject);
+  });
+
   itAsync("behaves appropriately if unsubscribed before first result", (resolve, reject) => {
     const concast = new Concast([
       new Promise(resolve => setTimeout(resolve, 100)).then(