react 19.0.0-canary-4c12339ce-20240408 → 19.0.0-canary-adb717393-20240411

package/umd/react.development.js

@@ -14,7 +14,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.React = {}));
 })(this, (function (exports) { 'use strict';
 
-  var ReactVersion = '19.0.0-canary-4c12339ce-20240408';
+  var ReactVersion = '19.0.0-canary-adb717393-20240411';
 
   // ATTENTION
   // When adding new symbols to this file,
@@ -51,77 +51,62 @@
     return null;
   }
 
-  /**
-   * Keeps track of the current dispatcher.
-   */
-  var ReactCurrentDispatcher$1 = {
-    current: null
-  };
+  // -----------------------------------------------------------------------------
 
-  /**
-   * Keeps track of the current Cache dispatcher.
-   */
-  var ReactCurrentCache = {
-    current: null
-  };
+  var enableScopeAPI = false; // Experimental Create Event Handle API.
+  var enableTransitionTracing = false; // No known bugs, but needs performance testing
 
-  /**
-   * Keeps track of the current batch's configuration such as how long an update
-   * should suspend for if it needs to.
-   */
-  var ReactCurrentBatchConfig = {
-    transition: null
-  };
+  var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+  // as a normal prop instead of stripping it from the props object.
+  // Passes `ref` as a normal prop instead of stripping it from the props object
+  // during element creation.
 
-  var ReactCurrentActQueue = {
-    current: null,
-    // Used to reproduce behavior of `batchedUpdates` in legacy mode.
-    isBatchingLegacy: false,
-    didScheduleLegacyUpdate: false,
-    // Tracks whether something called `use` during the current batch of work.
-    // Determines whether we should yield to microtasks to unwrap already resolved
-    // promises without suspending.
-    didUsePromise: false,
-    // Track first uncaught error within this act
-    thrownErrors: []
-  };
+  var enableRefAsProp = true;
+  // This allows us to land breaking changes to remove legacy mode APIs in experimental builds
+  // before removing them in stable in the next Major
 
-  /**
-   * Keeps track of the current owner.
-   *
-   * The current owner is the component who should own any components that are
-   * currently being constructed.
-   */
-  var ReactCurrentOwner$1 = {
-    /**
-     * @internal
-     * @type {ReactComponent}
-     */
-    current: null
+  var disableLegacyMode = true;
+
+  var enableRenderableContext = true; // -----------------------------------------------------------------------------
+  // stuff. Intended to enable React core members to more easily debug scheduling
+  // issues in DEV builds.
+
+  var enableDebugTracing = false;
+
+  var ReactSharedInternals$1 = {
+    H: null,
+    C: null,
+    T: null
   };
 
-  var ReactDebugCurrentFrame$1 = {};
-  var currentExtraStackFrame = null;
+  {
+    ReactSharedInternals$1.owner = null;
+  }
 
   {
-    ReactDebugCurrentFrame$1.setExtraStackFrame = function (stack) {
-      {
-        currentExtraStackFrame = stack;
-      }
+    ReactSharedInternals$1.actQueue = null;
+    ReactSharedInternals$1.isBatchingLegacy = false;
+    ReactSharedInternals$1.didScheduleLegacyUpdate = false;
+    ReactSharedInternals$1.didUsePromise = false;
+    ReactSharedInternals$1.thrownErrors = [];
+    var currentExtraStackFrame$1 = null;
+
+    ReactSharedInternals$1.setExtraStackFrame = function (stack) {
+      currentExtraStackFrame$1 = stack;
     }; // Stack implementation injected by the current renderer.
 
 
-    ReactDebugCurrentFrame$1.getCurrentStack = null;
+    ReactSharedInternals$1.getCurrentStack = null;
 
-    ReactDebugCurrentFrame$1.getStackAddendum = function () {
+    ReactSharedInternals$1.getStackAddendum = function () {
       var stack = ''; // Add an extra top frame while an element is being validated
 
-      if (currentExtraStackFrame) {
-        stack += currentExtraStackFrame;
+      if (currentExtraStackFrame$1) {
+        stack += currentExtraStackFrame$1;
       } // Delegate to the injected renderer-specific implementation
 
 
-      var impl = ReactDebugCurrentFrame$1.getCurrentStack;
+      var impl = ReactSharedInternals$1.getCurrentStack;
 
       if (impl) {
         stack += impl() || '';
@@ -131,18 +116,6 @@
     };
   }
 
-  var ReactSharedInternals = {
-    ReactCurrentDispatcher: ReactCurrentDispatcher$1,
-    ReactCurrentCache: ReactCurrentCache,
-    ReactCurrentBatchConfig: ReactCurrentBatchConfig,
-    ReactCurrentOwner: ReactCurrentOwner$1
-  };
-
-  {
-    ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame$1;
-    ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
-  }
-
   // by calls to these methods by a Babel plugin.
   //
   // In PROD (or in packages without access to React internals),
@@ -175,8 +148,7 @@
     // When changing this logic, you might want to also
     // update consoleWithStackDev.www.js as well.
     {
-      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-      var stack = ReactDebugCurrentFrame.getStackAddendum();
+      var stack = ReactSharedInternals$1.getStackAddendum();
 
       if (stack !== '') {
         format += '%s';
@@ -496,28 +468,6 @@
     }
   }
 
-  // -----------------------------------------------------------------------------
-
-  var enableScopeAPI = false; // Experimental Create Event Handle API.
-  var enableTransitionTracing = false; // No known bugs, but needs performance testing
-
-  var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
-  // as a normal prop instead of stripping it from the props object.
-  // Passes `ref` as a normal prop instead of stripping it from the props object
-  // during element creation.
-
-  var enableRefAsProp = true;
-  // This allows us to land breaking changes to remove legacy mode APIs in experimental builds
-  // before removing them in stable in the next Major
-
-  var disableLegacyMode = true;
-
-  var enableRenderableContext = true; // -----------------------------------------------------------------------------
-  // stuff. Intended to enable React core members to more easily debug scheduling
-  // issues in DEV builds.
-
-  var enableDebugTracing = false;
-
   function getWrappedName(outerType, innerType, wrapperName) {
     var displayName = outerType.displayName;
 
@@ -753,7 +703,6 @@
     }
   }
 
-  var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
   var prefix;
   function describeBuiltInComponentFrame(name) {
     {
@@ -809,13 +758,13 @@
     var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
 
     Error.prepareStackTrace = undefined;
-    var previousDispatcher;
+    var previousDispatcher = null;
 
     {
-      previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
+      previousDispatcher = ReactSharedInternals$1.H; // Set the dispatcher in DEV because this might be call in the render function
       // for warnings.
 
-      ReactCurrentDispatcher.current = null;
+      ReactSharedInternals$1.H = null;
       disableLogs();
     }
     /**
@@ -1000,7 +949,7 @@
       reentry = false;
 
       {
-        ReactCurrentDispatcher.current = previousDispatcher;
+        ReactSharedInternals$1.H = previousDispatcher;
         reenableLogs();
       }
 
@@ -1080,11 +1029,10 @@
     return '';
   }
 
-  var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
-  var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
   var REACT_CLIENT_REFERENCE = Symbol.for('react.client.reference');
   var specialPropKeyWarningShown;
   var didWarnAboutElementRef;
+  var didWarnAboutOldJSXRuntime;
 
   {
     didWarnAboutElementRef = {};
@@ -1319,6 +1267,20 @@
     var ref = null;
 
     if (config != null) {
+      {
+        if (!didWarnAboutOldJSXRuntime && '__self' in config && // Do not assume this is the result of an oudated JSX transform if key
+        // is present, because the modern JSX transform sometimes outputs
+        // createElement to preserve precedence between a static key and a
+        // spread key. To avoid false positive warnings, we never warn if
+        // there's a key.
+        !('key' in config)) {
+          didWarnAboutOldJSXRuntime = true;
+
+          warn('Your app (or one of its dependencies) is using an outdated JSX ' + 'transform. Update to the modern JSX transform for ' + 'faster performance: ' + // TODO: Create a short link for this
+          'https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html');
+        }
+      }
+
       if (hasValidRef(config)) ;
 
       if (hasValidKey(config)) {
@@ -1387,7 +1349,7 @@
       }
     }
 
-    var element = ReactElement(type, key, ref, undefined, undefined, ReactCurrentOwner.current, props);
+    var element = ReactElement(type, key, ref, undefined, undefined, ReactSharedInternals$1.owner, props);
 
     if (type === REACT_FRAGMENT_TYPE) {
       validateFragmentProps(element);
@@ -1421,8 +1383,7 @@
 
     if (config != null) {
       if (hasValidRef(config)) {
-
-        owner = ReactCurrentOwner.current;
+        owner = ReactSharedInternals$1.owner;
       }
 
       if (hasValidKey(config)) {
@@ -1481,8 +1442,8 @@
 
   function getDeclarationErrorAddendum() {
     {
-      if (ReactCurrentOwner.current) {
-        var name = getComponentNameFromType(ReactCurrentOwner.current.type);
+      if (ReactSharedInternals$1.owner) {
+        var name = getComponentNameFromType(ReactSharedInternals$1.owner.type);
 
         if (name) {
           return '\n\nCheck the render method of `' + name + '`.';
@@ -1586,7 +1547,7 @@
 
       var childOwner = '';
 
-      if (element && element._owner != null && element._owner !== ReactCurrentOwner.current) {
+      if (element && element._owner != null && element._owner !== ReactSharedInternals$1.owner) {
         var ownerName = null;
 
         if (typeof element._owner.tag === 'number') {
@@ -1611,9 +1572,9 @@
     {
       if (element) {
         var stack = describeUnknownElementTypeFrameInDEV(element.type);
-        ReactDebugCurrentFrame.setExtraStackFrame(stack);
+        ReactSharedInternals$1.setExtraStackFrame(stack);
       } else {
-        ReactDebugCurrentFrame.setExtraStackFrame(null);
+        ReactSharedInternals$1.setExtraStackFrame(null);
       }
     }
   }
@@ -2241,7 +2202,7 @@
 
   function cache$1(fn) {
     return function () {
-      var dispatcher = ReactCurrentCache.current;
+      var dispatcher = ReactSharedInternals$1.C;
 
       if (!dispatcher) {
         // If there is no dispatcher, then we treat this as not being cached.
@@ -2326,7 +2287,7 @@
   var cache = cache$1;
 
   function resolveDispatcher() {
-    var dispatcher = ReactCurrentDispatcher$1.current;
+    var dispatcher = ReactSharedInternals$1.H;
 
     {
       if (dispatcher === null) {
@@ -3024,11 +2985,10 @@
     unstable_wrapCallback: unstable_wrapCallback
   });
 
-  var ReactSharedInternalsClient = {
-    ReactCurrentDispatcher: ReactCurrentDispatcher$1,
-    ReactCurrentCache: ReactCurrentCache,
-    ReactCurrentOwner: ReactCurrentOwner$1,
-    ReactCurrentBatchConfig: ReactCurrentBatchConfig,
+  var ReactSharedInternals = {
+    H: null,
+    C: null,
+    T: null,
     // Re-export the schedule API(s) for UMD bundles.
     // This avoids introducing a dependency on a new UMD global in a minor update,
     // Since that would be a breaking change (e.g. for all existing CodeSandboxes).
@@ -3038,8 +2998,40 @@
   };
 
   {
-    ReactSharedInternalsClient.ReactCurrentActQueue = ReactCurrentActQueue;
-    ReactSharedInternalsClient.ReactDebugCurrentFrame = ReactDebugCurrentFrame$1;
+    ReactSharedInternals.owner = null;
+  }
+
+  {
+    ReactSharedInternals.actQueue = null;
+    ReactSharedInternals.isBatchingLegacy = false;
+    ReactSharedInternals.didScheduleLegacyUpdate = false;
+    ReactSharedInternals.didUsePromise = false;
+    ReactSharedInternals.thrownErrors = [];
+    var currentExtraStackFrame = null;
+
+    ReactSharedInternals.setExtraStackFrame = function (stack) {
+      currentExtraStackFrame = stack;
+    }; // Stack implementation injected by the current renderer.
+
+
+    ReactSharedInternals.getCurrentStack = null;
+
+    ReactSharedInternals.getStackAddendum = function () {
+      var stack = ''; // Add an extra top frame while an element is being validated
+
+      if (currentExtraStackFrame) {
+        stack += currentExtraStackFrame;
+      } // Delegate to the injected renderer-specific implementation
+
+
+      var impl = ReactSharedInternals.getCurrentStack;
+
+      if (impl) {
+        stack += impl() || '';
+      }
+
+      return stack;
+    };
   }
 
   var reportGlobalError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,
@@ -3073,18 +3065,18 @@
   };
 
   function startTransition(scope, options) {
-    var prevTransition = ReactCurrentBatchConfig.transition; // Each renderer registers a callback to receive the return value of
+    var prevTransition = ReactSharedInternals$1.T; // Each renderer registers a callback to receive the return value of
     // the scope function. This is used to implement async actions.
 
     var callbacks = new Set();
     var transition = {
       _callbacks: callbacks
     };
-    ReactCurrentBatchConfig.transition = transition;
-    var currentTransition = ReactCurrentBatchConfig.transition;
+    ReactSharedInternals$1.T = transition;
+    var currentTransition = ReactSharedInternals$1.T;
 
     {
-      ReactCurrentBatchConfig.transition._updatedFibers = new Set();
+      ReactSharedInternals$1.T._updatedFibers = new Set();
     }
 
     {
@@ -3101,7 +3093,7 @@
         reportGlobalError(error);
       } finally {
         warnAboutTransitionSubscriptions(prevTransition, currentTransition);
-        ReactCurrentBatchConfig.transition = prevTransition;
+        ReactSharedInternals$1.T = prevTransition;
       }
     }
   }
@@ -3176,7 +3168,7 @@
 
   function act(callback) {
     {
-      // When ReactCurrentActQueue.current is not null, it signals to React that
+      // When ReactSharedInternals.actQueue is not null, it signals to React that
       // we're currently inside an `act` scope. React will push all its tasks to
       // this queue instead of scheduling them with platform APIs.
       //
@@ -3186,10 +3178,10 @@
       //
       // If we're already inside an `act` scope, reuse the existing queue.
       var prevIsBatchingLegacy = false;
-      var prevActQueue = ReactCurrentActQueue.current;
+      var prevActQueue = ReactSharedInternals.actQueue;
       var prevActScopeDepth = actScopeDepth;
       actScopeDepth++;
-      var queue = ReactCurrentActQueue.current = prevActQueue !== null ? prevActQueue : []; // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
+      var queue = ReactSharedInternals.actQueue = prevActQueue !== null ? prevActQueue : []; // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
 
       var result; // This tracks whether the `act` call is awaited. In certain cases, not
       // awaiting it is a mistake, so we will detect that and warn.
@@ -3203,7 +3195,7 @@
         if (!disableLegacyMode) ;
 
         result = callback();
-        var didScheduleLegacyUpdate = !disableLegacyMode ? ReactCurrentActQueue.didScheduleLegacyUpdate : false; // Replicate behavior of original `act` implementation in legacy mode,
+        var didScheduleLegacyUpdate = !disableLegacyMode ? ReactSharedInternals.didScheduleLegacyUpdate : false; // Replicate behavior of original `act` implementation in legacy mode,
         // which flushed updates immediately after the scope function exits, even
         // if it's an async function.
 
@@ -3221,14 +3213,14 @@
         // one used to track `act` scopes. Why, you may be wondering? Because
         // that's how it worked before version 18. Yes, it's confusing! We should
         // delete legacy mode!!
-        ReactCurrentActQueue.thrownErrors.push(error);
+        ReactSharedInternals.thrownErrors.push(error);
       }
 
-      if (ReactCurrentActQueue.thrownErrors.length > 0) {
+      if (ReactSharedInternals.thrownErrors.length > 0) {
 
         popActScope(prevActQueue, prevActScopeDepth);
-        var thrownError = aggregateErrors(ReactCurrentActQueue.thrownErrors);
-        ReactCurrentActQueue.thrownErrors.length = 0;
+        var thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+        ReactSharedInternals.thrownErrors.length = 0;
         throw thrownError;
       }
 
@@ -3269,13 +3261,13 @@
                   // `thenable` might not be a real promise, and `flushActQueue`
                   // might throw, so we need to wrap `flushActQueue` in a
                   // try/catch.
-                  ReactCurrentActQueue.thrownErrors.push(error);
+                  ReactSharedInternals.thrownErrors.push(error);
                 }
 
-                if (ReactCurrentActQueue.thrownErrors.length > 0) {
-                  var _thrownError = aggregateErrors(ReactCurrentActQueue.thrownErrors);
+                if (ReactSharedInternals.thrownErrors.length > 0) {
+                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
 
-                  ReactCurrentActQueue.thrownErrors.length = 0;
+                  ReactSharedInternals.thrownErrors.length = 0;
                   reject(_thrownError);
                 }
               } else {
@@ -3284,10 +3276,10 @@
             }, function (error) {
               popActScope(prevActQueue, prevActScopeDepth);
 
-              if (ReactCurrentActQueue.thrownErrors.length > 0) {
-                var _thrownError2 = aggregateErrors(ReactCurrentActQueue.thrownErrors);
+              if (ReactSharedInternals.thrownErrors.length > 0) {
+                var _thrownError2 = aggregateErrors(ReactSharedInternals.thrownErrors);
 
-                ReactCurrentActQueue.thrownErrors.length = 0;
+                ReactSharedInternals.thrownErrors.length = 0;
                 reject(_thrownError2);
               } else {
                 reject(error);
@@ -3335,13 +3327,13 @@
           // to be awaited, regardless of whether the callback is sync or async.
 
 
-          ReactCurrentActQueue.current = null;
+          ReactSharedInternals.actQueue = null;
         }
 
-        if (ReactCurrentActQueue.thrownErrors.length > 0) {
-          var _thrownError3 = aggregateErrors(ReactCurrentActQueue.thrownErrors);
+        if (ReactSharedInternals.thrownErrors.length > 0) {
+          var _thrownError3 = aggregateErrors(ReactSharedInternals.thrownErrors);
 
-          ReactCurrentActQueue.thrownErrors.length = 0;
+          ReactSharedInternals.thrownErrors.length = 0;
           throw _thrownError3;
         }
 
@@ -3352,7 +3344,7 @@
             if (prevActScopeDepth === 0) {
               // If the `act` call is awaited, restore the queue we were
               // using before (see long comment above) so we can flush it.
-              ReactCurrentActQueue.current = queue;
+              ReactSharedInternals.actQueue = queue;
               enqueueTask(function () {
                 return (// Recursively flush tasks scheduled by a microtask.
                   recursivelyFlushAsyncActWork(returnValue, resolve, reject)
@@ -3380,7 +3372,7 @@
   function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
     {
       // Check if any tasks were scheduled asynchronously.
-      var queue = ReactCurrentActQueue.current;
+      var queue = ReactSharedInternals.actQueue;
 
       if (queue !== null) {
         if (queue.length !== 0) {
@@ -3396,17 +3388,17 @@
             return;
           } catch (error) {
             // Leave remaining tasks on the queue if something throws.
-            ReactCurrentActQueue.thrownErrors.push(error);
+            ReactSharedInternals.thrownErrors.push(error);
           }
         } else {
           // The queue is empty. We can finish.
-          ReactCurrentActQueue.current = null;
+          ReactSharedInternals.actQueue = null;
         }
       }
 
-      if (ReactCurrentActQueue.thrownErrors.length > 0) {
-        var thrownError = aggregateErrors(ReactCurrentActQueue.thrownErrors);
-        ReactCurrentActQueue.thrownErrors.length = 0;
+      if (ReactSharedInternals.thrownErrors.length > 0) {
+        var thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+        ReactSharedInternals.thrownErrors.length = 0;
         reject(thrownError);
       } else {
         resolve(returnValue);
@@ -3428,11 +3420,11 @@
             var callback = queue[i];
 
             do {
-              ReactCurrentActQueue.didUsePromise = false;
+              ReactSharedInternals.didUsePromise = false;
               var continuation = callback(false);
 
               if (continuation !== null) {
-                if (ReactCurrentActQueue.didUsePromise) {
+                if (ReactSharedInternals.didUsePromise) {
                   // The component just suspended. Yield to the main thread in
                   // case the promise is already resolved. If so, it will ping in
                   // a microtask and we can resume without unwinding the stack.
@@ -3453,7 +3445,7 @@
         } catch (error) {
           // If something throws, leave the remaining callbacks on the queue.
           queue.splice(0, i + 1);
-          ReactCurrentActQueue.thrownErrors.push(error);
+          ReactSharedInternals.thrownErrors.push(error);
         } finally {
           isFlushing = false;
         }
@@ -3492,7 +3484,7 @@
   exports.PureComponent = PureComponent;
   exports.StrictMode = REACT_STRICT_MODE_TYPE;
   exports.Suspense = REACT_SUSPENSE_TYPE;
-  exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternalsClient;
+  exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
   exports.act = act;
   exports.cache = cache;
   exports.cloneElement = cloneElement;