@ray-js/components 0.5.4 → 0.5.6-beta-1

package/lib/ScrollView/ScrollView.native.js

@@ -0,0 +1,283 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/es.array.concat.js";
+import * as React from 'react';
+import { ScrollView, StyleSheet } from 'react-native';
+import { omit } from '../utils';
+
+var _ScrollView = /*#__PURE__*/function (_React$Component) {
+  _inherits(_ScrollView, _React$Component);
+
+  var _super = _createSuper(_ScrollView);
+
+  function _ScrollView() {
+    var _this;
+
+    _classCallCheck(this, _ScrollView);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      snapScrollTop: 0,
+      snapScrollLeft: 0
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_scrollMetrics", {
+      contentLength: 0,
+      dOffset: 0,
+      dt: 10,
+      offset: 0,
+      offsetX: 0,
+      offsetY: 0,
+      timestamp: 0,
+      velocity: 0,
+      visibleLength: 0
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "$scrollView", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "_sentEndForContentLength", 0);
+
+    _defineProperty(_assertThisInitialized(_this), "_scrollEventThrottle", 50);
+
+    _defineProperty(_assertThisInitialized(_this), "_hasCallScrollToUpperInRange", true);
+
+    _defineProperty(_assertThisInitialized(_this), "_hasCallScrollToLowerInRange", false);
+
+    _defineProperty(_assertThisInitialized(_this), "_selectLength", function (metrics) {
+      var scrollX = _this.props.scrollX;
+      return !scrollX ? metrics.height : metrics.width;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_selectOffset", function (metrics) {
+      var scrollX = _this.props.scrollX;
+      return !scrollX ? metrics.y : metrics.x;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_maybeCallOnStartReached", function (e) {
+      var _this$props = _this.props,
+          onScrollToUpper = _this$props.onScrollToUpper,
+          upperThreshold = _this$props.upperThreshold,
+          scrollX = _this$props.scrollX;
+      var offset = _this._scrollMetrics.offset;
+
+      if (onScrollToUpper && offset <= upperThreshold) {
+        if (!_this._hasCallScrollToUpperInRange) {
+          typeof onScrollToUpper === 'function' && onScrollToUpper({
+            type: 'scrolltoupper',
+            direction: scrollX ? 'left' : 'top',
+            // distanceFromTop: offset,
+            origin: e
+          });
+          _this._hasCallScrollToUpperInRange = true;
+        }
+      } else {
+        _this._hasCallScrollToUpperInRange = false;
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_maybeCallOnEndReached", function (e) {
+      var _this$props2 = _this.props,
+          onScrollToLower = _this$props2.onScrollToLower,
+          lowerThreshold = _this$props2.lowerThreshold,
+          scrollX = _this$props2.scrollX;
+      var _this$_scrollMetrics = _this._scrollMetrics,
+          contentLength = _this$_scrollMetrics.contentLength,
+          visibleLength = _this$_scrollMetrics.visibleLength,
+          offset = _this$_scrollMetrics.offset;
+
+      if (onScrollToLower && contentLength - visibleLength - offset < lowerThreshold) {
+        if (!_this._hasCallScrollToLowerInRange) {
+          _this._hasDataChangedSinceEndReached = false;
+          _this._hasCallScrollToLowerInRange = true;
+          _this._sentEndForContentLength = _this._scrollMetrics.contentLength;
+          typeof onScrollToLower === 'function' && onScrollToLower({
+            type: 'scrolltolower',
+            direction: scrollX ? 'right' : 'bottom',
+            // distanceFromEnd,
+            origin: e
+          });
+        }
+      } else {
+        _this._hasCallScrollToLowerInRange = false;
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_onContentSizeChange", function (width, height) {
+      _this._scrollMetrics.contentLength = _this._selectLength({
+        height: height,
+        width: width
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_onScrollEndDrag", function (e) {
+      var velocity = e.nativeEvent.velocity;
+
+      if (velocity) {
+        _this._scrollMetrics.velocity = _this._selectOffset(velocity);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_onMomentumScrollEnd", function () {
+      _this._scrollMetrics.velocity = 0;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_onLayout", function (e) {
+      _this._scrollMetrics.visibleLength = _this._selectLength(e.nativeEvent.layout);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_onScroll", function (e) {
+      var onScroll = _this.props.onScroll;
+      var scrollLeft = e.nativeEvent.contentOffset.x;
+      var scrollTop = e.nativeEvent.contentOffset.y;
+      var scrollHeight = e.nativeEvent.contentSize.height;
+      var scrollWidth = e.nativeEvent.contentSize.width;
+      typeof onScroll === 'function' && onScroll({
+        type: 'scroll',
+        scrollLeft: scrollLeft,
+        scrollTop: scrollTop,
+        scrollHeight: scrollHeight,
+        scrollWidth: scrollWidth,
+        deltaX: scrollLeft - _this._scrollMetrics.offsetX,
+        deltaY: scrollTop - _this._scrollMetrics.offsetY,
+        origin: e
+      });
+      var timestamp = e.timeStamp;
+
+      var visibleLength = _this._selectLength(e.nativeEvent.layoutMeasurement);
+
+      var contentLength = _this._selectLength(e.nativeEvent.contentSize);
+
+      var offset = _this._selectOffset(e.nativeEvent.contentOffset);
+
+      var dt = Math.max(1, timestamp - _this._scrollMetrics.timestamp);
+      var dOffset = offset - _this._scrollMetrics.offset;
+      _this._scrollMetrics = {
+        contentLength: contentLength,
+        dt: dt,
+        dOffset: dOffset,
+        offset: offset,
+        offsetX: scrollLeft,
+        offsetY: scrollTop,
+        timestamp: timestamp,
+        velocity: dOffset / dt,
+        visibleLength: visibleLength
+      };
+
+      _this._maybeCallOnStartReached(e);
+
+      _this._maybeCallOnEndReached(e);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "scrollToOffset", function () {
+      var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var node = _this.$scrollView.current;
+
+      if (node) {
+        node.scrollTo({
+          x: x,
+          y: y,
+          animated: !!_this.props.scrollWithAnimation
+        });
+      }
+    });
+
+    return _this;
+  }
+
+  _createClass(_ScrollView, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+
+      if (this.state.snapScrollTop || this.state.snapScrollLeft) {
+        this._initialScrollIndexTimeout = setTimeout(function () {
+          _this2.scrollToOffset(_this2.state.snapScrollLeft, _this2.state.snapScrollTop);
+        }, 0);
+      }
+    }
+  }, {
+    key: "getSnapshotBeforeUpdate",
+    value: function getSnapshotBeforeUpdate(prevProps, prevState) {
+      if (prevProps.scrollTop !== undefined) {
+        return this._scrollMetrics.offsetY !== this.state.snapScrollTop || this._scrollMetrics.offsetX !== this.state.snapScrollLeft;
+      }
+
+      return prevState.snapScrollTop !== this.state.snapScrollTop || prevState.snapScrollLeft !== this.state.snapScrollLeft;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState, snapshot) {
+      if (snapshot) {
+        this.scrollToOffset(this.state.snapScrollLeft, this.state.snapScrollTop);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._initialScrollIndexTimeout && clearTimeout(this._initialScrollIndexTimeout);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props3 = this.props,
+          children = _this$props3.children,
+          style = _this$props3.style,
+          scrollX = _this$props3.scrollX;
+      var flattenStyle = StyleSheet.flatten(style);
+      var wrapperStyle = omit(flattenStyle, ['alignItems', 'justifyContent']);
+      var _contentContainerStyle = {};
+
+      if (flattenStyle) {
+        flattenStyle.alignItems && (_contentContainerStyle.alignItems = flattenStyle.alignItems);
+        flattenStyle.justifyContent && (_contentContainerStyle.justifyContent = flattenStyle.justifyContent);
+      }
+
+      var scrollElementProps = _objectSpread(_objectSpread({
+        horizontal: scrollX,
+        onContentSizeChange: this._onContentSizeChange,
+        onLayout: this._onLayout,
+        onScroll: this._onScroll,
+        onScrollEndDrag: this._onScrollEndDrag,
+        onMomentumScrollEnd: this._onMomentumScrollEnd,
+        scrollEventThrottle: this._scrollEventThrottle,
+        style: wrapperStyle,
+        contentContainerStyle: [_contentContainerStyle]
+      }, omit(this.props, [// props
+      'style', 'scrollX', 'upperThreshold', 'lowerThreshold', 'scrollTop', 'scrollLeft', 'scrollWithAnimation', 'onScrollToUpper', 'onScrollToLower', 'onScroll', 'contentContainerStyle', // SProps
+      'horizontal', 'onContentSizeChange', 'onLayout', 'onScroll', 'onScrollEndDrag', 'onMomentumScrollEnd', 'scrollEventThrottle', 'scrollsToTop', 'style', 'contentContainerStyle', 'data', 'renderItem', 'keyExtractor'])), {}, {
+        ref: this.$scrollView
+      });
+
+      return /*#__PURE__*/React.createElement(ScrollView, scrollElementProps, children);
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, state) {
+      return state.snapScrollTop !== props.scrollTop || state.snapScrollLeft !== props.scrollLeft ? {
+        snapScrollTop: props.scrollTop || 0,
+        snapScrollLeft: props.scrollLeft || 0
+      } : null;
+    }
+  }]);
+
+  return _ScrollView;
+}(React.Component);
+
+_defineProperty(_ScrollView, "defaultProps", {
+  upperThreshold: 50,
+  lowerThreshold: 50,
+  scrollX: false
+});
+
+export default _ScrollView;

package/lib/ScrollView/ScrollView.wechat.js

@@ -1,16 +1,16 @@
-import { ScrollView as _ScrollView } from "@ray-core/wechat/esm/hostComponents/ScrollView/index";
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 var _excluded = ["style"];
 import * as React from 'react';
 import { inlineStyle } from '@ray-js/framework-shared';
+import { ScrollView as RemaxScrollView } from '@ray-core/wechat';
 import { defaultScrollViewProps } from './props';
 
 var ScrollView = function (props) {
   var style = props.style,
       restProps = _objectWithoutProperties(props, _excluded);
 
-  return /*#__PURE__*/React.createElement(_ScrollView, _extends({
+  return /*#__PURE__*/React.createElement(RemaxScrollView, _extends({
     style: inlineStyle(style),
     enhanced: true
   }, restProps));

package/lib/Slider/Slider.native.js

@@ -0,0 +1,114 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _excluded = ["min", "max", "step", "backgroundColor", "activeColor", "blockSize", "blockColor", "onChange", "onChanging", "showValue"];
+import React from 'react';
+import { View, Text } from 'react-native';
+import SliderBase from 'tuya-panel-slider/lib/slider';
+import { sliderDefault } from './props';
+
+var Slider = /*#__PURE__*/function (_React$Component) {
+  _inherits(Slider, _React$Component);
+
+  var _super = _createSuper(Slider);
+
+  function Slider(props) {
+    var _this;
+
+    _classCallCheck(this, Slider);
+
+    _this = _super.call(this, props);
+    _this.state = {
+      currentValue: props.value
+    };
+    return _this;
+  }
+
+  _createClass(Slider, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (prevProps.value !== this.props.value) {
+        this.setState({
+          currentValue: this.props.value
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props = this.props,
+          min = _this$props.min,
+          max = _this$props.max,
+          step = _this$props.step,
+          backgroundColor = _this$props.backgroundColor,
+          activeColor = _this$props.activeColor,
+          blockSize = _this$props.blockSize,
+          blockColor = _this$props.blockColor,
+          onChange = _this$props.onChange,
+          onChanging = _this$props.onChanging,
+          showValue = _this$props.showValue,
+          rest = _objectWithoutProperties(_this$props, _excluded);
+
+      return /*#__PURE__*/React.createElement(View, {
+        style: {
+          flexDirection: 'row',
+          alignItems: 'center'
+        }
+      }, /*#__PURE__*/React.createElement(SliderBase, _extends({
+        trackStyle: {
+          width: 312,
+          height: 4
+        }
+      }, rest, {
+        minimumValue: min,
+        maximumValue: max,
+        stepValue: step,
+        maximumTrackTintColor: backgroundColor,
+        minimumTrackTintColor: activeColor,
+        thumbTouchSize: {
+          width: blockSize,
+          height: blockSize
+        },
+        thumbTintColor: blockColor,
+        onSlidingComplete: function onSlidingComplete(value) {
+          _this2.setState({
+            currentValue: value
+          });
+
+          typeof onChange === 'function' && onChange({
+            type: 'change',
+            value: value,
+            origin: undefined
+          });
+        },
+        onValueChange: function onValueChange(value) {
+          _this2.setState({
+            currentValue: value
+          });
+
+          typeof onChanging === 'function' && onChanging({
+            type: 'changing',
+            value: value,
+            origin: undefined
+          });
+        }
+      })), showValue && /*#__PURE__*/React.createElement(Text, {
+        style: {
+          marginLeft: 15
+        }
+      }, this.state.currentValue));
+    }
+  }]);
+
+  return Slider;
+}(React.Component);
+
+_defineProperty(Slider, "defaultProps", sliderDefault);
+
+export { Slider as default };

package/lib/Slider/Slider.wechat.js

@@ -1,9 +1,9 @@
-import { Slider as _Slider } from "@ray-core/wechat/esm/hostComponents/Slider/index";
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 var _excluded = ["id", "style", "className", "children", "onChange", "onChanging", "activeColor"];
 import * as React from 'react';
 import { inlineStyle } from '@ray-js/framework-shared';
+import { Slider as RemaxSlider } from '@ray-core/wechat';
 
 var Slider = function (props) {
   var id = props.id,
@@ -15,7 +15,7 @@ var Slider = function (props) {
       activeColor = props.activeColor,
       restProps = _objectWithoutProperties(props, _excluded);
 
-  return /*#__PURE__*/React.createElement(_Slider, _extends({
+  return /*#__PURE__*/React.createElement(RemaxSlider, _extends({
     id: id,
     style: inlineStyle(style),
     onChange: function handleChange(e) {

package/lib/Swiper/Swiper.native.js

@@ -0,0 +1,68 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["style", "vertical", "circular", "autoplay", "current", "dotActiveColor", "dotColor", "dots", "interval", "dataSource", "renderItem", "onAfterChange", "onchange"],
+    _excluded2 = ["width", "height"];
+import "core-js/modules/es.array.map.js";
+import React from 'react';
+import OriginSwiper from 'react-native-swiper';
+import { defaultSwiperProps } from './props';
+
+var Swiper = function (props) {
+  var style = props.style,
+      vertical = props.vertical,
+      circular = props.circular,
+      autoplay = props.autoplay,
+      current = props.current,
+      dotActiveColor = props.dotActiveColor,
+      dotColor = props.dotColor,
+      dots = props.dots,
+      interval = props.interval,
+      dataSource = props.dataSource,
+      renderItem = props.renderItem,
+      onAfterChange = props.onAfterChange,
+      onchange = props.onchange,
+      rest = _objectWithoutProperties(props, _excluded);
+
+  var width = style.width,
+      height = style.height,
+      restStyle = _objectWithoutProperties(style, _excluded2);
+
+  if (!dataSource || dataSource.length === 0 || !renderItem) return null;
+  return /*#__PURE__*/React.createElement(OriginSwiper, _extends({}, rest, {
+    style: _objectSpread({}, restStyle),
+    width: width,
+    height: height,
+    showsButtons: false,
+    horizontal: !vertical,
+    loop: circular,
+    autoplay: autoplay,
+    index: current,
+    activeDotColor: dotActiveColor,
+    dotColor: dotColor,
+    showsPagination: dots,
+    autoplayTimeout: interval / 1000,
+    onIndexChanged: function _handleIndexChange(index) {
+      typeof onchange === 'function' && onchange({
+        type: 'change',
+        current: index,
+        origin: null
+      });
+    },
+    onMomentumScrollEnd: function _handleIndexChangeEnd(event, state) {
+      var index = state.index;
+      typeof onAfterChange === 'function' && onAfterChange({
+        type: 'afterchange',
+        current: index,
+        origin: null
+      });
+    }
+  }), dataSource.map(function (item, index) {
+    if (renderItem) {
+      return renderItem(item, index);
+    }
+  }));
+};
+
+Swiper.defaultProps = defaultSwiperProps;
+export default Swiper;

package/lib/Swiper/Swiper.wechat.js

@@ -1,6 +1,4 @@
-import { Swiper as _Swiper } from "@ray-core/wechat/esm/hostComponents/Swiper/index";
 import _extends from "@babel/runtime/helpers/esm/extends";
-import { SwiperItem as _SwiperItem } from "@ray-core/wechat/esm/hostComponents/SwiperItem/index";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 var _excluded = ["id", "style", "className", "current", "dataSource", "onAfterChange", "onChange", "renderItem", "children"];
@@ -8,6 +6,7 @@ import "core-js/modules/es.array.map.js";
 import clsx from 'clsx';
 import * as React from 'react';
 import { inlineStyle } from '@ray-js/framework-shared';
+import { Swiper as RemaxSwiper, SwiperItem as RemaxSwiperItem } from '@ray-core/wechat';
 import { propsAlias } from '../core';
 import { SwiperPropsAlias, defaultSwiperProps } from './props';
 
@@ -35,7 +34,7 @@ function Swiper(props) {
       bufferCurrent.current = current;
     }
   }, [current]);
-  return /*#__PURE__*/React.createElement(_Swiper, _extends({
+  return /*#__PURE__*/React.createElement(RemaxSwiper, _extends({
     id: id,
     style: inlineStyle(style),
     className: clsx('ray-swiper', className),
@@ -50,7 +49,7 @@ function Swiper(props) {
     return children;
   }() || function () {
     return dataSource.map(function (item, index) {
-      return /*#__PURE__*/React.createElement(_SwiperItem, {
+      return /*#__PURE__*/React.createElement(RemaxSwiperItem, {
         key: index
       }, renderItem(item, index));
     });

package/lib/SwiperItem/SwiperItem.js

@@ -1 +1,14 @@
-var _interopRequireDefault=require("@babel/runtime/helpers/interopRequireDefault");Object.defineProperty(exports,"__esModule",{value:true});exports.default=void 0;var _extends2=_interopRequireDefault(require("@babel/runtime/helpers/extends"));var React=_interopRequireWildcard(require("react"));var _handleProps=_interopRequireDefault(require("../utils/handleProps"));var _this=this,_jsxFileName="/drone/src/packages/components/src/SwiperItem/SwiperItem.tsx";function _getRequireWildcardCache(nodeInterop){if(typeof WeakMap!=="function")return null;var cacheBabelInterop=new WeakMap();var cacheNodeInterop=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(nodeInterop){return nodeInterop?cacheNodeInterop:cacheBabelInterop;})(nodeInterop);}function _interopRequireWildcard(obj,nodeInterop){if(!nodeInterop&&obj&&obj.__esModule){return obj;}if(obj===null||typeof obj!=="object"&&typeof obj!=="function"){return{default:obj};}var cache=_getRequireWildcardCache(nodeInterop);if(cache&&cache.has(obj)){return cache.get(obj);}var newObj={};var hasPropertyDescriptor=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var key in obj){if(key!=="default"&&Object.prototype.hasOwnProperty.call(obj,key)){var desc=hasPropertyDescriptor?Object.getOwnPropertyDescriptor(obj,key):null;if(desc&&(desc.get||desc.set)){Object.defineProperty(newObj,key,desc);}else{newObj[key]=obj[key];}}}newObj.default=obj;if(cache){cache.set(obj,newObj);}return newObj;}var SwiperItem=function(props){var children=props.children;return React.createElement("v-swiper-item",(0,_extends2.default)({},(0,_handleProps.default)(props),{__self:_this,__source:{fileName:_jsxFileName,lineNumber:9,columnNumber:5}}),children);};SwiperItem.displayName='SwiperItem';var _default=SwiperItem;exports.default=_default;
+import * as React from 'react';
+import handleProps from '../utils/handleProps';
+
+var SwiperItem = function (props) {
+  var children = props.children;
+  return (
+    /*#__PURE__*/
+    // @ts-ignore
+    React.createElement("v-swiper-item", handleProps(props), children)
+  );
+};
+
+SwiperItem.displayName = 'SwiperItem';
+export default SwiperItem;

package/lib/Switch/Switch.native.js

@@ -0,0 +1,128 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _excluded = ["style", "color", "disabled", "type"];
+import "core-js/modules/es.array.concat.js";
+import React from 'react';
+import Switch from 'tuya-panel-switch/lib/switch';
+import Checkbox from '../Checkbox';
+import { defaultSwitchProps } from './props';
+
+var _Switch = /*#__PURE__*/function (_React$Component) {
+  _inherits(_Switch, _React$Component);
+
+  var _super = _createSuper(_Switch);
+
+  function _Switch() {
+    var _this;
+
+    _classCallCheck(this, _Switch);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "$touchable", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      checked: !!_this.props.checked
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_simulateNativePress", function (evt) {
+      var type = _this.props.type;
+
+      if (type === 'checkbox') {
+        var node = _this.$touchable.current;
+        node && node._simulateNativePress(evt);
+      } else {
+        _this.setState({
+          checked: !_this.state.checked
+        });
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onCheckedChange", function (event) {
+      var checked = event.checked;
+      var onChange = _this.props.onChange;
+      typeof onChange === 'function' && onChange({
+        type: 'change',
+        value: checked
+      });
+
+      _this.setState({
+        checked: checked
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onSwitchChange", function (isChecked) {
+      var onChange = _this.props.onChange;
+      typeof onChange === 'function' && onChange({
+        type: 'change',
+        value: isChecked
+      });
+
+      _this.setState({
+        checked: isChecked
+      });
+    });
+
+    return _this;
+  }
+
+  _createClass(_Switch, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          style = _this$props.style,
+          color = _this$props.color,
+          disabled = _this$props.disabled,
+          type = _this$props.type,
+          rest = _objectWithoutProperties(_this$props, _excluded);
+
+      var checked = this.state.checked;
+
+      if (type === 'checkbox') {
+        return /*#__PURE__*/React.createElement(Checkbox, {
+          checked: this.state.checked,
+          style: style,
+          disabled: disabled,
+          onChange: this.onCheckedChange,
+          ref: this.$touchable
+        });
+      }
+
+      return /*#__PURE__*/React.createElement(Switch, _extends({
+        size: {
+          width: 50,
+          height: 30,
+          activeSize: 26,
+          margin: 2
+        },
+        thumbTintColor: "#FFFFFF",
+        tintColor: 'rgba(0,0,0,0.12)'
+      }, rest, {
+        value: checked,
+        onValueChange: this.onSwitchChange,
+        style: style,
+        onTintColor: color,
+        disabled: disabled,
+        ref: this.$touchable
+      }));
+    }
+  }]);
+
+  return _Switch;
+}(React.Component);
+
+_defineProperty(_Switch, "displayName", 'Switch');
+
+_defineProperty(_Switch, "defaultProps", defaultSwitchProps);
+
+export { _Switch as default };