commit 0e20aad0f1736aba0d5f47819ba0dd6ccc64ff8d · kitten.sh/urql

+5

.changeset/rich-melons-play.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       'urql': patch

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Upgrade false-positive circumvention for internal React warning to support React 19

+23 -15

packages/react-urql/src/hooks/state.ts

···

       1
       1
       -
       import * as React from 'react';

     

       1
       1
       +
       import type { Dispatch } from 'react';

     

       2
       2
        
       

     

       3
       3
        
       export const initialState = {

     

       4
       4
        
         fetching: false,

     
···

       65
       65
        
         return false;

     

       66
       66
        
       };

     

       67
       67
        
       

     

       68
       68
       -
       const reactSharedInternals = (React as any)

     

       69
       69
       -
         .__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

     

       68
       68
       +
       let isDispatching = false;

     

       70
       69
        
       

     

       71
       71
       -
       export function deferDispatch<Dispatch extends React.Dispatch<any>>(

     

       72
       72
       -
         setState: Dispatch,

     

       73
       73
       -
         value: Dispatch extends React.Dispatch<infer State> ? State : void

     

       74
       74
       -
       ) {

     

       75
       75
       -
         if (

     

       76
       76
       -
           process.env.NODE_ENV !== 'production' &&

     

       77
       77
       -
           !!reactSharedInternals &&

     

       78
       78
       -
           !!reactSharedInternals.ReactCurrentOwner &&

     

       79
       79
       -
           !!reactSharedInternals.ReactCurrentOwner.current

     

       80
       80
       -
         ) {

     

       81
       81
       -
           Promise.resolve(value).then(setState);

     

       70
       70
       +
       function deferDispatch<F extends Dispatch<any>>(

     

       71
       71
       +
         setState: F,

     

       72
       72
       +
         value: F extends Dispatch<infer State> ? State : void

     

       73
       73
       +
       ): void;

     

       74
       74
       +
       

     

       75
       75
       +
       function deferDispatch<F extends Dispatch<any>>(setState: F): ReturnType<F>;

     

       76
       76
       +
       

     

       77
       77
       +
       function deferDispatch<F extends Dispatch<any>>(

     

       78
       78
       +
         setState: F,

     

       79
       79
       +
         value?: F extends Dispatch<infer State> ? State : void

     

       80
       80
       +
       ): any {

     

       81
       81
       +
         if (!isDispatching || value === undefined) {

     

       82
       82
       +
           try {

     

       83
       83
       +
             isDispatching = true;

     

       84
       84
       +
             return setState(value);

     

       85
       85
       +
           } finally {

     

       86
       86
       +
             isDispatching = false;

     

       87
       87
       +
           }

     

       82
       88
        
         } else {

     

       83
       83
       -
           setState(value);

     

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

     

       84
       90
        
         }

     

       85
       91
        
       }

     

       92
       92
       +
       

     

       93
       93
       +
       export { deferDispatch };

+5 -2

packages/react-urql/src/hooks/useQuery.ts

···

       308
       308
        
           () =>

     

       309
       309
        
             [

     

       310
       310
        
               source,

     

       311
       311
       -
               computeNextState(initialState, getSnapshot(source, suspense)),

     

       311
       311
       +
               computeNextState(

     

       312
       312
       +
                 initialState,

     

       313
       313
       +
                 deferDispatch(() => getSnapshot(source, suspense))

     

       314
       314
       +
               ),

     

       312
       315
        
               deps,

     

       313
       316
        
             ] as const

     

       314
       317
        
         );

     
···

       319
       322
        
             source,

     

       320
       323
        
             (currentResult = computeNextState(

     

       321
       324
        
               state[1],

     

       322
       322
       -
               getSnapshot(source, suspense)

     

       325
       325
       +
               deferDispatch(() => getSnapshot(source, suspense))

     

       323
       326
        
             )),

     

       324
       327
        
             deps,

     

       325
       328
        
           ]);