···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

       
2
       
+
       
'@urql/core': patch

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Return `AbortController` invocation to previous behaviour where it used to be more forceful. It will now properly abort outside of when our generator yields results, and hence now also cancels requests again that have already delivered headers but are currently awaiting a response body.

     

···

       
1
       
-
       
import { Source, fromAsyncIterable, filter, pipe } from 'wonka';

     

       
2
       
 
       
import { Operation, OperationResult, ExecutionResult } from '../types';

     

       
3
       
 
       
import { makeResult, makeErrorResult, mergeResultPatch } from '../utils';

     

       
4
       
 
       


     
···

       
108
       
 
       
  fetchOptions: RequestInit

     

       
109
       
 
       
) {

     

       
110
       
 
       
  let networkMode = true;

     

       
111
       
-
       
  let abortController: AbortController | void;

     

       
112
       
 
       
  let result: OperationResult | null = null;

     

       
113
       
 
       
  let response: Response | void;

     

       
114
       
 
       


     

       
115
       
 
       
  try {

     

       
116
       
-
       
    if (typeof AbortController !== 'undefined') {

     

       
117
       
-
       
      fetchOptions.signal = (abortController = new AbortController()).signal;

     

       
118
       
-
       
    }

     

       
119
       
-
       


     

       
120
       
 
       
    // Delay for a tick to give the Client a chance to cancel the request

     

       
121
       
 
       
    // if a teardown comes in immediately

     

       
122
       
 
       
    yield await Promise.resolve();

     
···

       
161
       
 
       
        : error,

     

       
162
       
 
       
      response

     

       
163
       
 
       
    );

     

       
164
       
-
       
  } finally {

     

       
165
       
-
       
    if (abortController) abortController.abort();

     

       
166
       
 
       
  }

     

       
167
       
 
       
}

     

       
168
       
 
       


     
···

       
198
       
 
       
  url: string,

     

       
199
       
 
       
  fetchOptions: RequestInit

     

       
200
       
 
       
): Source<OperationResult> {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
201
       
 
       
  return pipe(

     

       
202
       
 
       
    fromAsyncIterable(fetchOperation(operation, url, fetchOptions)),

     

       
203
       
-
       
    filter((result): result is OperationResult => !!result)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
204
       
 
       
  );

     

       
205
       
 
       
}

     

···

       
1
       
+
       
import { Source, fromAsyncIterable, onEnd, filter, pipe } from 'wonka';

     

       
2
       
 
       
import { Operation, OperationResult, ExecutionResult } from '../types';

     

       
3
       
 
       
import { makeResult, makeErrorResult, mergeResultPatch } from '../utils';

     

       
4
       
 
       


     
···

       
108
       
 
       
  fetchOptions: RequestInit

     

       
109
       
 
       
) {

     

       
110
       
 
       
  let networkMode = true;

     

       
0
       
 
       

     

       
111
       
 
       
  let result: OperationResult | null = null;

     

       
112
       
 
       
  let response: Response | void;

     

       
113
       
 
       


     

       
114
       
 
       
  try {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
115
       
 
       
    // Delay for a tick to give the Client a chance to cancel the request

     

       
116
       
 
       
    // if a teardown comes in immediately

     

       
117
       
 
       
    yield await Promise.resolve();

     
···

       
156
       
 
       
        : error,

     

       
157
       
 
       
      response

     

       
158
       
 
       
    );

     

       
0
       
 
       

     

       
0
       
 
       

     

       
159
       
 
       
  }

     

       
160
       
 
       
}

     

       
161
       
 
       


     
···

       
191
       
 
       
  url: string,

     

       
192
       
 
       
  fetchOptions: RequestInit

     

       
193
       
 
       
): Source<OperationResult> {

     

       
194
       
+
       
  let abortController: AbortController | void;

     

       
195
       
+
       
  if (typeof AbortController !== 'undefined') {

     

       
196
       
+
       
    fetchOptions.signal = (abortController = new AbortController()).signal;

     

       
197
       
+
       
  }

     

       
198
       
 
       
  return pipe(

     

       
199
       
 
       
    fromAsyncIterable(fetchOperation(operation, url, fetchOptions)),

     

       
200
       
+
       
    filter((result): result is OperationResult => !!result),

     

       
201
       
+
       
    onEnd(() => {

     

       
202
       
+
       
      if (abortController) abortController.abort();

     

       
203
       
+
       
    })

     

       
204
       
 
       
  );

     

       
205
       
 
       
}