···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

       
2
       
+
       
'urql': patch

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Silence "Cannot update a component (%s) while rendering a different component (%s)." warning forcefully.

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
1
       
 
       
export const initialState = {

     

       
2
       
 
       
  fetching: false,

     

       
3
       
 
       
  stale: false,

     
···

       
41
       
 
       
  for (let i = 0, l = b.length; i < l; i++) if (a[i] !== b[i]) return true;

     

       
42
       
 
       
  return false;

     

       
43
       
 
       
};

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
import * as React from 'react';

     

       
2
       
+
       


     

       
3
       
 
       
export const initialState = {

     

       
4
       
 
       
  fetching: false,

     

       
5
       
 
       
  stale: false,

     
···

       
43
       
 
       
  for (let i = 0, l = b.length; i < l; i++) if (a[i] !== b[i]) return true;

     

       
44
       
 
       
  return false;

     

       
45
       
 
       
};

     

       
46
       
+
       


     

       
47
       
+
       
const reactSharedInternals = (React as any)

     

       
48
       
+
       
  .__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

     

       
49
       
+
       


     

       
50
       
+
       
export function deferDispatch<Dispatch extends React.Dispatch<any>>(

     

       
51
       
+
       
  setState: Dispatch,

     

       
52
       
+
       
  value: Dispatch extends React.Dispatch<infer State> ? State : void

     

       
53
       
+
       
) {

     

       
54
       
+
       
  if (

     

       
55
       
+
       
    process.env.NODE_ENV !== 'production' &&

     

       
56
       
+
       
    !!reactSharedInternals &&

     

       
57
       
+
       
    !!reactSharedInternals.ReactCurrentOwner &&

     

       
58
       
+
       
    !!reactSharedInternals.ReactCurrentOwner.current

     

       
59
       
+
       
  ) {

     

       
60
       
+
       
    Promise.resolve(value).then(setState);

     

       
61
       
+
       
  } else {

     

       
62
       
+
       
    setState(value);

     

       
63
       
+
       
  }

     

       
64
       
+
       
}

     

···

       
13
       
 
       
} from '@urql/core';

     

       
14
       
 
       


     

       
15
       
 
       
import { useClient } from '../context';

     

       
16
       
-
       
import { initialState } from './state';

     

       
17
       
 
       


     

       
18
       
 
       
/** State of the last mutation executed by your {@link useMutation} hook.

     

       
19
       
 
       
 *

     
···

       
155
       
 
       


     

       
156
       
 
       
  const executeMutation = useCallback(

     

       
157
       
 
       
    (variables: Variables, context?: Partial<OperationContext>) => {

     

       
158
       
-
       
      setState({ ...initialState, fetching: true });

     

       
159
       
 
       


     

       
160
       
 
       
      return pipe(

     

       
161
       
 
       
        client.executeMutation<Data, Variables>(

     
···

       
165
       
 
       
        toPromise

     

       
166
       
 
       
      ).then(result => {

     

       
167
       
 
       
        if (isMounted.current) {

     

       
168
       
-
       
          setState({

     

       
169
       
 
       
            fetching: false,

     

       
170
       
 
       
            stale: !!result.stale,

     

       
171
       
 
       
            data: result.data,

     

···

       
13
       
 
       
} from '@urql/core';

     

       
14
       
 
       


     

       
15
       
 
       
import { useClient } from '../context';

     

       
16
       
+
       
import { deferDispatch, initialState } from './state';

     

       
17
       
 
       


     

       
18
       
 
       
/** State of the last mutation executed by your {@link useMutation} hook.

     

       
19
       
 
       
 *

     
···

       
155
       
 
       


     

       
156
       
 
       
  const executeMutation = useCallback(

     

       
157
       
 
       
    (variables: Variables, context?: Partial<OperationContext>) => {

     

       
158
       
+
       
      deferDispatch(setState, { ...initialState, fetching: true });

     

       
159
       
 
       


     

       
160
       
 
       
      return pipe(

     

       
161
       
 
       
        client.executeMutation<Data, Variables>(

     
···

       
165
       
 
       
        toPromise

     

       
166
       
 
       
      ).then(result => {

     

       
167
       
 
       
        if (isMounted.current) {

     

       
168
       
+
       
          deferDispatch(setState, {

     

       
169
       
 
       
            fetching: false,

     

       
170
       
 
       
            stale: !!result.stale,

     

       
171
       
 
       
            data: result.data,

     

···

       
17
       
 
       
import { useClient } from '../context';

     

       
18
       
 
       
import { useRequest } from './useRequest';

     

       
19
       
 
       
import { getCacheForClient } from './cache';

     

       
20
       
-
       
import { initialState, computeNextState, hasDepsChanged } from './state';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
21
       
 
       


     

       
22
       
 
       
/** Input arguments for the {@link useQuery} hook.

     

       
23
       
 
       
 *

     
···

       
317
       
 
       


     

       
318
       
 
       
    const updateResult = (result: Partial<UseQueryState<Data, Variables>>) => {

     

       
319
       
 
       
      hasResult = true;

     

       
320
       
-
       
      setState(state => {

     

       
321
       
 
       
        const nextResult = computeNextState(state[1], result);

     

       
322
       
 
       
        return state[1] !== nextResult

     

       
323
       
 
       
          ? [state[0], nextResult, state[2]]

     
···

       
353
       
 
       
        ...opts,

     

       
354
       
 
       
      };

     

       
355
       
 
       


     

       
356
       
-
       
      setState(state => {

     

       
357
       
 
       
        const source = suspense

     

       
358
       
 
       
          ? pipe(

     

       
359
       
 
       
              client.executeQuery(request, context),

     

···

       
17
       
 
       
import { useClient } from '../context';

     

       
18
       
 
       
import { useRequest } from './useRequest';

     

       
19
       
 
       
import { getCacheForClient } from './cache';

     

       
20
       
+
       


     

       
21
       
+
       
import {

     

       
22
       
+
       
  deferDispatch,

     

       
23
       
+
       
  initialState,

     

       
24
       
+
       
  computeNextState,

     

       
25
       
+
       
  hasDepsChanged,

     

       
26
       
+
       
} from './state';

     

       
27
       
 
       


     

       
28
       
 
       
/** Input arguments for the {@link useQuery} hook.

     

       
29
       
 
       
 *

     
···

       
323
       
 
       


     

       
324
       
 
       
    const updateResult = (result: Partial<UseQueryState<Data, Variables>>) => {

     

       
325
       
 
       
      hasResult = true;

     

       
326
       
+
       
      deferDispatch(setState, state => {

     

       
327
       
 
       
        const nextResult = computeNextState(state[1], result);

     

       
328
       
 
       
        return state[1] !== nextResult

     

       
329
       
 
       
          ? [state[0], nextResult, state[2]]

     
···

       
359
       
 
       
        ...opts,

     

       
360
       
 
       
      };

     

       
361
       
 
       


     

       
362
       
+
       
      deferDispatch(setState, state => {

     

       
363
       
 
       
        const source = suspense

     

       
364
       
 
       
          ? pipe(

     

       
365
       
 
       
              client.executeQuery(request, context),

     

···

       
13
       
 
       


     

       
14
       
 
       
import { useClient } from '../context';

     

       
15
       
 
       
import { useRequest } from './useRequest';

     

       
16
       
-
       
import { initialState, computeNextState, hasDepsChanged } from './state';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
17
       
 
       


     

       
18
       
 
       
/** Input arguments for the {@link useSubscription} hook.

     

       
19
       
 
       
 *

     
···

       
257
       
 
       
    const updateResult = (

     

       
258
       
 
       
      result: Partial<UseSubscriptionState<Data, Variables>>

     

       
259
       
 
       
    ) => {

     

       
260
       
-
       
      setState(state => {

     

       
261
       
 
       
        const nextResult = computeNextState(state[1], result);

     

       
262
       
 
       
        if (state[1] === nextResult) return state;

     

       
263
       
 
       
        if (handlerRef.current && state[1].data !== nextResult.data) {

     
···

       
292
       
 
       
        ...opts,

     

       
293
       
 
       
      });

     

       
294
       
 
       


     

       
295
       
-
       
      setState(state => [source, state[1], deps]);

     

       
296
       
 
       
    },

     

       
297
       
 
       
    [client, args.context, request]

     

       
298
       
 
       
  );

     

···

       
13
       
 
       


     

       
14
       
 
       
import { useClient } from '../context';

     

       
15
       
 
       
import { useRequest } from './useRequest';

     

       
16
       
+
       


     

       
17
       
+
       
import {

     

       
18
       
+
       
  deferDispatch,

     

       
19
       
+
       
  initialState,

     

       
20
       
+
       
  computeNextState,

     

       
21
       
+
       
  hasDepsChanged,

     

       
22
       
+
       
} from './state';

     

       
23
       
 
       


     

       
24
       
 
       
/** Input arguments for the {@link useSubscription} hook.

     

       
25
       
 
       
 *

     
···

       
263
       
 
       
    const updateResult = (

     

       
264
       
 
       
      result: Partial<UseSubscriptionState<Data, Variables>>

     

       
265
       
 
       
    ) => {

     

       
266
       
+
       
      deferDispatch(setState, state => {

     

       
267
       
 
       
        const nextResult = computeNextState(state[1], result);

     

       
268
       
 
       
        if (state[1] === nextResult) return state;

     

       
269
       
 
       
        if (handlerRef.current && state[1].data !== nextResult.data) {

     
···

       
298
       
 
       
        ...opts,

     

       
299
       
 
       
      });

     

       
300
       
 
       


     

       
301
       
+
       
      deferDispatch(setState, state => [source, state[1], deps]);

     

       
302
       
 
       
    },

     

       
303
       
 
       
    [client, args.context, request]

     

       
304
       
 
       
  );