react 15.0.0 → 15.0.2-alpha.3

package/lib/ReactNativeBaseComponent.js

@@ -0,0 +1,196 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ReactNativeBaseComponent
+ * 
+ */
+'use strict';
+
+var _assign = require('object-assign');
+
+var NativeMethodsMixin = require('./NativeMethodsMixin');
+var ReactNativeAttributePayload = require('./ReactNativeAttributePayload');
+var ReactNativeComponentTree = require('./ReactNativeComponentTree');
+var ReactNativeEventEmitter = require('./ReactNativeEventEmitter');
+var ReactNativeTagHandles = require('./ReactNativeTagHandles');
+var ReactMultiChild = require('./ReactMultiChild');
+var UIManager = require('UIManager');
+
+var deepFreezeAndThrowOnMutationInDev = require('deepFreezeAndThrowOnMutationInDev');
+
+var registrationNames = ReactNativeEventEmitter.registrationNames;
+var putListener = ReactNativeEventEmitter.putListener;
+var deleteListener = ReactNativeEventEmitter.deleteListener;
+var deleteAllListeners = ReactNativeEventEmitter.deleteAllListeners;
+
+// require('UIManagerStatTracker').install(); // uncomment to enable
+
+/**
+ * @constructor ReactNativeBaseComponent
+ * @extends ReactComponent
+ * @extends ReactMultiChild
+ * @param {!object} UIKit View Configuration.
+ */
+var ReactNativeBaseComponent = function (viewConfig) {
+  this.viewConfig = viewConfig;
+};
+
+/**
+ * Mixin for containers that contain UIViews. NOTE: markup is rendered markup
+ * which is a `viewID` ... see the return value for `mountComponent` !
+ */
+ReactNativeBaseComponent.Mixin = {
+  getPublicInstance: function () {
+    // TODO: This should probably use a composite wrapper
+    return this;
+  },
+
+  unmountComponent: function () {
+    ReactNativeComponentTree.uncacheNode(this);
+    deleteAllListeners(this);
+    this.unmountChildren();
+    this._rootNodeID = null;
+  },
+
+  /**
+   * Every native component is responsible for allocating its own `tag`, and
+   * issuing the native `createView` command. But it is not responsible for
+   * recording the fact that its own `rootNodeID` is associated with a
+   * `nodeHandle`. Only the code that actually adds its `nodeHandle` (`tag`) as
+   * a child of a container can confidently record that in
+   * `ReactNativeTagHandles`.
+   */
+  initializeChildren: function (children, containerTag, transaction, context) {
+    var mountImages = this.mountChildren(children, transaction, context);
+    // In a well balanced tree, half of the nodes are in the bottom row and have
+    // no children - let's avoid calling out to the native bridge for a large
+    // portion of the children.
+    if (mountImages.length) {
+
+      // TODO: Pool these per platform view class. Reusing the `mountImages`
+      // array would likely be a jit deopt.
+      var createdTags = [];
+      for (var i = 0, l = mountImages.length; i < l; i++) {
+        var mountImage = mountImages[i];
+        var childTag = mountImage;
+        createdTags[i] = childTag;
+      }
+      UIManager.setChildren(containerTag, createdTags);
+    }
+  },
+
+  /**
+   * Updates the component's currently mounted representation.
+   *
+   * @param {object} nextElement
+   * @param {ReactReconcileTransaction} transaction
+   * @param {object} context
+   * @internal
+   */
+  receiveComponent: function (nextElement, transaction, context) {
+    var prevElement = this._currentElement;
+    this._currentElement = nextElement;
+
+    if (process.env.NODE_ENV !== 'production') {
+      for (var key in this.viewConfig.validAttributes) {
+        if (nextElement.props.hasOwnProperty(key)) {
+          deepFreezeAndThrowOnMutationInDev(nextElement.props[key]);
+        }
+      }
+    }
+
+    var updatePayload = ReactNativeAttributePayload.diff(prevElement.props, nextElement.props, this.viewConfig.validAttributes);
+
+    if (updatePayload) {
+      UIManager.updateView(this._rootNodeID, this.viewConfig.uiViewClassName, updatePayload);
+    }
+
+    this._reconcileListenersUponUpdate(prevElement.props, nextElement.props);
+    this.updateChildren(nextElement.props.children, transaction, context);
+  },
+
+  /**
+   * @param {object} initialProps Native component props.
+   */
+  _registerListenersUponCreation: function (initialProps) {
+    for (var key in initialProps) {
+      // NOTE: The check for `!props[key]`, is only possible because this method
+      // registers listeners the *first* time a component is created.
+      if (registrationNames[key] && initialProps[key]) {
+        var listener = initialProps[key];
+        putListener(this, key, listener);
+      }
+    }
+  },
+
+  /**
+   * Reconciles event listeners, adding or removing if necessary.
+   * @param {object} prevProps Native component props including events.
+   * @param {object} nextProps Next native component props including events.
+   */
+  _reconcileListenersUponUpdate: function (prevProps, nextProps) {
+    for (var key in nextProps) {
+      if (registrationNames[key] && nextProps[key] !== prevProps[key]) {
+        if (nextProps[key]) {
+          putListener(this, key, nextProps[key]);
+        } else {
+          deleteListener(this, key);
+        }
+      }
+    }
+  },
+
+  /**
+   * Currently this still uses IDs for reconciliation so this can return null.
+   *
+   * @return {null} Null.
+   */
+  getNativeNode: function () {
+    return this._rootNodeID;
+  },
+
+  /**
+   * @param {string} rootID Root ID of this subtree.
+   * @param {Transaction} transaction For creating/updating.
+   * @return {string} Unique iOS view tag.
+   */
+  mountComponent: function (transaction, nativeParent, nativeContainerInfo, context) {
+    var tag = ReactNativeTagHandles.allocateTag();
+
+    this._rootNodeID = tag;
+    this._nativeParent = nativeParent;
+    this._nativeContainerInfo = nativeContainerInfo;
+
+    if (process.env.NODE_ENV !== 'production') {
+      for (var key in this.viewConfig.validAttributes) {
+        if (this._currentElement.props.hasOwnProperty(key)) {
+          deepFreezeAndThrowOnMutationInDev(this._currentElement.props[key]);
+        }
+      }
+    }
+
+    var updatePayload = ReactNativeAttributePayload.create(this._currentElement.props, this.viewConfig.validAttributes);
+
+    var nativeTopRootTag = nativeContainerInfo._tag;
+    UIManager.createView(tag, this.viewConfig.uiViewClassName, nativeTopRootTag, updatePayload);
+
+    ReactNativeComponentTree.precacheNode(this, tag);
+
+    this._registerListenersUponCreation(this._currentElement.props);
+    this.initializeChildren(this._currentElement.props.children, tag, transaction, context);
+    return tag;
+  }
+};
+
+/**
+ * Order of mixins is important. ReactNativeBaseComponent overrides methods in
+ * ReactMultiChild.
+ */
+_assign(ReactNativeBaseComponent.prototype, ReactMultiChild.Mixin, ReactNativeBaseComponent.Mixin, NativeMethodsMixin);
+
+module.exports = ReactNativeBaseComponent;

package/lib/ReactNativeComponentEnvironment.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ReactNativeComponentEnvironment
+ * 
+ */
+'use strict';
+
+var ReactNativeDOMIDOperations = require('./ReactNativeDOMIDOperations');
+var ReactNativeReconcileTransaction = require('./ReactNativeReconcileTransaction');
+
+var ReactNativeComponentEnvironment = {
+
+  processChildrenUpdates: ReactNativeDOMIDOperations.dangerouslyProcessChildrenUpdates,
+
+  replaceNodeWithMarkup: ReactNativeDOMIDOperations.dangerouslyReplaceNodeWithMarkupByID,
+
+  /**
+   * Nothing to do for UIKit bridge.
+   *
+   * @private
+   */
+  unmountIDFromEnvironment: function () /*rootNodeID*/{},
+
+  /**
+   * @param {DOMElement} Element to clear.
+   */
+  clearNode: function () /*containerView*/{},
+
+  ReactReconcileTransaction: ReactNativeReconcileTransaction
+};
+
+module.exports = ReactNativeComponentEnvironment;

package/lib/ReactNativeComponentTree.js

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ReactNativeComponentTree
+ */
+
+'use strict';
+
+var invariant = require('fbjs/lib/invariant');
+
+var instanceCache = {};
+
+/**
+ * Drill down (through composites and empty components) until we get a native or
+ * native text component.
+ *
+ * This is pretty polymorphic but unavoidable with the current structure we have
+ * for `_renderedChildren`.
+ */
+function getRenderedNativeOrTextFromComponent(component) {
+  var rendered;
+  while (rendered = component._renderedComponent) {
+    component = rendered;
+  }
+  return component;
+}
+
+/**
+ * Populate `_nativeNode` on the rendered native/text component with the given
+ * DOM node. The passed `inst` can be a composite.
+ */
+function precacheNode(inst, tag) {
+  var nativeInst = getRenderedNativeOrTextFromComponent(inst);
+  instanceCache[tag] = nativeInst;
+}
+
+function uncacheNode(inst) {
+  var tag = inst._rootNodeID;
+  if (tag) {
+    delete instanceCache[tag];
+  }
+}
+
+function getInstanceFromTag(tag) {
+  return instanceCache[tag] || null;
+}
+
+function getTagFromInstance(inst) {
+  !inst._rootNodeID ? process.env.NODE_ENV !== 'production' ? invariant(false, 'All native instances should have a tag.') : invariant(false) : void 0;
+  return inst._rootNodeID;
+}
+
+var ReactNativeComponentTree = {
+  getClosestInstanceFromNode: getInstanceFromTag,
+  getInstanceFromNode: getInstanceFromTag,
+  getNodeFromInstance: getTagFromInstance,
+  precacheNode: precacheNode,
+  uncacheNode: uncacheNode
+};
+
+module.exports = ReactNativeComponentTree;

package/lib/ReactNativeContainerInfo.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ReactNativeContainerInfo
+ * 
+ */
+'use strict';
+
+function ReactNativeContainerInfo(tag) {
+  var info = {
+    _tag: tag
+  };
+  return info;
+}
+
+module.exports = ReactNativeContainerInfo;

package/lib/ReactNativeDOMIDOperations.js

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ReactNativeDOMIDOperations
+ * 
+ */
+'use strict';
+
+var ReactNativeComponentTree = require('./ReactNativeComponentTree');
+var ReactMultiChildUpdateTypes = require('./ReactMultiChildUpdateTypes');
+var ReactPerf = require('./ReactPerf');
+var UIManager = require('UIManager');
+
+/**
+ * Updates a component's children by processing a series of updates.
+ * For each of the update/create commands, the `fromIndex` refers to the index
+ * that the item existed at *before* any of the updates are applied, and the
+ * `toIndex` refers to the index after *all* of the updates are applied
+ * (including deletes/moves). TODO: refactor so this can be shared with
+ * DOMChildrenOperations.
+ *
+ * @param {ReactNativeBaseComponent} updates List of update configurations.
+ * @param {array<string>} markup List of markup strings - in the case of React
+ * IOS, the ids of new components assumed to be already created.
+ */
+var dangerouslyProcessChildrenUpdates = function (inst, childrenUpdates) {
+  if (!childrenUpdates.length) {
+    return;
+  }
+
+  var containerTag = ReactNativeComponentTree.getNodeFromInstance(inst);
+
+  var moveFromIndices;
+  var moveToIndices;
+  var addChildTags;
+  var addAtIndices;
+  var removeAtIndices;
+
+  for (var i = 0; i < childrenUpdates.length; i++) {
+    var update = childrenUpdates[i];
+    if (update.type === ReactMultiChildUpdateTypes.MOVE_EXISTING) {
+      (moveFromIndices || (moveFromIndices = [])).push(update.fromIndex);
+      (moveToIndices || (moveToIndices = [])).push(update.toIndex);
+    } else if (update.type === ReactMultiChildUpdateTypes.REMOVE_NODE) {
+      (removeAtIndices || (removeAtIndices = [])).push(update.fromIndex);
+    } else if (update.type === ReactMultiChildUpdateTypes.INSERT_MARKUP) {
+      var mountImage = update.content;
+      var tag = mountImage;
+      (addAtIndices || (addAtIndices = [])).push(update.toIndex);
+      (addChildTags || (addChildTags = [])).push(tag);
+    }
+  }
+
+  UIManager.manageChildren(containerTag, moveFromIndices, moveToIndices, addChildTags, addAtIndices, removeAtIndices);
+};
+
+/**
+ * Operations used to process updates to DOM nodes. This is made injectable via
+ * `ReactComponent.DOMIDOperations`.
+ */
+var ReactNativeDOMIDOperations = {
+  dangerouslyProcessChildrenUpdates: ReactPerf.measure(
+  // FIXME(frantic): #4441289 Hack to avoid modifying react-tools
+  'ReactDOMIDOperations', 'dangerouslyProcessChildrenUpdates', dangerouslyProcessChildrenUpdates),
+
+  /**
+   * Replaces a view that exists in the document with markup.
+   *
+   * @param {string} id ID of child to be replaced.
+   * @param {string} markup Mount image to replace child with id.
+   */
+  dangerouslyReplaceNodeWithMarkupByID: ReactPerf.measure('ReactDOMIDOperations', 'dangerouslyReplaceNodeWithMarkupByID', function (id, mountImage) {
+    var oldTag = id;
+    UIManager.replaceExistingNonRootView(oldTag, mountImage);
+  })
+};
+
+module.exports = ReactNativeDOMIDOperations;

package/lib/ReactNativeDefaultInjection.js

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ReactNativeDefaultInjection
+ * 
+ */
+'use strict';
+
+/**
+ * Make sure essential globals are available and are patched correctly. Please don't remove this
+ * line. Bundles created by react-packager `require` it before executing any application code. This
+ * ensures it exists in the dependency graph and can be `require`d.
+ */
+
+require('InitializeJavaScriptAppEngine');
+
+var EventPluginHub = require('./EventPluginHub');
+var EventPluginUtils = require('./EventPluginUtils');
+var IOSDefaultEventPluginOrder = require('./IOSDefaultEventPluginOrder');
+var IOSNativeBridgeEventPlugin = require('./IOSNativeBridgeEventPlugin');
+var ReactElement = require('./ReactElement');
+var ReactComponentEnvironment = require('./ReactComponentEnvironment');
+var ReactDefaultBatchingStrategy = require('./ReactDefaultBatchingStrategy');
+var ReactEmptyComponent = require('./ReactEmptyComponent');
+var ReactNativeComponentEnvironment = require('./ReactNativeComponentEnvironment');
+var ReactNativeGlobalResponderHandler = require('./ReactNativeGlobalResponderHandler');
+var ReactNativeTextComponent = require('./ReactNativeTextComponent');
+var ReactNativeTreeTraversal = require('./ReactNativeTreeTraversal');
+var ReactNativeComponent = require('./ReactNativeComponent');
+var ReactNativeComponentTree = require('./ReactNativeComponentTree');
+var ReactSimpleEmptyComponent = require('./ReactSimpleEmptyComponent');
+var ReactUpdates = require('./ReactUpdates');
+var ResponderEventPlugin = require('./ResponderEventPlugin');
+
+var invariant = require('fbjs/lib/invariant');
+
+// Just to ensure this gets packaged, since its only caller is from Native.
+require('RCTEventEmitter');
+require('RCTLog');
+require('JSTimersExecution');
+
+function inject() {
+  /**
+   * Inject module for resolving DOM hierarchy and plugin ordering.
+   */
+  EventPluginHub.injection.injectEventPluginOrder(IOSDefaultEventPluginOrder);
+  EventPluginUtils.injection.injectComponentTree(ReactNativeComponentTree);
+  EventPluginUtils.injection.injectTreeTraversal(ReactNativeTreeTraversal);
+
+  ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler);
+
+  /**
+   * Some important event plugins included by default (without having to require
+   * them).
+   */
+  EventPluginHub.injection.injectEventPluginsByName({
+    'ResponderEventPlugin': ResponderEventPlugin,
+    'IOSNativeBridgeEventPlugin': IOSNativeBridgeEventPlugin
+  });
+
+  ReactUpdates.injection.injectReconcileTransaction(ReactNativeComponentEnvironment.ReactReconcileTransaction);
+
+  ReactUpdates.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy);
+
+  ReactComponentEnvironment.injection.injectEnvironment(ReactNativeComponentEnvironment);
+
+  var EmptyComponent = function (instantiate) {
+    // Can't import View at the top because it depends on React to make its composite
+    var View = require('View');
+    return new ReactSimpleEmptyComponent(ReactElement.createElement(View, {
+      collapsable: true,
+      style: { position: 'absolute' }
+    }), instantiate);
+  };
+
+  ReactEmptyComponent.injection.injectEmptyComponentFactory(EmptyComponent);
+
+  ReactNativeComponent.injection.injectTextComponentClass(ReactNativeTextComponent);
+  ReactNativeComponent.injection.injectGenericComponentClass(function (tag) {
+    // Show a nicer error message for non-function tags
+    var info = '';
+    if (typeof tag === 'string' && /^[a-z]/.test(tag)) {
+      info += ' Each component name should start with an uppercase letter.';
+    }
+    !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected a component class, got %s.%s', tag, info) : invariant(false) : void 0;
+  });
+}
+
+module.exports = {
+  inject: inject
+};