initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/StyleSheet/ColorPropType.js

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ColorPropType
+ */
+'use strict';
+
+var normalizeColor = require('normalizeColor');
+
+var colorPropType = function(isRequired, props, propName, componentName, location, propFullName) {
+  var color = props[propName];
+  if (color === undefined || color === null) {
+    if (isRequired) {
+      return new Error(
+        'Required ' + location + ' `' + (propFullName || propName) +
+        '` was not specified in `' + componentName + '`.'
+      );
+    }
+    return;
+  }
+
+  if (typeof color === 'number') {
+    // Developers should not use a number, but we are using the prop type
+    // both for user provided colors and for transformed ones. This isn't ideal
+    // and should be fixed but will do for now...
+    return;
+  }
+
+  if (normalizeColor(color) === null) {
+    return new Error(
+      'Invalid ' + location + ' `' + (propFullName || propName) +
+      '` supplied to `' + componentName + '`: ' + color + '\n' +
+`Valid color formats are
+  - '#f0f' (#rgb)
+  - '#f0fc' (#rgba)
+  - '#ff00ff' (#rrggbb)
+  - '#ff00ff00' (#rrggbbaa)
+  - 'rgb(255, 255, 255)'
+  - 'rgba(255, 255, 255, 1.0)'
+  - 'hsl(360, 100%, 100%)'
+  - 'hsla(360, 100%, 100%, 1.0)'
+  - 'transparent'
+  - 'red'
+  - 0xff00ff00 (0xrrggbbaa)
+`);
+  }
+};
+
+var ColorPropType = colorPropType.bind(null, false /* isRequired */);
+ColorPropType.isRequired = colorPropType.bind(null, true /* isRequired */);
+
+module.exports = ColorPropType;

node_modules/react-native/Libraries/StyleSheet/EdgeInsetsPropType.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule EdgeInsetsPropType
+ * @flow
+ */
+'use strict';
+
+const PropTypes = require('prop-types');
+
+const createStrictShapeTypeChecker = require('createStrictShapeTypeChecker');
+
+const EdgeInsetsPropType = (createStrictShapeTypeChecker({
+  top: PropTypes.number,
+  left: PropTypes.number,
+  bottom: PropTypes.number,
+  right: PropTypes.number,
+}): ReactPropsCheckType & ReactPropsChainableTypeChecker);
+
+export type EdgeInsetsProp = {|
+  +top: number,
+  +left: number,
+  +bottom: number,
+  +right: number,
+|};
+
+module.exports = EdgeInsetsPropType;

node_modules/react-native/Libraries/StyleSheet/LayoutPropTypes.js

@@ -0,0 +1,583 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule LayoutPropTypes
+ * @flow
+ */
+'use strict';
+
+var ReactPropTypes = require('prop-types');
+
+/**
+ * React Native's layout system is based on Flexbox and is powered both
+ * on iOS and Android by an open source project called `Yoga`:
+ * https://github.com/facebook/yoga
+ *
+ * The implementation in Yoga is slightly different from what the
+ * Flexbox spec defines - for example, we chose more sensible default
+ * values. Since our layout docs are generated from the comments in this
+ * file, please keep a brief comment describing each prop type.
+ *
+ * These properties are a subset of our styles that are consumed by the layout
+ * algorithm and affect the positioning and sizing of views.
+ */
+var LayoutPropTypes = {
+  /** `display` sets the display type of this component.
+   *
+   *  It works similarly to `display` in CSS, but only support 'flex' and 'none'.
+   *  'flex' is the default.
+   */
+  display: ReactPropTypes.oneOf([
+    'none',
+    'flex',
+  ]),
+
+  /** `width` sets the width of this component.
+   *
+   *  It works similarly to `width` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/width for more details.
+   */
+  width: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `height` sets the height of this component.
+   *
+   *  It works similarly to `height` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/height for more details.
+   */
+  height: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /**
+   * When the direction is `ltr`, `start` is equivalent to `left`.
+   * When the direction is `rtl`, `start` is equivalent to `right`.
+   *
+   * This style takes precedence over the `left`, `right`, and `end` styles.
+   */
+  start: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /**
+   * When the direction is `ltr`, `end` is equivalent to `right`.
+   * When the direction is `rtl`, `end` is equivalent to `left`.
+   *
+   * This style takes precedence over the `left` and `right` styles.
+   */
+  end: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `top` is the number of logical pixels to offset the top edge of
+   *  this component.
+   *
+   *  It works similarly to `top` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/top
+   *  for more details of how `top` affects layout.
+   */
+  top: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `left` is the number of logical pixels to offset the left edge of
+   *  this component.
+   *
+   *  It works similarly to `left` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/left
+   *  for more details of how `left` affects layout.
+   */
+  left: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `right` is the number of logical pixels to offset the right edge of
+   *  this component.
+   *
+   *  It works similarly to `right` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/right
+   *  for more details of how `right` affects layout.
+   */
+  right: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `bottom` is the number of logical pixels to offset the bottom edge of
+   *  this component.
+   *
+   *  It works similarly to `bottom` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/bottom
+   *  for more details of how `bottom` affects layout.
+   */
+  bottom: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `minWidth` is the minimum width for this component, in logical pixels.
+   *
+   *  It works similarly to `min-width` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/min-width
+   *  for more details.
+   */
+  minWidth: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `maxWidth` is the maximum width for this component, in logical pixels.
+   *
+   *  It works similarly to `max-width` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/max-width
+   *  for more details.
+   */
+  maxWidth: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `minHeight` is the minimum height for this component, in logical pixels.
+   *
+   *  It works similarly to `min-height` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/min-height
+   *  for more details.
+   */
+  minHeight: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `maxHeight` is the maximum height for this component, in logical pixels.
+   *
+   *  It works similarly to `max-height` in CSS, but in React Native you
+   *  must use points or percentages. Ems and other units are not supported.
+   *
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/max-height
+   *  for more details.
+   */
+  maxHeight: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** Setting `margin` has the same effect as setting each of
+   *  `marginTop`, `marginLeft`, `marginBottom`, and `marginRight`.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/margin
+   *  for more details.
+   */
+  margin: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** Setting `marginVertical` has the same effect as setting both
+   *  `marginTop` and `marginBottom`.
+   */
+  marginVertical: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** Setting `marginHorizontal` has the same effect as setting
+   *  both `marginLeft` and `marginRight`.
+   */
+  marginHorizontal: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `marginTop` works like `margin-top` in CSS.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/margin-top
+   *  for more details.
+   */
+  marginTop: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `marginBottom` works like `margin-bottom` in CSS.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/margin-bottom
+   *  for more details.
+   */
+  marginBottom: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `marginLeft` works like `margin-left` in CSS.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/margin-left
+   *  for more details.
+   */
+  marginLeft: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `marginRight` works like `margin-right` in CSS.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/margin-right
+   *  for more details.
+   */
+  marginRight: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /**
+   * When direction is `ltr`, `marginStart` is equivalent to `marginLeft`.
+   * When direction is `rtl`, `marginStart` is equivalent to `marginRight`.
+   */
+  marginStart: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /**
+   * When direction is `ltr`, `marginEnd` is equivalent to `marginRight`.
+   * When direction is `rtl`, `marginEnd` is equivalent to `marginLeft`.
+   */
+  marginEnd: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** Setting `padding` has the same effect as setting each of
+   *  `paddingTop`, `paddingBottom`, `paddingLeft`, and `paddingRight`.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/padding
+   *  for more details.
+   */
+  padding: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** Setting `paddingVertical` is like setting both of
+   *  `paddingTop` and `paddingBottom`.
+   */
+  paddingVertical: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** Setting `paddingHorizontal` is like setting both of
+   *  `paddingLeft` and `paddingRight`.
+   */
+  paddingHorizontal: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `paddingTop` works like `padding-top` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/padding-top
+   * for more details.
+   */
+  paddingTop: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `paddingBottom` works like `padding-bottom` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/padding-bottom
+   * for more details.
+   */
+  paddingBottom: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `paddingLeft` works like `padding-left` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/padding-left
+   * for more details.
+   */
+  paddingLeft: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `paddingRight` works like `padding-right` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/padding-right
+   * for more details.
+   */
+  paddingRight: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /**
+   * When direction is `ltr`, `paddingStart` is equivalent to `paddingLeft`.
+   * When direction is `rtl`, `paddingStart` is equivalent to `paddingRight`.
+   */
+  paddingStart: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /**
+   * When direction is `ltr`, `paddingEnd` is equivalent to `paddingRight`.
+   * When direction is `rtl`, `paddingEnd` is equivalent to `paddingLeft`.
+   */
+  paddingEnd: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /** `borderWidth` works like `border-width` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/border-width
+   * for more details.
+   */
+  borderWidth: ReactPropTypes.number,
+
+  /** `borderTopWidth` works like `border-top-width` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-width
+   * for more details.
+   */
+  borderTopWidth: ReactPropTypes.number,
+
+  /**
+   * When direction is `ltr`, `borderStartWidth` is equivalent to `borderLeftWidth`.
+   * When direction is `rtl`, `borderStartWidth` is equivalent to `borderRightWidth`.
+   */
+  borderStartWidth: ReactPropTypes.number,
+
+  /**
+   * When direction is `ltr`, `borderEndWidth` is equivalent to `borderRightWidth`.
+   * When direction is `rtl`, `borderEndWidth` is equivalent to `borderLeftWidth`.
+   */
+  borderEndWidth: ReactPropTypes.number,
+
+  /** `borderRightWidth` works like `border-right-width` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/border-right-width
+   * for more details.
+   */
+  borderRightWidth: ReactPropTypes.number,
+
+  /** `borderBottomWidth` works like `border-bottom-width` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-width
+   * for more details.
+   */
+  borderBottomWidth: ReactPropTypes.number,
+
+  /** `borderLeftWidth` works like `border-left-width` in CSS.
+   * See https://developer.mozilla.org/en-US/docs/Web/CSS/border-left-width
+   * for more details.
+   */
+  borderLeftWidth: ReactPropTypes.number,
+
+  /** `position` in React Native is similar to regular CSS, but
+   *  everything is set to `relative` by default, so `absolute`
+   *  positioning is always just relative to the parent.
+   *
+   *  If you want to position a child using specific numbers of logical
+   *  pixels relative to its parent, set the child to have `absolute`
+   *  position.
+   *
+   *  If you want to position a child relative to something
+   *  that is not its parent, just don't use styles for that. Use the
+   *  component tree.
+   *
+   *  See https://github.com/facebook/yoga
+   *  for more details on how `position` differs between React Native
+   *  and CSS.
+   */
+  position: ReactPropTypes.oneOf([
+    'absolute',
+    'relative'
+  ]),
+
+  /** `flexDirection` controls which directions children of a container go.
+   *  `row` goes left to right, `column` goes top to bottom, and you may
+   *  be able to guess what the other two do. It works like `flex-direction`
+   *  in CSS, except the default is `column`.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/flex-direction
+   *  for more details.
+   */
+  flexDirection: ReactPropTypes.oneOf([
+    'row',
+    'row-reverse',
+    'column',
+    'column-reverse'
+  ]),
+
+  /** `flexWrap` controls whether children can wrap around after they
+   *  hit the end of a flex container.
+   *  It works like `flex-wrap` in CSS (default: nowrap).
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/flex-wrap
+   *  for more details.
+   */
+  flexWrap: ReactPropTypes.oneOf([
+    'wrap',
+    'nowrap'
+  ]),
+
+  /** `justifyContent` aligns children in the main direction.
+   *  For example, if children are flowing vertically, `justifyContent`
+   *  controls how they align vertically.
+   *  It works like `justify-content` in CSS (default: flex-start).
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/justify-content
+   *  for more details.
+   */
+  justifyContent: ReactPropTypes.oneOf([
+    'flex-start',
+    'flex-end',
+    'center',
+    'space-between',
+    'space-around',
+    'space-evenly'
+  ]),
+
+  /** `alignItems` aligns children in the cross direction.
+   *  For example, if children are flowing vertically, `alignItems`
+   *  controls how they align horizontally.
+   *  It works like `align-items` in CSS (default: stretch).
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/align-items
+   *  for more details.
+   */
+  alignItems: ReactPropTypes.oneOf([
+    'flex-start',
+    'flex-end',
+    'center',
+    'stretch',
+    'baseline'
+  ]),
+
+  /** `alignSelf` controls how a child aligns in the cross direction,
+   *  overriding the `alignItems` of the parent. It works like `align-self`
+   *  in CSS (default: auto).
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/align-self
+   *  for more details.
+   */
+  alignSelf: ReactPropTypes.oneOf([
+    'auto',
+    'flex-start',
+    'flex-end',
+    'center',
+    'stretch',
+    'baseline'
+  ]),
+
+  /** `alignContent` controls how rows align in the cross direction,
+   *  overriding the `alignContent` of the parent.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/align-content
+   *  for more details.
+   */
+  alignContent: ReactPropTypes.oneOf([
+    'flex-start',
+    'flex-end',
+    'center',
+    'stretch',
+    'space-between',
+    'space-around'
+  ]),
+
+  /** `overflow` controls how children are measured and displayed.
+   *  `overflow: hidden` causes views to be clipped while `overflow: scroll`
+   *  causes views to be measured independently of their parents main axis.
+   *  It works like `overflow` in CSS (default: visible).
+   *  See https://developer.mozilla.org/en/docs/Web/CSS/overflow
+   *  for more details.
+   *  `overflow: visible` only works on iOS. On Android, all views will clip
+   *  their children.
+   */
+  overflow: ReactPropTypes.oneOf([
+    'visible',
+    'hidden',
+    'scroll',
+  ]),
+
+  /** In React Native `flex` does not work the same way that it does in CSS.
+   *  `flex` is a number rather than a string, and it works
+   *  according to the `Yoga` library
+   *  at https://github.com/facebook/yoga
+   *
+   *  When `flex` is a positive number, it makes the component flexible
+   *  and it will be sized proportional to its flex value. So a
+   *  component with `flex` set to 2 will take twice the space as a
+   *  component with `flex` set to 1.
+   *
+   *  When `flex` is 0, the component is sized according to `width`
+   *  and `height` and it is inflexible.
+   *
+   *  When `flex` is -1, the component is normally sized according
+   *  `width` and `height`. However, if there's not enough space,
+   *  the component will shrink to its `minWidth` and `minHeight`.
+   *
+   * flexGrow, flexShrink, and flexBasis work the same as in CSS.
+   */
+  flex: ReactPropTypes.number,
+  flexGrow: ReactPropTypes.number,
+  flexShrink: ReactPropTypes.number,
+  flexBasis: ReactPropTypes.oneOfType([
+    ReactPropTypes.number,
+    ReactPropTypes.string,
+  ]),
+
+  /**
+   * Aspect ratio control the size of the undefined dimension of a node. Aspect ratio is a
+   * non-standard property only available in react native and not CSS.
+   *
+   * - On a node with a set width/height aspect ratio control the size of the unset dimension
+   * - On a node with a set flex basis aspect ratio controls the size of the node in the cross axis
+   *   if unset
+   * - On a node with a measure function aspect ratio works as though the measure function measures
+   *   the flex basis
+   * - On a node with flex grow/shrink aspect ratio controls the size of the node in the cross axis
+   *   if unset
+   * - Aspect ratio takes min/max dimensions into account
+   */
+  aspectRatio: ReactPropTypes.number,
+
+  /** `zIndex` controls which components display on top of others.
+   *  Normally, you don't use `zIndex`. Components render according to
+   *  their order in the document tree, so later components draw over
+   *  earlier ones. `zIndex` may be useful if you have animations or custom
+   *  modal interfaces where you don't want this behavior.
+   *
+   *  It works like the CSS `z-index` property - components with a larger
+   *  `zIndex` will render on top. Think of the z-direction like it's
+   *  pointing from the phone into your eyeball.
+   *  See https://developer.mozilla.org/en-US/docs/Web/CSS/z-index for
+   *  more details.
+   */
+  zIndex: ReactPropTypes.number,
+
+  /** `direction` specifies the directional flow of the user interface.
+   *  The default is `inherit`, except for root node which will have
+   *  value based on the current locale.
+   *  See https://facebook.github.io/yoga/docs/rtl/
+   *  for more details.
+   *  @platform ios
+   */
+  direction: ReactPropTypes.oneOf([
+    'inherit',
+    'ltr',
+    'rtl',
+  ]),
+};
+
+module.exports = LayoutPropTypes;

node_modules/react-native/Libraries/StyleSheet/PointPropType.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule PointPropType
+ * @flow
+ */
+'use strict';
+
+var PropTypes = require('prop-types');
+
+var createStrictShapeTypeChecker = require('createStrictShapeTypeChecker');
+
+var PointPropType = createStrictShapeTypeChecker({
+  x: PropTypes.number,
+  y: PropTypes.number,
+});
+
+module.exports = PointPropType;

node_modules/react-native/Libraries/StyleSheet/StyleSheet.js

@@ -0,0 +1,240 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule StyleSheet
+ * @flow
+ * @format
+ */
+'use strict';
+
+const PixelRatio = require('PixelRatio');
+const ReactNativePropRegistry = require('ReactNativePropRegistry');
+const ReactNativeStyleAttributes = require('ReactNativeStyleAttributes');
+const StyleSheetValidation = require('StyleSheetValidation');
+
+const flatten = require('flattenStyle');
+
+import type {
+  ____StyleSheetInternalStyleIdentifier_Internal as StyleSheetInternalStyleIdentifier,
+  ____Styles_Internal,
+  ____DangerouslyImpreciseStyleProp_Internal,
+  ____ViewStyleProp_Internal,
+  ____TextStyleProp_Internal,
+  ____ImageStyleProp_Internal,
+  LayoutStyle,
+} from 'StyleSheetTypes';
+
+export type DangerouslyImpreciseStyleProp = ____DangerouslyImpreciseStyleProp_Internal;
+export type ViewStyleProp = ____ViewStyleProp_Internal;
+export type TextStyleProp = ____TextStyleProp_Internal;
+export type ImageStyleProp = ____ImageStyleProp_Internal;
+
+let hairlineWidth = PixelRatio.roundToNearestPixel(0.4);
+if (hairlineWidth === 0) {
+  hairlineWidth = 1 / PixelRatio.get();
+}
+
+const absoluteFillObject: LayoutStyle = {
+  position: 'absolute',
+  left: 0,
+  right: 0,
+  top: 0,
+  bottom: 0,
+};
+const absoluteFill: StyleSheetInternalStyleIdentifier = ReactNativePropRegistry.register(
+  absoluteFillObject,
+); // This also freezes it
+
+/**
+ * A StyleSheet is an abstraction similar to CSS StyleSheets
+ *
+ * Create a new StyleSheet:
+ *
+ * ```
+ * const styles = StyleSheet.create({
+ *   container: {
+ *     borderRadius: 4,
+ *     borderWidth: 0.5,
+ *     borderColor: '#d6d7da',
+ *   },
+ *   title: {
+ *     fontSize: 19,
+ *     fontWeight: 'bold',
+ *   },
+ *   activeTitle: {
+ *     color: 'red',
+ *   },
+ * });
+ * ```
+ *
+ * Use a StyleSheet:
+ *
+ * ```
+ * <View style={styles.container}>
+ *   <Text style={[styles.title, this.props.isActive && styles.activeTitle]} />
+ * </View>
+ * ```
+ *
+ * Code quality:
+ *
+ *  - By moving styles away from the render function, you're making the code
+ *  easier to understand.
+ *  - Naming the styles is a good way to add meaning to the low level components
+ *  in the render function.
+ *
+ * Performance:
+ *
+ *  - Making a stylesheet from a style object makes it possible to refer to it
+ * by ID instead of creating a new style object every time.
+ *  - It also allows to send the style only once through the bridge. All
+ * subsequent uses are going to refer an id (not implemented yet).
+ */
+module.exports = {
+  /**
+   * This is defined as the width of a thin line on the platform. It can be
+   * used as the thickness of a border or division between two elements.
+   * Example:
+   * ```
+   *   {
+   *     borderBottomColor: '#bbb',
+   *     borderBottomWidth: StyleSheet.hairlineWidth
+   *   }
+   * ```
+   *
+   * This constant will always be a round number of pixels (so a line defined
+   * by it look crisp) and will try to match the standard width of a thin line
+   * on the underlying platform. However, you should not rely on it being a
+   * constant size, because on different platforms and screen densities its
+   * value may be calculated differently.
+   *
+   * A line with hairline width may not be visible if your simulator is downscaled.
+   */
+  hairlineWidth,
+
+  /**
+   * A very common pattern is to create overlays with position absolute and zero positioning,
+   * so `absoluteFill` can be used for convenience and to reduce duplication of these repeated
+   * styles.
+   */
+  absoluteFill,
+
+  /**
+   * Sometimes you may want `absoluteFill` but with a couple tweaks - `absoluteFillObject` can be
+   * used to create a customized entry in a `StyleSheet`, e.g.:
+   *
+   *   const styles = StyleSheet.create({
+   *     wrapper: {
+   *       ...StyleSheet.absoluteFillObject,
+   *       top: 10,
+   *       backgroundColor: 'transparent',
+   *     },
+   *   });
+   */
+  absoluteFillObject,
+
+  /**
+   * Combines two styles such that `style2` will override any styles in `style1`.
+   * If either style is falsy, the other one is returned without allocating an
+   * array, saving allocations and maintaining reference equality for
+   * PureComponent checks.
+   */
+  compose(
+    style1: ?DangerouslyImpreciseStyleProp,
+    style2: ?DangerouslyImpreciseStyleProp,
+  ): ?DangerouslyImpreciseStyleProp {
+    if (style1 != null && style2 != null) {
+      return [style1, style2];
+    } else {
+      return style1 != null ? style1 : style2;
+    }
+  },
+
+  /**
+   * Flattens an array of style objects, into one aggregated style object.
+   * Alternatively, this method can be used to lookup IDs, returned by
+   * StyleSheet.register.
+   *
+   * > **NOTE**: Exercise caution as abusing this can tax you in terms of
+   * > optimizations.
+   * >
+   * > IDs enable optimizations through the bridge and memory in general. Refering
+   * > to style objects directly will deprive you of these optimizations.
+   *
+   * Example:
+   * ```
+   * const styles = StyleSheet.create({
+   *   listItem: {
+   *     flex: 1,
+   *     fontSize: 16,
+   *     color: 'white'
+   *   },
+   *   selectedListItem: {
+   *     color: 'green'
+   *   }
+   * });
+   *
+   * StyleSheet.flatten([styles.listItem, styles.selectedListItem])
+   * // returns { flex: 1, fontSize: 16, color: 'green' }
+   * ```
+   * Alternative use:
+   * ```
+   * StyleSheet.flatten(styles.listItem);
+   * // return { flex: 1, fontSize: 16, color: 'white' }
+   * // Simply styles.listItem would return its ID (number)
+   * ```
+   * This method internally uses `StyleSheetRegistry.getStyleByID(style)`
+   * to resolve style objects represented by IDs. Thus, an array of style
+   * objects (instances of StyleSheet.create), are individually resolved to,
+   * their respective objects, merged as one and then returned. This also explains
+   * the alternative use.
+   */
+  flatten,
+
+  /**
+   * WARNING: EXPERIMENTAL. Breaking changes will probably happen a lot and will
+   * not be reliably announced. The whole thing might be deleted, who knows? Use
+   * at your own risk.
+   *
+   * Sets a function to use to pre-process a style property value. This is used
+   * internally to process color and transform values. You should not use this
+   * unless you really know what you are doing and have exhausted other options.
+   */
+  setStyleAttributePreprocessor(
+    property: string,
+    process: (nextProp: mixed) => mixed,
+  ) {
+    let value;
+
+    if (typeof ReactNativeStyleAttributes[property] === 'string') {
+      value = {};
+    } else if (typeof ReactNativeStyleAttributes[property] === 'object') {
+      value = ReactNativeStyleAttributes[property];
+    } else {
+      console.error(`${property} is not a valid style attribute`);
+      return;
+    }
+
+    if (__DEV__ && typeof value.process === 'function') {
+      console.warn(`Overwriting ${property} style attribute preprocessor`);
+    }
+
+    ReactNativeStyleAttributes[property] = {...value, process};
+  },
+
+  /**
+   * Creates a StyleSheet style reference from the given object.
+   */
+  create<+S: ____Styles_Internal>(
+    obj: S,
+  ): $ObjMap<S, (Object) => StyleSheetInternalStyleIdentifier> {
+    const result = {};
+    for (const key in obj) {
+      StyleSheetValidation.validateStyle(key, obj);
+      result[key] = obj[key] && ReactNativePropRegistry.register(obj[key]);
+    }
+    return result;
+  },
+};

node_modules/react-native/Libraries/StyleSheet/StyleSheetPropType.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule StyleSheetPropType
+ * @flow
+ */
+'use strict';
+
+var createStrictShapeTypeChecker = require('createStrictShapeTypeChecker');
+var flattenStyle = require('flattenStyle');
+
+function StyleSheetPropType(
+  shape: {[key: string]: ReactPropsCheckType}
+): ReactPropsCheckType {
+  var shapePropType = createStrictShapeTypeChecker(shape);
+  return function(props, propName, componentName, location?, ...rest) {
+    var newProps = props;
+    if (props[propName]) {
+      // Just make a dummy prop object with only the flattened style
+      newProps = {};
+      newProps[propName] = flattenStyle(props[propName]);
+    }
+    return shapePropType(newProps, propName, componentName, location, ...rest);
+  };
+}
+
+module.exports = StyleSheetPropType;

node_modules/react-native/Libraries/StyleSheet/StyleSheetTypes.js

@@ -0,0 +1,267 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule StyleSheetTypes
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import AnimatedNode from 'AnimatedNode';
+
+export opaque type ____StyleSheetInternalStyleIdentifier_Internal: number = number;
+
+export type ColorValue = null | string;
+export type DimensionValue = null | number | string | AnimatedNode;
+
+export type LayoutStyle = $ReadOnly<{|
+  display?: 'none' | 'flex',
+  width?: DimensionValue,
+  height?: DimensionValue,
+  bottom?: DimensionValue,
+  end?: DimensionValue,
+  left?: DimensionValue,
+  right?: DimensionValue,
+  start?: DimensionValue,
+  top?: DimensionValue,
+  minWidth?: DimensionValue,
+  maxWidth?: DimensionValue,
+  minHeight?: DimensionValue,
+  maxHeight?: DimensionValue,
+  margin?: DimensionValue,
+  marginBottom?: DimensionValue,
+  marginEnd?: DimensionValue,
+  marginHorizontal?: DimensionValue,
+  marginLeft?: DimensionValue,
+  marginRight?: DimensionValue,
+  marginStart?: DimensionValue,
+  marginTop?: DimensionValue,
+  marginVertical?: DimensionValue,
+  padding?: DimensionValue,
+  paddingBottom?: DimensionValue,
+  paddingEnd?: DimensionValue,
+  paddingHorizontal?: DimensionValue,
+  paddingLeft?: DimensionValue,
+  paddingRight?: DimensionValue,
+  paddingStart?: DimensionValue,
+  paddingTop?: DimensionValue,
+  paddingVertical?: DimensionValue,
+  borderWidth?: number,
+  borderBottomWidth?: number,
+  borderEndWidth?: number,
+  borderLeftWidth?: number,
+  borderRightWidth?: number,
+  borderStartWidth?: number,
+  borderTopWidth?: number,
+  position?: 'absolute' | 'relative',
+  flexDirection?: 'row' | 'row-reverse' | 'column' | 'column-reverse',
+  flexWrap?: 'wrap' | 'nowrap',
+  justifyContent?:
+    | 'flex-start'
+    | 'flex-end'
+    | 'center'
+    | 'space-between'
+    | 'space-around'
+    | 'space-evenly',
+  alignItems?: 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline',
+  alignSelf?:
+    | 'auto'
+    | 'flex-start'
+    | 'flex-end'
+    | 'center'
+    | 'stretch'
+    | 'baseline',
+  alignContent?:
+    | 'flex-start'
+    | 'flex-end'
+    | 'center'
+    | 'stretch'
+    | 'space-between'
+    | 'space-around',
+  overflow?: 'visible' | 'hidden' | 'scroll',
+  flex?: number,
+  flexGrow?: number,
+  flexShrink?: number,
+  flexBasis?: number | string,
+  aspectRatio?: number,
+  zIndex?: number,
+  direction?: 'inherit' | 'ltr' | 'rtl',
+|}>;
+
+export type TransformStyle = $ReadOnly<{|
+  transform?: $ReadOnlyArray<
+    | {|+perspective: number | AnimatedNode|}
+    | {|+rotate: string|}
+    | {|+rotateX: string|}
+    | {|+rotateY: string|}
+    | {|+rotateZ: string|}
+    | {|+scale: number | AnimatedNode|}
+    | {|+scaleX: number | AnimatedNode|}
+    | {|+scaleY: number | AnimatedNode|}
+    | {|+translateX: number | AnimatedNode|}
+    | {|+translateY: number | AnimatedNode|}
+    | {|
+      +translate: [number | AnimatedNode, number | AnimatedNode] | AnimatedNode,
+    |}
+    | {|+skewX: string|}
+    | {|+skewY: string|}
+    // TODO: what is the actual type it expects?
+    | {|
+      +matrix: $ReadOnlyArray<number | AnimatedNode> | AnimatedNode,
+    |},
+  >,
+|}>;
+
+export type ShadowStyle = $ReadOnly<{|
+  shadowColor?: ColorValue,
+  shadowOffset?: $ReadOnly<{|
+    width?: number,
+    height?: number,
+  |}>,
+  shadowOpacity?: number | AnimatedNode,
+  shadowRadius?: number,
+|}>;
+
+export type ViewStyle = $ReadOnly<{|
+  ...$Exact<LayoutStyle>,
+  ...$Exact<ShadowStyle>,
+  ...$Exact<TransformStyle>,
+  backfaceVisibility?: 'visible' | 'hidden',
+  backgroundColor?: ColorValue,
+  borderColor?: ColorValue,
+  borderBottomColor?: ColorValue,
+  borderEndColor?: ColorValue,
+  borderLeftColor?: ColorValue,
+  borderRightColor?: ColorValue,
+  borderStartColor?: ColorValue,
+  borderTopColor?: ColorValue,
+  borderRadius?: number,
+  borderBottomEndRadius?: number,
+  borderBottomLeftRadius?: number,
+  borderBottomRightRadius?: number,
+  borderBottomStartRadius?: number,
+  borderTopEndRadius?: number,
+  borderTopLeftRadius?: number,
+  borderTopRightRadius?: number,
+  borderTopStartRadius?: number,
+  borderStyle?: 'solid' | 'dotted' | 'dashed',
+  borderWidth?: number,
+  borderBottomWidth?: number,
+  borderEndWidth?: number,
+  borderLeftWidth?: number,
+  borderRightWidth?: number,
+  borderStartWidth?: number,
+  borderTopWidth?: number,
+  opacity?: number | AnimatedNode,
+  elevation?: number,
+|}>;
+
+export type TextStyle = $ReadOnly<{|
+  ...$Exact<ViewStyle>,
+  color?: ColorValue,
+  fontFamily?: string,
+  fontSize?: number,
+  fontStyle?: 'normal' | 'italic',
+  fontWeight?:
+    | 'normal'
+    | 'bold'
+    | '100'
+    | '200'
+    | '300'
+    | '400'
+    | '500'
+    | '600'
+    | '700'
+    | '800'
+    | '900',
+  fontVariant?: $ReadOnlyArray<
+    | 'small-caps'
+    | 'oldstyle-nums'
+    | 'lining-nums'
+    | 'tabular-nums'
+    | 'proportional-nums',
+  >,
+  textShadowOffset?: $ReadOnly<{|
+    width?: number,
+    height?: number,
+  |}>,
+  textShadowRadius?: number,
+  textShadowColor?: ColorValue,
+  letterSpacing?: number,
+  lineHeight?: number,
+  textAlign?: 'auto' | 'left' | 'right' | 'center' | 'justify',
+  textAlignVertical?: 'auto' | 'top' | 'bottom' | 'center',
+  includeFontPadding?: boolean,
+  textDecorationLine?:
+    | 'none'
+    | 'underline'
+    | 'line-through'
+    | 'underline line-through',
+  textDecorationStyle?: 'solid' | 'double' | 'dotted' | 'dashed',
+  textDecorationColor?: ColorValue,
+  writingDirection?: 'auto' | 'ltr' | 'rtl',
+|}>;
+
+export type ImageStyle = $ReadOnly<{|
+  ...$Exact<ViewStyle>,
+  resizeMode?: 'contain' | 'cover' | 'stretch' | 'center' | 'repeat',
+  tintColor?: ColorValue,
+  overlayColor?: string,
+|}>;
+
+export type DangerouslyImpreciseStyle = {
+  ...$Exact<TextStyle>,
+  +resizeMode?: 'contain' | 'cover' | 'stretch' | 'center' | 'repeat',
+  +tintColor?: ColorValue,
+  +overlayColor?: string,
+};
+
+type GenericStyleProp<+T> =
+  | null
+  | void
+  | T
+  | ____StyleSheetInternalStyleIdentifier_Internal
+  | number
+  | false
+  | ''
+  | $ReadOnlyArray<GenericStyleProp<T>>;
+
+export type ____DangerouslyImpreciseStyleProp_Internal = GenericStyleProp<
+  $Shape<DangerouslyImpreciseStyle>,
+>;
+export type ____ViewStyleProp_Internal = GenericStyleProp<
+  $ReadOnly<$Shape<ViewStyle>>,
+>;
+export type ____TextStyleProp_Internal = GenericStyleProp<
+  $ReadOnly<$Shape<TextStyle>>,
+>;
+export type ____ImageStyleProp_Internal = GenericStyleProp<
+  $ReadOnly<$Shape<ImageStyle>>,
+>;
+
+export type ____Styles_Internal = {
+  +[key: string]: $Shape<DangerouslyImpreciseStyle>,
+};
+
+/*
+Utility type get non-nullable types for specific style keys.
+Useful when a component requires values for certain Style Keys.
+So Instead:
+```
+type Props = {position: string};
+```
+You should use:
+```
+type Props = {position: TypeForStyleKey<'position'>};
+```
+
+This will correctly give you the type 'absolute' | 'relative' instead of the
+weak type of just string;
+*/
+export type TypeForStyleKey<
+  +key: $Keys<DangerouslyImpreciseStyle>,
+> = $ElementType<DangerouslyImpreciseStyle, key>;

node_modules/react-native/Libraries/StyleSheet/StyleSheetValidation.js

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule StyleSheetValidation
+ * @flow
+ */
+'use strict';
+
+var ImageStylePropTypes = require('ImageStylePropTypes');
+var TextStylePropTypes = require('TextStylePropTypes');
+var ViewStylePropTypes = require('ViewStylePropTypes');
+
+var invariant = require('fbjs/lib/invariant');
+
+// Hardcoded because this is a legit case but we don't want to load it from
+// a private API. We might likely want to unify style sheet creation with how it
+// is done in the DOM so this might move into React. I know what I'm doing so
+// plz don't fire me.
+const ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+class StyleSheetValidation {
+  static validateStyleProp(prop: string, style: Object, caller: string) {
+    if (!__DEV__) {
+      return;
+    }
+    if (allStylePropTypes[prop] === undefined) {
+      var message1 = '"' + prop + '" is not a valid style property.';
+      var message2 = '\nValid style props: ' +
+        JSON.stringify(Object.keys(allStylePropTypes).sort(), null, '  ');
+      styleError(message1, style, caller, message2);
+    }
+    var error = allStylePropTypes[prop](
+      style,
+      prop,
+      caller,
+      'prop',
+      null,
+      ReactPropTypesSecret,
+    );
+    if (error) {
+      styleError(error.message, style, caller);
+    }
+  }
+
+  static validateStyle(name: string, styles: Object) {
+    if (!__DEV__) {
+      return;
+    }
+    for (var prop in styles[name]) {
+      StyleSheetValidation.validateStyleProp(prop, styles[name], 'StyleSheet ' + name);
+    }
+  }
+
+  static addValidStylePropTypes(stylePropTypes) {
+    for (var key in stylePropTypes) {
+      allStylePropTypes[key] = stylePropTypes[key];
+    }
+  }
+}
+
+var styleError = function(message1, style, caller?, message2?) {
+  invariant(
+    false,
+    message1 + '\n' + (caller || '<<unknown>>') + ': ' +
+    JSON.stringify(style, null, '  ') + (message2 || '')
+  );
+};
+
+var allStylePropTypes = {};
+
+StyleSheetValidation.addValidStylePropTypes(ImageStylePropTypes);
+StyleSheetValidation.addValidStylePropTypes(TextStylePropTypes);
+StyleSheetValidation.addValidStylePropTypes(ViewStylePropTypes);
+
+module.exports = StyleSheetValidation;

node_modules/react-native/Libraries/StyleSheet/TransformPropTypes.js

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule TransformPropTypes
+ * @flow
+ */
+'use strict';
+
+var ReactPropTypes = require('prop-types');
+
+var deprecatedPropType = require('deprecatedPropType');
+
+var TransformMatrixPropType = function(
+  props : Object,
+  propName : string,
+  componentName : string
+) : ?Error {
+  if (props[propName]) {
+    return new Error(
+      'The transformMatrix style property is deprecated. ' +
+      'Use `transform: [{ matrix: ... }]` instead.'
+    );
+  }
+};
+
+var DecomposedMatrixPropType = function(
+  props : Object,
+  propName : string,
+  componentName : string
+) : ?Error {
+  if (props[propName]) {
+    return new Error(
+      'The decomposedMatrix style property is deprecated. ' +
+      'Use `transform: [...]` instead.'
+    );
+  }
+};
+
+var TransformPropTypes = {
+  /**
+   * `transform` accepts an array of transformation objects. Each object specifies
+   * the property that will be transformed as the key, and the value to use in the
+   * transformation. Objects should not be combined. Use a single key/value pair
+   * per object.
+   *
+   * The rotate transformations require a string so that the transform may be
+   * expressed in degrees (deg) or radians (rad). For example:
+   *
+   * `transform([{ rotateX: '45deg' }, { rotateZ: '0.785398rad' }])`
+   *
+   * The skew transformations require a string so that the transform may be
+   * expressed in degrees (deg). For example:
+   *
+   * `transform([{ skewX: '45deg' }])`
+   */
+  transform: ReactPropTypes.arrayOf(
+    ReactPropTypes.oneOfType([
+      ReactPropTypes.shape({perspective: ReactPropTypes.number}),
+      ReactPropTypes.shape({rotate: ReactPropTypes.string}),
+      ReactPropTypes.shape({rotateX: ReactPropTypes.string}),
+      ReactPropTypes.shape({rotateY: ReactPropTypes.string}),
+      ReactPropTypes.shape({rotateZ: ReactPropTypes.string}),
+      ReactPropTypes.shape({scale: ReactPropTypes.number}),
+      ReactPropTypes.shape({scaleX: ReactPropTypes.number}),
+      ReactPropTypes.shape({scaleY: ReactPropTypes.number}),
+      ReactPropTypes.shape({translateX: ReactPropTypes.number}),
+      ReactPropTypes.shape({translateY: ReactPropTypes.number}),
+      ReactPropTypes.shape({skewX: ReactPropTypes.string}),
+      ReactPropTypes.shape({skewY: ReactPropTypes.string})
+    ])
+  ),
+
+  /**
+   * Deprecated. Use the transform prop instead.
+   */
+  transformMatrix: TransformMatrixPropType,
+  /**
+   * Deprecated. Use the transform prop instead.
+   */
+  decomposedMatrix: DecomposedMatrixPropType,
+
+  /* Deprecated transform props used on Android only */
+  scaleX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+  scaleY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+  rotation: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+  translateX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+  translateY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+};
+
+module.exports = TransformPropTypes;

node_modules/react-native/Libraries/StyleSheet/flattenStyle.js

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule flattenStyle
+ * @flow
+ * @format
+ */
+'use strict';
+
+var ReactNativePropRegistry;
+
+import type {DangerouslyImpreciseStyleProp} from 'StyleSheet';
+import type {DangerouslyImpreciseStyle} from 'StyleSheetTypes';
+
+function getStyle(style) {
+  if (ReactNativePropRegistry === undefined) {
+    ReactNativePropRegistry = require('ReactNativePropRegistry');
+  }
+  if (typeof style === 'number') {
+    return ReactNativePropRegistry.getByID(style);
+  }
+  return style;
+}
+
+function flattenStyle(
+  style: ?DangerouslyImpreciseStyleProp,
+): ?DangerouslyImpreciseStyle {
+  if (style == null) {
+    return undefined;
+  }
+
+  if (!Array.isArray(style)) {
+    /* $FlowFixMe(>=0.63.0 site=react_native_fb) This comment suppresses an
+     * error found when Flow v0.63 was deployed. To see the error delete this
+     * comment and run Flow. */
+    return getStyle(style);
+  }
+
+  var result = {};
+  for (var i = 0, styleLength = style.length; i < styleLength; ++i) {
+    var computedStyle = flattenStyle(style[i]);
+    if (computedStyle) {
+      for (var key in computedStyle) {
+        result[key] = computedStyle[key];
+      }
+    }
+  }
+  return result;
+}
+
+module.exports = flattenStyle;

node_modules/react-native/Libraries/StyleSheet/normalizeColor.js

@@ -0,0 +1,344 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule normalizeColor
+ * @flow
+ */
+/* eslint no-bitwise: 0 */
+'use strict';
+
+function normalizeColor(color: string | number): ?number {
+  var match;
+
+  if (typeof color === 'number') {
+    if (color >>> 0 === color && color >= 0 && color <= 0xffffffff) {
+      return color;
+    }
+    return null;
+  }
+
+  // Ordered based on occurrences on Facebook codebase
+  if ((match = matchers.hex6.exec(color))) {
+    return parseInt(match[1] + 'ff', 16) >>> 0;
+  }
+
+  if (names.hasOwnProperty(color)) {
+    return names[color];
+  }
+
+  if ((match = matchers.rgb.exec(color))) {
+    return (
+      (// b
+      parse255(match[1]) << 24 | // r
+      parse255(match[2]) << 16 | // g
+      parse255(match[3]) << 8 | 0x000000ff) // a
+    ) >>> 0;
+  }
+
+  if ((match = matchers.rgba.exec(color))) {
+    return (
+      (// b
+      parse255(match[1]) << 24 | // r
+      parse255(match[2]) << 16 | // g
+      parse255(match[3]) << 8 | parse1(match[4])) // a
+    ) >>> 0;
+  }
+
+  if ((match = matchers.hex3.exec(color))) {
+    return parseInt(
+      match[1] + match[1] + // r
+      match[2] + match[2] + // g
+      match[3] + match[3] + // b
+      'ff', // a
+      16
+    ) >>> 0;
+  }
+
+  // https://drafts.csswg.org/css-color-4/#hex-notation
+  if ((match = matchers.hex8.exec(color))) {
+    return parseInt(match[1], 16) >>> 0;
+  }
+
+  if ((match = matchers.hex4.exec(color))) {
+    return parseInt(
+      match[1] + match[1] + // r
+      match[2] + match[2] + // g
+      match[3] + match[3] + // b
+      match[4] + match[4], // a
+      16
+    ) >>> 0;
+  }
+
+  if ((match = matchers.hsl.exec(color))) {
+    return (
+      (hslToRgb(
+        parse360(match[1]), // h
+        parsePercentage(match[2]), // s
+        parsePercentage(match[3]) // l
+      ) | 0x000000ff) // a
+    ) >>> 0;
+  }
+
+  if ((match = matchers.hsla.exec(color))) {
+    return (
+      (hslToRgb(
+        parse360(match[1]), // h
+        parsePercentage(match[2]), // s
+        parsePercentage(match[3]) // l
+      ) | parse1(match[4])) // a
+    ) >>> 0;
+  }
+
+  return null;
+}
+
+function hue2rgb(p: number, q: number, t: number): number {
+  if (t < 0) {
+    t += 1;
+  }
+  if (t > 1) {
+    t -= 1;
+  }
+  if (t < 1 / 6) {
+    return p + (q - p) * 6 * t;
+  }
+  if (t < 1 / 2) {
+    return q;
+  }
+  if (t < 2 / 3) {
+    return p + (q - p) * (2 / 3 - t) * 6;
+  }
+  return p;
+}
+
+function hslToRgb(h: number, s: number, l: number): number {
+  var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  var p = 2 * l - q;
+  var r = hue2rgb(p, q, h + 1 / 3);
+  var g = hue2rgb(p, q, h);
+  var b = hue2rgb(p, q, h - 1 / 3);
+
+  return (
+    Math.round(r * 255) << 24 |
+    Math.round(g * 255) << 16 |
+    Math.round(b * 255) << 8
+  );
+}
+
+// var INTEGER = '[-+]?\\d+';
+var NUMBER = '[-+]?\\d*\\.?\\d+';
+var PERCENTAGE = NUMBER + '%';
+
+function call(...args) {
+  return '\\(\\s*(' + args.join(')\\s*,\\s*(') + ')\\s*\\)';
+}
+
+var matchers = {
+  rgb: new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER)),
+  rgba: new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER)),
+  hsl: new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE)),
+  hsla: new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER)),
+  hex3: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+  hex4: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+  hex6: /^#([0-9a-fA-F]{6})$/,
+  hex8: /^#([0-9a-fA-F]{8})$/,
+};
+
+function parse255(str: string): number {
+  var int = parseInt(str, 10);
+  if (int < 0) {
+    return 0;
+  }
+  if (int > 255) {
+    return 255;
+  }
+  return int;
+}
+
+function parse360(str: string): number {
+  var int = parseFloat(str);
+  return (((int % 360) + 360) % 360) / 360;
+}
+
+function parse1(str: string): number {
+  var num = parseFloat(str);
+  if (num < 0) {
+    return 0;
+  }
+  if (num > 1) {
+    return 255;
+  }
+  return Math.round(num * 255);
+}
+
+function parsePercentage(str: string): number {
+  // parseFloat conveniently ignores the final %
+  var int = parseFloat(str);
+  if (int < 0) {
+    return 0;
+  }
+  if (int > 100) {
+    return 1;
+  }
+  return int / 100;
+}
+
+var names = {
+  transparent: 0x00000000,
+
+  // http://www.w3.org/TR/css3-color/#svg-color
+  aliceblue: 0xf0f8ffff,
+  antiquewhite: 0xfaebd7ff,
+  aqua: 0x00ffffff,
+  aquamarine: 0x7fffd4ff,
+  azure: 0xf0ffffff,
+  beige: 0xf5f5dcff,
+  bisque: 0xffe4c4ff,
+  black: 0x000000ff,
+  blanchedalmond: 0xffebcdff,
+  blue: 0x0000ffff,
+  blueviolet: 0x8a2be2ff,
+  brown: 0xa52a2aff,
+  burlywood: 0xdeb887ff,
+  burntsienna: 0xea7e5dff,
+  cadetblue: 0x5f9ea0ff,
+  chartreuse: 0x7fff00ff,
+  chocolate: 0xd2691eff,
+  coral: 0xff7f50ff,
+  cornflowerblue: 0x6495edff,
+  cornsilk: 0xfff8dcff,
+  crimson: 0xdc143cff,
+  cyan: 0x00ffffff,
+  darkblue: 0x00008bff,
+  darkcyan: 0x008b8bff,
+  darkgoldenrod: 0xb8860bff,
+  darkgray: 0xa9a9a9ff,
+  darkgreen: 0x006400ff,
+  darkgrey: 0xa9a9a9ff,
+  darkkhaki: 0xbdb76bff,
+  darkmagenta: 0x8b008bff,
+  darkolivegreen: 0x556b2fff,
+  darkorange: 0xff8c00ff,
+  darkorchid: 0x9932ccff,
+  darkred: 0x8b0000ff,
+  darksalmon: 0xe9967aff,
+  darkseagreen: 0x8fbc8fff,
+  darkslateblue: 0x483d8bff,
+  darkslategray: 0x2f4f4fff,
+  darkslategrey: 0x2f4f4fff,
+  darkturquoise: 0x00ced1ff,
+  darkviolet: 0x9400d3ff,
+  deeppink: 0xff1493ff,
+  deepskyblue: 0x00bfffff,
+  dimgray: 0x696969ff,
+  dimgrey: 0x696969ff,
+  dodgerblue: 0x1e90ffff,
+  firebrick: 0xb22222ff,
+  floralwhite: 0xfffaf0ff,
+  forestgreen: 0x228b22ff,
+  fuchsia: 0xff00ffff,
+  gainsboro: 0xdcdcdcff,
+  ghostwhite: 0xf8f8ffff,
+  gold: 0xffd700ff,
+  goldenrod: 0xdaa520ff,
+  gray: 0x808080ff,
+  green: 0x008000ff,
+  greenyellow: 0xadff2fff,
+  grey: 0x808080ff,
+  honeydew: 0xf0fff0ff,
+  hotpink: 0xff69b4ff,
+  indianred: 0xcd5c5cff,
+  indigo: 0x4b0082ff,
+  ivory: 0xfffff0ff,
+  khaki: 0xf0e68cff,
+  lavender: 0xe6e6faff,
+  lavenderblush: 0xfff0f5ff,
+  lawngreen: 0x7cfc00ff,
+  lemonchiffon: 0xfffacdff,
+  lightblue: 0xadd8e6ff,
+  lightcoral: 0xf08080ff,
+  lightcyan: 0xe0ffffff,
+  lightgoldenrodyellow: 0xfafad2ff,
+  lightgray: 0xd3d3d3ff,
+  lightgreen: 0x90ee90ff,
+  lightgrey: 0xd3d3d3ff,
+  lightpink: 0xffb6c1ff,
+  lightsalmon: 0xffa07aff,
+  lightseagreen: 0x20b2aaff,
+  lightskyblue: 0x87cefaff,
+  lightslategray: 0x778899ff,
+  lightslategrey: 0x778899ff,
+  lightsteelblue: 0xb0c4deff,
+  lightyellow: 0xffffe0ff,
+  lime: 0x00ff00ff,
+  limegreen: 0x32cd32ff,
+  linen: 0xfaf0e6ff,
+  magenta: 0xff00ffff,
+  maroon: 0x800000ff,
+  mediumaquamarine: 0x66cdaaff,
+  mediumblue: 0x0000cdff,
+  mediumorchid: 0xba55d3ff,
+  mediumpurple: 0x9370dbff,
+  mediumseagreen: 0x3cb371ff,
+  mediumslateblue: 0x7b68eeff,
+  mediumspringgreen: 0x00fa9aff,
+  mediumturquoise: 0x48d1ccff,
+  mediumvioletred: 0xc71585ff,
+  midnightblue: 0x191970ff,
+  mintcream: 0xf5fffaff,
+  mistyrose: 0xffe4e1ff,
+  moccasin: 0xffe4b5ff,
+  navajowhite: 0xffdeadff,
+  navy: 0x000080ff,
+  oldlace: 0xfdf5e6ff,
+  olive: 0x808000ff,
+  olivedrab: 0x6b8e23ff,
+  orange: 0xffa500ff,
+  orangered: 0xff4500ff,
+  orchid: 0xda70d6ff,
+  palegoldenrod: 0xeee8aaff,
+  palegreen: 0x98fb98ff,
+  paleturquoise: 0xafeeeeff,
+  palevioletred: 0xdb7093ff,
+  papayawhip: 0xffefd5ff,
+  peachpuff: 0xffdab9ff,
+  peru: 0xcd853fff,
+  pink: 0xffc0cbff,
+  plum: 0xdda0ddff,
+  powderblue: 0xb0e0e6ff,
+  purple: 0x800080ff,
+  rebeccapurple: 0x663399ff,
+  red: 0xff0000ff,
+  rosybrown: 0xbc8f8fff,
+  royalblue: 0x4169e1ff,
+  saddlebrown: 0x8b4513ff,
+  salmon: 0xfa8072ff,
+  sandybrown: 0xf4a460ff,
+  seagreen: 0x2e8b57ff,
+  seashell: 0xfff5eeff,
+  sienna: 0xa0522dff,
+  silver: 0xc0c0c0ff,
+  skyblue: 0x87ceebff,
+  slateblue: 0x6a5acdff,
+  slategray: 0x708090ff,
+  slategrey: 0x708090ff,
+  snow: 0xfffafaff,
+  springgreen: 0x00ff7fff,
+  steelblue: 0x4682b4ff,
+  tan: 0xd2b48cff,
+  teal: 0x008080ff,
+  thistle: 0xd8bfd8ff,
+  tomato: 0xff6347ff,
+  turquoise: 0x40e0d0ff,
+  violet: 0xee82eeff,
+  wheat: 0xf5deb3ff,
+  white: 0xffffffff,
+  whitesmoke: 0xf5f5f5ff,
+  yellow: 0xffff00ff,
+  yellowgreen: 0x9acd32ff,
+};
+
+module.exports = normalizeColor;

node_modules/react-native/Libraries/StyleSheet/processColor.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule processColor
+ * @flow
+ */
+'use strict';
+
+const Platform = require('Platform');
+
+const normalizeColor = require('normalizeColor');
+
+/* eslint no-bitwise: 0 */
+function processColor(color?: string | number): ?number {
+  if (color === undefined || color === null) {
+    return color;
+  }
+
+  let int32Color = normalizeColor(color);
+  if (int32Color === null || int32Color === undefined) {
+    return undefined;
+  }
+
+  // Converts 0xrrggbbaa into 0xaarrggbb
+  int32Color = (int32Color << 24 | int32Color >>> 8) >>> 0;
+
+  if (Platform.OS === 'android') {
+    // Android use 32 bit *signed* integer to represent the color
+    // We utilize the fact that bitwise operations in JS also operates on
+    // signed 32 bit integers, so that we can use those to convert from
+    // *unsigned* to *signed* 32bit int that way.
+    int32Color = int32Color | 0x0;
+  }
+  return int32Color;
+}
+
+module.exports = processColor;

node_modules/react-native/Libraries/StyleSheet/processTransform.js

@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule processTransform
+ * @flow
+ */
+'use strict';
+
+var MatrixMath = require('MatrixMath');
+var Platform = require('Platform');
+
+var invariant = require('fbjs/lib/invariant');
+var stringifySafe = require('stringifySafe');
+
+/**
+ * Generate a transform matrix based on the provided transforms, and use that
+ * within the style object instead.
+ *
+ * This allows us to provide an API that is similar to CSS, where transforms may
+ * be applied in an arbitrary order, and yet have a universal, singular
+ * interface to native code.
+ */
+function processTransform(transform: Array<Object>): Array<Object> | Array<number> {
+  if (__DEV__) {
+    _validateTransforms(transform);
+  }
+
+  // Android & iOS implementations of transform property accept the list of
+  // transform properties as opposed to a transform Matrix. This is necessary
+  // to control transform property updates completely on the native thread.
+  if (Platform.OS === 'android' || Platform.OS === 'ios') {
+    return transform;
+  }
+
+  var result = MatrixMath.createIdentityMatrix();
+
+  transform.forEach(transformation => {
+    var key = Object.keys(transformation)[0];
+    var value = transformation[key];
+
+    switch (key) {
+      case 'matrix':
+        MatrixMath.multiplyInto(result, result, value);
+        break;
+      case 'perspective':
+        _multiplyTransform(result, MatrixMath.reusePerspectiveCommand, [value]);
+        break;
+      case 'rotateX':
+        _multiplyTransform(result, MatrixMath.reuseRotateXCommand, [_convertToRadians(value)]);
+        break;
+      case 'rotateY':
+        _multiplyTransform(result, MatrixMath.reuseRotateYCommand, [_convertToRadians(value)]);
+        break;
+      case 'rotate':
+      case 'rotateZ':
+        _multiplyTransform(result, MatrixMath.reuseRotateZCommand, [_convertToRadians(value)]);
+        break;
+      case 'scale':
+        _multiplyTransform(result, MatrixMath.reuseScaleCommand, [value]);
+        break;
+      case 'scaleX':
+        _multiplyTransform(result, MatrixMath.reuseScaleXCommand, [value]);
+        break;
+      case 'scaleY':
+        _multiplyTransform(result, MatrixMath.reuseScaleYCommand, [value]);
+        break;
+      case 'translate':
+        _multiplyTransform(result, MatrixMath.reuseTranslate3dCommand, [value[0], value[1], value[2] || 0]);
+        break;
+      case 'translateX':
+        _multiplyTransform(result, MatrixMath.reuseTranslate2dCommand, [value, 0]);
+        break;
+      case 'translateY':
+        _multiplyTransform(result, MatrixMath.reuseTranslate2dCommand, [0, value]);
+        break;
+      case 'skewX':
+        _multiplyTransform(result, MatrixMath.reuseSkewXCommand, [_convertToRadians(value)]);
+        break;
+      case 'skewY':
+        _multiplyTransform(result, MatrixMath.reuseSkewYCommand, [_convertToRadians(value)]);
+        break;
+      default:
+        throw new Error('Invalid transform name: ' + key);
+    }
+  });
+
+  return result;
+}
+
+/**
+ * Performs a destructive operation on a transform matrix.
+ */
+function _multiplyTransform(
+  result: Array<number>,
+  matrixMathFunction: Function,
+  args: Array<number>
+): void {
+  var matrixToApply = MatrixMath.createIdentityMatrix();
+  var argsWithIdentity = [matrixToApply].concat(args);
+  matrixMathFunction.apply(this, argsWithIdentity);
+  MatrixMath.multiplyInto(result, result, matrixToApply);
+}
+
+/**
+ * Parses a string like '0.5rad' or '60deg' into radians expressed in a float.
+ * Note that validation on the string is done in `_validateTransform()`.
+ */
+function _convertToRadians(value: string): number {
+  var floatValue = parseFloat(value);
+  return value.indexOf('rad') > -1 ? floatValue : floatValue * Math.PI / 180;
+}
+
+function _validateTransforms(transform: Array<Object>): void {
+  transform.forEach(transformation => {
+    var keys = Object.keys(transformation);
+    invariant(
+      keys.length === 1,
+      'You must specify exactly one property per transform object. Passed properties: %s',
+      stringifySafe(transformation),
+    );
+    var key = keys[0];
+    var value = transformation[key];
+    _validateTransform(key, value, transformation);
+  });
+}
+
+function _validateTransform(key, value, transformation) {
+  invariant(
+    !value.getValue,
+    'You passed an Animated.Value to a normal component. ' +
+    'You need to wrap that component in an Animated. For example, ' +
+    'replace <View /> by <Animated.View />.'
+  );
+
+  var multivalueTransforms = [
+    'matrix',
+    'translate',
+  ];
+  if (multivalueTransforms.indexOf(key) !== -1) {
+    invariant(
+      Array.isArray(value),
+      'Transform with key of %s must have an array as the value: %s',
+      key,
+      stringifySafe(transformation),
+    );
+  }
+  switch (key) {
+    case 'matrix':
+      invariant(
+        value.length === 9 || value.length === 16,
+        'Matrix transform must have a length of 9 (2d) or 16 (3d). ' +
+          'Provided matrix has a length of %s: %s',
+        value.length,
+        stringifySafe(transformation),
+      );
+      break;
+    case 'translate':
+      invariant(
+        value.length === 2 || value.length === 3,
+        'Transform with key translate must be an array of length 2 or 3, found %s: %s',
+        value.length,
+        stringifySafe(transformation),
+      );
+      break;
+    case 'rotateX':
+    case 'rotateY':
+    case 'rotateZ':
+    case 'rotate':
+    case 'skewX':
+    case 'skewY':
+      invariant(
+        typeof value === 'string',
+        'Transform with key of "%s" must be a string: %s',
+        key,
+        stringifySafe(transformation),
+      );
+      invariant(
+        value.indexOf('deg') > -1 || value.indexOf('rad') > -1,
+        'Rotate transform must be expressed in degrees (deg) or radians ' +
+          '(rad): %s',
+        stringifySafe(transformation),
+      );
+      break;
+    case 'perspective':
+      invariant(
+        typeof value === 'number',
+        'Transform with key of "%s" must be a number: %s',
+        key,
+        stringifySafe(transformation),
+      );
+      invariant(
+        value !== 0,
+        'Transform with key of "%s" cannot be zero: %s',
+        key,
+        stringifySafe(transformation),
+      );
+      break;
+    case 'translateX':
+    case 'translateY':
+    case 'scale':
+    case 'scaleX':
+    case 'scaleY':
+      invariant(
+        typeof value === 'number',
+        'Transform with key of "%s" must be a number: %s',
+        key,
+        stringifySafe(transformation),
+      );
+      break;
+    default:
+      invariant(false, 'Invalid transform %s: %s', key, stringifySafe(transformation));
+  }
+}
+
+module.exports = processTransform;

node_modules/react-native/Libraries/StyleSheet/setNormalizedColorAlpha.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule setNormalizedColorAlpha
+ * @flow
+ */
+/* eslint no-bitwise: 0 */
+'use strict';
+
+/**
+ * number should be a color processed by `normalizeColor`
+ * alpha should be number between 0 and 1
+ */
+function setNormalizedColorAlpha(input: number, alpha: number): number {
+  if (alpha < 0) {
+    alpha = 0;
+  } else if (alpha > 1) {
+    alpha = 1;
+  }
+
+  alpha = Math.round(alpha * 255);
+  // magic bitshift guarantees we return an unsigned int
+  return ((input & 0xffffff00) | alpha) >>> 0;
+}
+
+module.exports = setNormalizedColorAlpha;