react 19.0.0-canary-e3ebcd54b-20240405 → 19.0.0-canary-adb717393-20240411

package/cjs/react.development.js

@@ -23,7 +23,7 @@ if (
 ) {
   __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
 }
-          var ReactVersion = '19.0.0-canary-e3ebcd54b-20240405';
+          var ReactVersion = '19.0.0-canary-adb717393-20240411';
 
 // ATTENTION
 // When adding new symbols to this file,
@@ -60,69 +60,54 @@ function getIteratorFn(maybeIterable) {
   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 = {
+  H: null,
+  C: null,
+  T: null
 };
 
-var ReactDebugCurrentFrame$1 = {};
-var currentExtraStackFrame = null;
+{
+  ReactSharedInternals.owner = null;
+}
 
 {
-  ReactDebugCurrentFrame$1.setExtraStackFrame = function (stack) {
-    {
-      currentExtraStackFrame = stack;
-    }
+  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.
 
 
-  ReactDebugCurrentFrame$1.getCurrentStack = null;
+  ReactSharedInternals.getCurrentStack = null;
 
-  ReactDebugCurrentFrame$1.getStackAddendum = function () {
+  ReactSharedInternals.getStackAddendum = function () {
     var stack = ''; // Add an extra top frame while an element is being validated
 
     if (currentExtraStackFrame) {
@@ -130,7 +115,7 @@ var currentExtraStackFrame = null;
     } // Delegate to the injected renderer-specific implementation
 
 
-    var impl = ReactDebugCurrentFrame$1.getCurrentStack;
+    var impl = ReactSharedInternals.getCurrentStack;
 
     if (impl) {
       stack += impl() || '';
@@ -140,18 +125,6 @@ var currentExtraStackFrame = null;
   };
 }
 
-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),
@@ -184,8 +157,7 @@ function printWarning(level, format, args) {
   // 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.getStackAddendum();
 
     if (stack !== '') {
       format += '%s';
@@ -505,28 +477,6 @@ function checkKeyStringCoercion(value) {
   }
 }
 
-// -----------------------------------------------------------------------------
-
-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;
 
@@ -762,9 +712,8 @@ function reenableLogs() {
   }
 }
 
-var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
 var prefix;
-function describeBuiltInComponentFrame(name, ownerFn) {
+function describeBuiltInComponentFrame(name) {
   {
     if (prefix === undefined) {
       // Extract the VM specific prefix used by each line.
@@ -818,13 +767,13 @@ function describeNativeComponentFrame(fn, construct) {
   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.H; // Set the dispatcher in DEV because this might be call in the render function
     // for warnings.
 
-    ReactCurrentDispatcher.current = null;
+    ReactSharedInternals.H = null;
     disableLogs();
   }
   /**
@@ -1009,7 +958,7 @@ function describeNativeComponentFrame(fn, construct) {
     reentry = false;
 
     {
-      ReactCurrentDispatcher.current = previousDispatcher;
+      ReactSharedInternals.H = previousDispatcher;
       reenableLogs();
     }
 
@@ -1028,7 +977,7 @@ function describeNativeComponentFrame(fn, construct) {
 
   return syntheticFrame;
 }
-function describeFunctionComponentFrame(fn, ownerFn) {
+function describeFunctionComponentFrame(fn) {
   {
     return describeNativeComponentFrame(fn, false);
   }
@@ -1039,7 +988,7 @@ function shouldConstruct(Component) {
   return !!(prototype && prototype.isReactComponent);
 }
 
-function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
+function describeUnknownElementTypeFrameInDEV(type) {
 
   if (type == null) {
     return '';
@@ -1070,7 +1019,7 @@ function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
 
       case REACT_MEMO_TYPE:
         // Memo may contain any component type so we recursively resolve it.
-        return describeUnknownElementTypeFrameInDEV(type.type, ownerFn);
+        return describeUnknownElementTypeFrameInDEV(type.type);
 
       case REACT_LAZY_TYPE:
         {
@@ -1080,7 +1029,7 @@ function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
 
           try {
             // Lazy may contain any component type so we recursively resolve it.
-            return describeUnknownElementTypeFrameInDEV(init(payload), ownerFn);
+            return describeUnknownElementTypeFrameInDEV(init(payload));
           } catch (x) {}
         }
     }
@@ -1089,11 +1038,10 @@ function describeUnknownElementTypeFrameInDEV(type, ownerFn) {
   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 = {};
@@ -1328,6 +1276,20 @@ function createElement(type, config, children) {
   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)) {
@@ -1396,7 +1358,7 @@ function createElement(type, config, children) {
     }
   }
 
-  var element = ReactElement(type, key, ref, undefined, undefined, ReactCurrentOwner.current, props);
+  var element = ReactElement(type, key, ref, undefined, undefined, ReactSharedInternals.owner, props);
 
   if (type === REACT_FRAGMENT_TYPE) {
     validateFragmentProps(element);
@@ -1430,8 +1392,7 @@ function cloneElement(element, config, children) {
 
   if (config != null) {
     if (hasValidRef(config)) {
-
-      owner = ReactCurrentOwner.current;
+      owner = ReactSharedInternals.owner;
     }
 
     if (hasValidKey(config)) {
@@ -1490,8 +1451,8 @@ function cloneElement(element, config, children) {
 
 function getDeclarationErrorAddendum() {
   {
-    if (ReactCurrentOwner.current) {
-      var name = getComponentNameFromType(ReactCurrentOwner.current.type);
+    if (ReactSharedInternals.owner) {
+      var name = getComponentNameFromType(ReactSharedInternals.owner.type);
 
       if (name) {
         return '\n\nCheck the render method of `' + name + '`.';
@@ -1595,9 +1556,17 @@ function validateExplicitKey(element, parentType) {
 
     var childOwner = '';
 
-    if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
-      // Give the component that originally created this child.
-      childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+    if (element && element._owner != null && element._owner !== ReactSharedInternals.owner) {
+      var ownerName = null;
+
+      if (typeof element._owner.tag === 'number') {
+        ownerName = getComponentNameFromType(element._owner.type);
+      } else if (typeof element._owner.name === 'string') {
+        ownerName = element._owner.name;
+      } // Give the component that originally created this child.
+
+
+      childOwner = " It was passed a child from " + ownerName + ".";
     }
 
     setCurrentlyValidatingElement(element);
@@ -1611,11 +1580,10 @@ function validateExplicitKey(element, parentType) {
 function setCurrentlyValidatingElement(element) {
   {
     if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(element.type, owner ? owner.type : null);
-      ReactDebugCurrentFrame.setExtraStackFrame(stack);
+      var stack = describeUnknownElementTypeFrameInDEV(element.type);
+      ReactSharedInternals.setExtraStackFrame(stack);
     } else {
-      ReactDebugCurrentFrame.setExtraStackFrame(null);
+      ReactSharedInternals.setExtraStackFrame(null);
     }
   }
 }
@@ -2243,7 +2211,7 @@ function createCacheNode() {
 
 function cache$1(fn) {
   return function () {
-    var dispatcher = ReactCurrentCache.current;
+    var dispatcher = ReactSharedInternals.C;
 
     if (!dispatcher) {
       // If there is no dispatcher, then we treat this as not being cached.
@@ -2328,7 +2296,7 @@ function cache$1(fn) {
 var cache = cache$1;
 
 function resolveDispatcher() {
-  var dispatcher = ReactCurrentDispatcher$1.current;
+  var dispatcher = ReactSharedInternals.H;
 
   {
     if (dispatcher === null) {
@@ -2463,18 +2431,18 @@ reportError : function (error) {
 };
 
 function startTransition(scope, options) {
-  var prevTransition = ReactCurrentBatchConfig.transition; // Each renderer registers a callback to receive the return value of
+  var prevTransition = ReactSharedInternals.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.T = transition;
+  var currentTransition = ReactSharedInternals.T;
 
   {
-    ReactCurrentBatchConfig.transition._updatedFibers = new Set();
+    ReactSharedInternals.T._updatedFibers = new Set();
   }
 
   {
@@ -2491,7 +2459,7 @@ function startTransition(scope, options) {
       reportGlobalError(error);
     } finally {
       warnAboutTransitionSubscriptions(prevTransition, currentTransition);
-      ReactCurrentBatchConfig.transition = prevTransition;
+      ReactSharedInternals.T = prevTransition;
     }
   }
 }
@@ -2566,7 +2534,7 @@ function aggregateErrors(errors) {
 
 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.
     //
@@ -2576,10 +2544,10 @@ function act(callback) {
     //
     // 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.
@@ -2593,7 +2561,7 @@ function act(callback) {
       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.
 
@@ -2611,14 +2579,14 @@ function act(callback) {
       // 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;
     }
 
@@ -2659,13 +2627,13 @@ function act(callback) {
                 // `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 {
@@ -2674,10 +2642,10 @@ function act(callback) {
           }, 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);
@@ -2725,13 +2693,13 @@ function act(callback) {
         // 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;
       }
 
@@ -2742,7 +2710,7 @@ function act(callback) {
           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)
@@ -2770,7 +2738,7 @@ function popActScope(prevActQueue, prevActScopeDepth) {
 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) {
@@ -2786,17 +2754,17 @@ function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
           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);
@@ -2818,11 +2786,11 @@ function flushActQueue(queue) {
           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.
@@ -2843,7 +2811,7 @@ function flushActQueue(queue) {
       } 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;
       }
@@ -2882,7 +2850,7 @@ exports.Profiler = REACT_PROFILER_TYPE;
 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 = ReactSharedInternals;
+exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
 exports.act = act;
 exports.cache = cache;
 exports.cloneElement = cloneElement;