react-native 0.0.0-263478b91 → 0.0.0-268efb102

package/Libraries/Components/View/ViewAccessibility.js

@@ -39,8 +39,10 @@ export type AccessibilityRole =
   | 'spinbutton'
   | 'switch'
   | 'tab'
+  | 'tabbar'
   | 'tablist'
   | 'timer'
+  | 'list'
   | 'toolbar';
 
 // the info associated with an accessibility action

package/Libraries/Components/View/ViewNativeComponent.js

@@ -13,10 +13,8 @@ import {type HostComponent} from '../../Renderer/shims/ReactNativeTypes';
 import Platform from '../../Utilities/Platform';
 import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
 import ReactNativeViewViewConfigAndroid from './ReactNativeViewViewConfigAndroid';
-import ViewInjection from './ViewInjection';
 import {type ViewProps as Props} from './ViewPropTypes';
 import * as React from 'react';
-import ReactNativeViewConfigRegistry from '../../Renderer/shims/ReactNativeViewConfigRegistry';
 
 const ViewNativeComponent: HostComponent<Props> = NativeComponentRegistry.get<Props>(
   'RCTView',
@@ -26,14 +24,6 @@ const ViewNativeComponent: HostComponent<Props> = NativeComponentRegistry.get<Pr
       : {uiViewClassName: 'RCTView'},
 );
 
-if (Platform.OS === 'ios') {
-  if (ViewInjection.unstable_enableCollapsable) {
-    const viewConfig = ReactNativeViewConfigRegistry.get('RCTView');
-    // $FlowFixMe - Yes, knowingly writing to a read-only property.
-    viewConfig.validAttributes.collapsable = true;
-  }
-}
-
 interface NativeCommands {
   +hotspotUpdate: (
     viewRef: React.ElementRef<HostComponent<mixed>>,

package/Libraries/Core/Devtools/parseErrorStack.js

@@ -15,16 +15,6 @@ import type {HermesParsedStack} from './parseHermesStack';
 
 const parseHermesStack = require('./parseHermesStack');
 
-// $FlowFixMe[incompatible-exact]
-export type ExtendedError = Error &
-  interface {
-    jsEngine?: string,
-    preventSymbolication?: boolean,
-    componentStack?: string,
-    forceRedbox?: boolean,
-    isComponentError?: boolean,
-  };
-
 function convertHermesStack(stack: HermesParsedStack): Array<StackFrame> {
   const frames = [];
   for (const entry of stack.entries) {

package/Libraries/Core/Devtools/parseHermesStack.js

@@ -58,7 +58,7 @@ export type HermesParsedStack = {|
 // 4. source URL (filename)
 // 5. line number (1 based)
 // 6. column number (1 based) or virtual offset (0 based)
-const RE_FRAME = /^ {4}at (.+?)(?: \((native)\)?| \((address at )?(.+?):(\d+):(\d+)\))$/;
+const RE_FRAME = /^ {4}at (.+?)(?: \((native)\)?| \((address at )?(.*?):(\d+):(\d+)\))$/;
 
 // Capturing groups:
 // 1. count of skipped frames

package/Libraries/Core/ExceptionsManager.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-import type {ExtendedError} from './Devtools/parseErrorStack';
+import type {ExtendedError} from './ExtendedError';
 import type {ExceptionData} from './NativeExceptionsManager';
 
 class SyntheticError extends Error {
@@ -76,7 +76,9 @@ function reportException(
       e.jsEngine == null ? message : `${message}, js engine: ${e.jsEngine}`;
 
     const isHandledByLogBox =
-      e.forceRedbox !== true && !global.RN$Bridgeless && !global.RN$Express;
+      e.forceRedbox !== true &&
+      global.RN$Bridgeless !== true &&
+      !global.RN$Express;
 
     const data = preprocessException({
       message,
@@ -112,28 +114,30 @@ function reportException(
       });
     }
 
-    NativeExceptionsManager.reportException(data);
+    if (isFatal || e.type !== 'warn') {
+      NativeExceptionsManager.reportException(data);
 
-    if (__DEV__ && !global.RN$Express) {
-      if (e.preventSymbolication === true) {
-        return;
+      if (__DEV__ && !global.RN$Express) {
+        if (e.preventSymbolication === true) {
+          return;
+        }
+        const symbolicateStackTrace = require('./Devtools/symbolicateStackTrace');
+        symbolicateStackTrace(stack)
+          .then(({stack: prettyStack}) => {
+            if (prettyStack) {
+              NativeExceptionsManager.updateExceptionMessage(
+                data.message,
+                prettyStack,
+                currentExceptionID,
+              );
+            } else {
+              throw new Error('The stack is null');
+            }
+          })
+          .catch(error => {
+            console.log('Unable to symbolicate stack trace: ' + error.message);
+          });
       }
-      const symbolicateStackTrace = require('./Devtools/symbolicateStackTrace');
-      symbolicateStackTrace(stack)
-        .then(({stack: prettyStack}) => {
-          if (prettyStack) {
-            NativeExceptionsManager.updateExceptionMessage(
-              data.message,
-              prettyStack,
-              currentExceptionID,
-            );
-          } else {
-            throw new Error('The stack is null');
-          }
-        })
-        .catch(error => {
-          console.log('Unable to symbolicate stack trace: ' + error.message);
-        });
     }
   } else if (reportToConsole) {
     // we feed back into console.error, to make sure any methods that are
@@ -169,15 +173,17 @@ function handleException(e: mixed, isFatal: boolean) {
   }
   try {
     inExceptionHandler = true;
+    /* $FlowFixMe[class-object-subtyping] added when improving typing for this
+     * parameters */
     reportException(error, isFatal, /*reportToConsole*/ true);
   } finally {
     inExceptionHandler = false;
   }
 }
 
-function reactConsoleErrorHandler() {
+function reactConsoleErrorHandler(...args) {
   // bubble up to any original handlers
-  console._errorOriginal.apply(console, arguments);
+  console._errorOriginal(...args);
   if (!console.reportErrorsAsExceptions) {
     return;
   }
@@ -213,31 +219,35 @@ function reactConsoleErrorHandler() {
     return;
   }
 
-  if (arguments[0] && arguments[0].stack) {
+  let error;
+
+  const firstArg = args[0];
+  if (firstArg?.stack) {
     // reportException will console.error this with high enough fidelity.
-    reportException(
-      arguments[0],
-      /* isFatal */ false,
-      /*reportToConsole*/ false,
-    );
+    error = firstArg;
   } else {
     const stringifySafe = require('../Utilities/stringifySafe').default;
-    const str = Array.prototype.map
-      .call(arguments, value =>
-        typeof value === 'string' ? value : stringifySafe(value),
-      )
-      .join(' ');
-
-    if (str.slice(0, 9) === 'Warning: ') {
+    if (typeof firstArg === 'string' && firstArg.startsWith('Warning: ')) {
       // React warnings use console.error so that a stack trace is shown, but
       // we don't (currently) want these to show a redbox
       // (Note: Logic duplicated in polyfills/console.js.)
       return;
     }
-    const error: ExtendedError = new SyntheticError(str);
+    const message = args
+      .map(arg => (typeof arg === 'string' ? arg : stringifySafe(arg)))
+      .join(' ');
+
+    error = new SyntheticError(message);
     error.name = 'console.error';
-    reportException(error, /* isFatal */ false, /*reportToConsole*/ false);
   }
+
+  reportException(
+    /* $FlowFixMe[class-object-subtyping] added when improving typing for this
+     * parameters */
+    error,
+    false, // isFatal
+    false, // reportToConsole
+  );
 }
 
 /**

package/Libraries/{Components/View/ViewInjection.js → Core/ExtendedError.js}

@@ -8,6 +8,12 @@
  * @format
  */
 
-export default {
-  unstable_enableCollapsable: false,
+export type ExtendedError = Error & {
+  jsEngine?: string,
+  preventSymbolication?: boolean,
+  componentStack?: string,
+  forceRedbox?: boolean,
+  isComponentError?: boolean,
+  type?: string,
+  ...
 };

package/Libraries/Core/ReactFiberErrorDialog.js

@@ -8,6 +8,10 @@
  * @flow strict-local
  */
 
+import {handleException, SyntheticError} from './ExceptionsManager';
+
+import type {ExtendedError} from './ExtendedError';
+
 export type CapturedError = {
   +componentStack: string,
   +error: mixed,
@@ -15,38 +19,44 @@ export type CapturedError = {
   ...
 };
 
-import type {ExtendedError} from './Devtools/parseErrorStack';
-
-import {handleException, SyntheticError} from './ExceptionsManager';
+const ReactFiberErrorDialog = {
+  /**
+   * Intercept lifecycle errors and ensure they are shown with the correct stack
+   * trace within the native redbox component.
+   */
+  showErrorDialog({componentStack, error: errorValue}: CapturedError): boolean {
+    let error: ?ExtendedError;
+
+    // Typically, `errorValue` should be an error. However, other values such as
+    // strings (or even null) are sometimes thrown.
+    if (errorValue instanceof Error) {
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
+      error = (errorValue: ExtendedError);
+    } else if (typeof errorValue === 'string') {
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
+      error = (new SyntheticError(errorValue): ExtendedError);
+    } else {
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
+      error = (new SyntheticError('Unspecified error'): ExtendedError);
+    }
+    try {
+      error.componentStack = componentStack;
+      error.isComponentError = true;
+    } catch {
+      // Ignored.
+    }
+
+    handleException(error, false);
+
+    // Return false here to prevent ReactFiberErrorLogger default behavior of
+    // logging error details to console.error. Calls to console.error are
+    // automatically routed to the native redbox controller, which we've already
+    // done above by calling ExceptionsManager.
+    return false;
+  },
+};
 
-/**
- * Intercept lifecycle errors and ensure they are shown with the correct stack
- * trace within the native redbox component.
- */
-function showErrorDialog(capturedError: CapturedError): boolean {
-  const {componentStack, error} = capturedError;
-
-  let errorToHandle;
-
-  // Typically Errors are thrown but eg strings or null can be thrown as well.
-  if (error instanceof Error) {
-    errorToHandle = (error: ExtendedError);
-  } else if (typeof error === 'string') {
-    errorToHandle = (new SyntheticError(error): ExtendedError);
-  } else {
-    errorToHandle = (new SyntheticError('Unspecified error'): ExtendedError);
-  }
-  try {
-    errorToHandle.componentStack = componentStack;
-    errorToHandle.isComponentError = true;
-  } catch (e) {}
-  handleException(errorToHandle, false);
-
-  // Return false here to prevent ReactFiberErrorLogger default behavior of
-  // logging error details to console.error. Calls to console.error are
-  // automatically routed to the native redbox controller, which we've already
-  // done above by calling ExceptionsManager.
-  return false;
-}
-
-module.exports = {showErrorDialog};
+export default ReactFiberErrorDialog;

package/Libraries/Core/ReactNativeVersion.js

@@ -13,5 +13,5 @@ exports.version = {
   major: 0,
   minor: 0,
   patch: 0,
-  prerelease: '263478b91',
+  prerelease: '268efb102',
 };

package/Libraries/Core/Timers/JSTimers.js

@@ -25,7 +25,7 @@ export type JSTimerType =
   | 'setTimeout'
   | 'setInterval'
   | 'requestAnimationFrame'
-  | 'setImmediate'
+  | 'queueReactNativeMicrotask'
   | 'requestIdleCallback';
 
 // These timing constants should be kept in sync with the ones in native ios and
@@ -37,7 +37,7 @@ const IDLE_CALLBACK_FRAME_DEADLINE = 1;
 const callbacks: Array<?Function> = [];
 const types: Array<?JSTimerType> = [];
 const timerIDs: Array<?number> = [];
-let immediates: Array<number> = [];
+let reactNativeMicrotasks: Array<number> = [];
 let requestIdleCallbacks: Array<number> = [];
 const requestIdleCallbackTimeouts: {[number]: number, ...} = {};
 
@@ -107,7 +107,7 @@ function _callTimer(timerID: number, frameTime: number, didTimeout: ?boolean) {
     if (
       type === 'setTimeout' ||
       type === 'setInterval' ||
-      type === 'setImmediate'
+      type === 'queueReactNativeMicrotask'
     ) {
       callback();
     } else if (type === 'requestAnimationFrame') {
@@ -143,33 +143,33 @@ function _callTimer(timerID: number, frameTime: number, didTimeout: ?boolean) {
 }
 
 /**
- * Performs a single pass over the enqueued immediates. Returns whether
- * more immediates are queued up (can be used as a condition a while loop).
+ * Performs a single pass over the enqueued reactNativeMicrotasks. Returns whether
+ * more reactNativeMicrotasks are queued up (can be used as a condition a while loop).
  */
-function _callImmediatesPass() {
-  if (immediates.length === 0) {
+function _callReactNativeMicrotasksPass() {
+  if (reactNativeMicrotasks.length === 0) {
     return false;
   }
 
   if (__DEV__) {
-    Systrace.beginEvent('callImmediatesPass()');
+    Systrace.beginEvent('callReactNativeMicrotasksPass()');
   }
 
   // The main reason to extract a single pass is so that we can track
   // in the system trace
-  const passImmediates = immediates;
-  immediates = [];
+  const passReactNativeMicrotasks = reactNativeMicrotasks;
+  reactNativeMicrotasks = [];
 
   // Use for loop rather than forEach as per @vjeux's advice
   // https://github.com/facebook/react-native/commit/c8fd9f7588ad02d2293cac7224715f4af7b0f352#commitcomment-14570051
-  for (let i = 0; i < passImmediates.length; ++i) {
-    _callTimer(passImmediates[i], 0);
+  for (let i = 0; i < passReactNativeMicrotasks.length; ++i) {
+    _callTimer(passReactNativeMicrotasks[i], 0);
   }
 
   if (__DEV__) {
     Systrace.endEvent();
   }
-  return immediates.length > 0;
+  return reactNativeMicrotasks.length > 0;
 }
 
 function _clearIndex(i: number) {
@@ -190,7 +190,10 @@ function _freeCallback(timerID: number) {
   if (index !== -1) {
     const type = types[index];
     _clearIndex(index);
-    if (type !== 'setImmediate' && type !== 'requestIdleCallback') {
+    if (
+      type !== 'queueReactNativeMicrotask' &&
+      type !== 'requestIdleCallback'
+    ) {
       deleteTimer(timerID);
     }
   }
@@ -233,15 +236,19 @@ const JSTimers = {
   },
 
   /**
+   * The React Native microtask mechanism is used to back public APIs e.g.
+   * `queueMicrotask`, `clearImmediate`, and `setImmediate` (which is used by
+   * the Promise polyfill) when the JSVM microtask mechanism is not used.
+   *
    * @param {function} func Callback to be invoked before the end of the
    * current JavaScript execution loop.
    */
-  setImmediate: function(func: Function, ...args: any) {
+  queueReactNativeMicrotask: function(func: Function, ...args: any) {
     const id = _allocateCallback(
       () => func.apply(undefined, args),
-      'setImmediate',
+      'queueReactNativeMicrotask',
     );
-    immediates.push(id);
+    reactNativeMicrotasks.push(id);
     return id;
   },
 
@@ -323,11 +330,11 @@ const JSTimers = {
     _freeCallback(timerID);
   },
 
-  clearImmediate: function(timerID: number) {
+  clearReactNativeMicrotask: function(timerID: number) {
     _freeCallback(timerID);
-    const index = immediates.indexOf(timerID);
+    const index = reactNativeMicrotasks.indexOf(timerID);
     if (index !== -1) {
-      immediates.splice(index, 1);
+      reactNativeMicrotasks.splice(index, 1);
     }
   },
 
@@ -406,9 +413,9 @@ const JSTimers = {
    * This is called after we execute any command we receive from native but
    * before we hand control back to native.
    */
-  callImmediates() {
+  callReactNativeMicrotasks() {
     errors = (null: ?Array<Error>);
-    while (_callImmediatesPass()) {}
+    while (_callReactNativeMicrotasksPass()) {}
     if (errors) {
       errors.forEach(error =>
         JSTimers.setTimeout(() => {
@@ -452,17 +459,17 @@ function setSendIdleEvents(sendIdleEvents: boolean): void {
 
 let ExportedJSTimers: {|
   callIdleCallbacks: (frameTime: number) => any | void,
-  callImmediates: () => void,
+  callReactNativeMicrotasks: () => void,
   callTimers: (timersToCall: Array<number>) => any | void,
   cancelAnimationFrame: (timerID: number) => void,
   cancelIdleCallback: (timerID: number) => void,
-  clearImmediate: (timerID: number) => void,
+  clearReactNativeMicrotask: (timerID: number) => void,
   clearInterval: (timerID: number) => void,
   clearTimeout: (timerID: number) => void,
   emitTimeDriftWarning: (warningMessage: string) => any | void,
   requestAnimationFrame: (func: any) => any | number,
   requestIdleCallback: (func: any, options: ?any) => any | number,
-  setImmediate: (func: any, ...args: any) => number,
+  queueReactNativeMicrotask: (func: any, ...args: any) => number,
   setInterval: (func: any, duration: number, ...args: any) => number,
   setTimeout: (func: any, duration: number, ...args: any) => number,
 |};
@@ -471,13 +478,15 @@ if (!NativeTiming) {
   console.warn("Timing native module is not available, can't set timers.");
   // $FlowFixMe[prop-missing] : we can assume timers are generally available
   ExportedJSTimers = ({
-    callImmediates: JSTimers.callImmediates,
-    setImmediate: JSTimers.setImmediate,
+    callReactNativeMicrotasks: JSTimers.callReactNativeMicrotasks,
+    queueReactNativeMicrotask: JSTimers.queueReactNativeMicrotask,
   }: typeof JSTimers);
 } else {
   ExportedJSTimers = JSTimers;
 }
 
-BatchedBridge.setImmediatesCallback(JSTimers.callImmediates);
+BatchedBridge.setReactNativeMicrotasksCallback(
+  JSTimers.callReactNativeMicrotasks,
+);
 
 module.exports = ExportedJSTimers;

package/Libraries/Core/Timers/immediateShim.js

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+// Globally Unique Immediate ID.
+let GUIID = 1;
+
+// A global set of the currently cleared immediates.
+const clearedImmediates: Set<number> = new Set();
+
+/**
+ * Shim the setImmediate API on top of queueMicrotask.
+ * @param {function} func Callback to be invoked before the end of the
+ * current JavaScript execution loop.
+ */
+function setImmediate(callback: Function, ...args: any): number {
+  if (arguments.length < 1) {
+    throw new TypeError(
+      'setImmediate must be called with at least one argument (a function to call)',
+    );
+  }
+  if (typeof callback !== 'function') {
+    throw new TypeError(
+      'The first argument to setImmediate must be a function.',
+    );
+  }
+
+  const id = GUIID++;
+  // This is an edgey case in which the sequentially assigned ID has been
+  // "guessed" and "cleared" ahead of time, so we need to clear it up first.
+  if (clearedImmediates.has(id)) {
+    clearedImmediates.delete(id);
+  }
+
+  global.queueMicrotask(() => {
+    if (!clearedImmediates.has(id)) {
+      callback.apply(undefined, args);
+    } else {
+      // Free up the Set entry.
+      clearedImmediates.delete(id);
+    }
+  });
+
+  return id;
+}
+
+/**
+ * @param {number} immediateID The ID of the immediate to be clearred.
+ */
+function clearImmediate(immediateID: number) {
+  clearedImmediates.add(immediateID);
+}
+
+const immediateShim = {
+  setImmediate: setImmediate,
+  clearImmediate: clearImmediate,
+};
+
+module.exports = immediateShim;

package/Libraries/Core/Timers/queueMicrotask.js

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+let resolvedPromise;
+
+/**
+ * Polyfill for the microtask queuening API defined by WHATWG HTMP spec.
+ * https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-queuemicrotask
+ *
+ * The method must queue a microtask to invoke @param {function} callback, and
+ * if the callback throws an exception, report the exception.
+ */
+export default function queueMicrotask(callback: Function) {
+  if (arguments.length < 1) {
+    throw new TypeError(
+      'queueMicrotask must be called with at least one argument (a function to call)',
+    );
+  }
+  if (typeof callback !== 'function') {
+    throw new TypeError('The argument to queueMicrotask must be a function.');
+  }
+
+  // Try to reuse a lazily allocated resolved promise from closure.
+  (resolvedPromise || (resolvedPromise = Promise.resolve()))
+    .then(callback)
+    .catch(error =>
+      // Report the exception until the next tick.
+      setTimeout(() => {
+        throw error;
+      }, 0),
+    );
+}

package/Libraries/Core/polyfillPromise.js

@@ -29,7 +29,7 @@ if (global?.HermesInternal?.hasPromise?.()) {
     if (typeof HermesPromise !== 'function') {
       console.error('HermesPromise does not exist');
     }
-    global.HermesInternal.enablePromiseRejectionTracker(
+    global.HermesInternal?.enablePromiseRejectionTracker?.(
       require('../promiseRejectionTrackingOptions').default,
     );
   }

package/Libraries/Core/setUpBatchedBridge.js

@@ -11,7 +11,7 @@
 'use strict';
 
 let registerModule;
-if (global.RN$Bridgeless && global.RN$registerCallableModule) {
+if (global.RN$Bridgeless === true && global.RN$registerCallableModule) {
   registerModule = global.RN$registerCallableModule;
 } else {
   const BatchedBridge = require('../BatchedBridge/BatchedBridge');

package/Libraries/Core/setUpGlobals.js

@@ -19,10 +19,12 @@ if (global.GLOBAL === undefined) {
 }
 
 if (global.window === undefined) {
+  // $FlowFixMe[cannot-write]
   global.window = global;
 }
 
 if (global.self === undefined) {
+  // $FlowFixMe[cannot-write]
   global.self = global;
 }
 

package/Libraries/Core/setUpRegeneratorRuntime.js

@@ -11,17 +11,34 @@
 'use strict';
 
 const {polyfillGlobal} = require('../Utilities/PolyfillFunctions');
+const {hasNativeConstructor} = require('../Utilities/FeatureDetection');
 
 /**
  * Set up regenerator.
  * You can use this module directly, or just require InitializeCore.
  */
-polyfillGlobal('regeneratorRuntime', () => {
-  // The require just sets up the global, so make sure when we first
-  // invoke it the global does not exist
-  delete global.regeneratorRuntime;
 
-  // regenerator-runtime/runtime exports the regeneratorRuntime object, so we
-  // can return it safely.
-  return require('regenerator-runtime/runtime'); // flowlint-line untyped-import:off
-});
+let hasNativeGenerator;
+try {
+  // If this function was lowered by regenerator-transform, it will try to
+  // access `global.regeneratorRuntime` which doesn't exist yet and will throw.
+  hasNativeGenerator = hasNativeConstructor(function*() {},
+  'GeneratorFunction');
+} catch {
+  // In this case, we know generators are not provided natively.
+  hasNativeGenerator = false;
+}
+
+// If generators are provided natively, which suggests that there was no
+// regenerator-transform, then there is no need to set up the runtime.
+if (!hasNativeGenerator) {
+  polyfillGlobal('regeneratorRuntime', () => {
+    // The require just sets up the global, so make sure when we first
+    // invoke it the global does not exist
+    delete global.regeneratorRuntime;
+
+    // regenerator-runtime/runtime exports the regeneratorRuntime object, so we
+    // can return it safely.
+    return require('regenerator-runtime/runtime'); // flowlint-line untyped-import:off
+  });
+}