@quintype/components 3.8.8-only-react-v19.4 → 3.8.9-razorpay-log.0

package/dist/es/components/story-elements/youtube.js

@@ -1,13 +1,19 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/inherits";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
 import getYouTubeID from 'get-youtube-id';
 import { bool, func, object } from 'prop-types';
 import React from 'react';
@@ -15,20 +21,26 @@ import { disconnectObserver, getQliticsSchema, initiateNewObserver } from '../..
 import { WithLazy } from '../with-lazy';
 var YouTube = null;
 var loaderPromise = null;
+
 function loadLibrary() {
   if (loaderPromise === null) {
-    loaderPromise = import(/* webpackChunkName: "qtc-react-youtube" */'react-youtube').then(function (YT) {
+    loaderPromise = import(
+    /* webpackChunkName: "qtc-react-youtube" */
+    'react-youtube').then(function (YT) {
       YouTube = YT["default"];
     })["catch"](function (err) {
       console.log('Failed to load react-youtube', err);
       return Promise.reject();
     });
   }
+
   return loaderPromise;
 }
+
 function isLibraryLoaded() {
   return YouTube !== null;
 }
+
 function getYoutubeButton(onClick) {
   return /*#__PURE__*/React.createElement("button", {
     onClick: onClick,
@@ -48,88 +60,118 @@ function getYoutubeButton(onClick) {
     fill: "white"
   })));
 }
+
 var CustomStoryElementYoutube = /*#__PURE__*/function (_React$Component) {
+  _inherits(CustomStoryElementYoutube, _React$Component);
+
+  var _super = /*#__PURE__*/_createSuper(CustomStoryElementYoutube);
+
   function CustomStoryElementYoutube(props) {
     var _this;
+
     _classCallCheck(this, CustomStoryElementYoutube);
-    _this = _callSuper(this, CustomStoryElementYoutube, [props]);
-    _defineProperty(_this, "initiateObserver", function (targetElement) {
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "initiateObserver", function (targetElement) {
       _this.removeObserverIfExists();
+
       _this.intersectionObserver = new IntersectionObserver(_this.intersectionCallback, {
         threshold: 0.75
       });
+
       _this.intersectionObserver.observe(targetElement);
     });
-    _defineProperty(_this, "triggerQlitics", function (action) {
+
+    _defineProperty(_assertThisInitialized(_this), "triggerQlitics", function (action) {
       if (_this.props.disableAnalytics === true) return false;
       var _this$props = _this.props,
-        _this$props$story = _this$props.story,
-        story = _this$props$story === void 0 ? {} : _this$props$story,
-        _this$props$card = _this$props.card,
-        card = _this$props$card === void 0 ? {} : _this$props$card,
-        _this$props$element = _this$props.element,
-        element = _this$props$element === void 0 ? {} : _this$props$element;
+          _this$props$story = _this$props.story,
+          story = _this$props$story === void 0 ? {} : _this$props$story,
+          _this$props$card = _this$props.card,
+          card = _this$props$card === void 0 ? {} : _this$props$card,
+          _this$props$element = _this$props.element,
+          element = _this$props$element === void 0 ? {} : _this$props$element;
+
       var qliticsData = _objectSpread(_objectSpread({}, getQliticsSchema(story, card, element)), {
         'story-element-action': action
       });
+
       if (global.qlitics) {
         global.qlitics('track', 'story-element-action', qliticsData);
       } else {
         global.qlitics = global.qlitics || function () {
           (qlitics.q = qlitics.q || []).push(arguments);
         };
+
         qlitics.qlitics.q.push('track', 'story-element-action', qliticsData);
       }
     });
-    _defineProperty(_this, "onPlayCallback", function (event) {
+
+    _defineProperty(_assertThisInitialized(_this), "onPlayCallback", function (event) {
       _this.triggerQlitics('play');
+
       _this.props.onPlay === 'function' && _this.props.onPlay(event);
       _this.videoRef.current = event.target;
+
       var targetElement = _this.videoRef.current.getIframe();
+
       if (_this.intersectionObserver) {
         _this.intersectionObserver.observe(targetElement);
       } else {
         _this.intersectionObserver = initiateNewObserver(targetElement, _this.intersectionCallback);
       }
     });
-    _defineProperty(_this, "intersectionCallback", function (entries) {
+
+    _defineProperty(_assertThisInitialized(_this), "intersectionCallback", function (entries) {
       var videoInVewPort = entries === null || entries === void 0 ? void 0 : entries[0].isIntersecting;
       var player = _this.videoRef.current;
       if (videoInVewPort) player.playVideo();else {
         _this.videoPausedByObserver.current = true; // before the below line fires the pause event we set the videoPausedByObserver Ref to true, this lets the pause events callback to know that the video is not click-paused by the user but paused by the intersection observer
+
         player.pauseVideo();
       }
     });
-    _defineProperty(_this, "onPauseCallback", function (event) {
+
+    _defineProperty(_assertThisInitialized(_this), "onPauseCallback", function (event) {
       _this.triggerQlitics('pause');
+
       _this.props.onPause === 'function' && _this.props.onPause(event);
       var videoPausedByObserver = _this.videoPausedByObserver.current;
+
       if (videoPausedByObserver) {
         _this.videoPausedByObserver.current = false; // This is a clean up to set videoPausedByObserver back to false
       } else {
         disconnectObserver(_this.intersectionObserver);
       }
     });
-    _defineProperty(_this, "onEndCallback", function (event) {
+
+    _defineProperty(_assertThisInitialized(_this), "onEndCallback", function (event) {
       _this.triggerQlitics('end');
+
       _this.props.onEnd === 'function' && _this.props.onEnd(event);
     });
-    _defineProperty(_this, "triggerIframe", function () {
+
+    _defineProperty(_assertThisInitialized(_this), "triggerIframe", function () {
       _this._isMounted = true;
       loadLibrary().then(function () {
         return _this._isMounted && _this.forceUpdate();
       });
     });
-    _defineProperty(_this, "onPlayerReady", function (event) {
+
+    _defineProperty(_assertThisInitialized(_this), "onPlayerReady", function (event) {
       event.target.setVolume(100);
       event.target.playVideo();
     });
-    _defineProperty(_this, "renderVideo", function () {
+
+    _defineProperty(_assertThisInitialized(_this), "renderVideo", function () {
       _this.triggerIframe();
+
       _this.setState({
         showVideo: true
       });
     });
+
     _this.state = {
       showVideo: false
     };
@@ -140,10 +182,11 @@ var CustomStoryElementYoutube = /*#__PURE__*/function (_React$Component) {
     };
     _this.videoRef = /*#__PURE__*/React.createRef();
     _this.videoPausedByObserver = /*#__PURE__*/React.createRef(); // To check if the video is not click paused by user but paused by intersection observer, Its implemented this way because we cannot capture the click-pause event as videos are playing in iframe
+
     return _this;
   }
-  _inherits(CustomStoryElementYoutube, _React$Component);
-  return _createClass(CustomStoryElementYoutube, [{
+
+  _createClass(CustomStoryElementYoutube, [{
     key: "componentDidMount",
     value: function componentDidMount() {
       if (!this.props.loadIframeOnClick) {
@@ -160,6 +203,7 @@ var CustomStoryElementYoutube = /*#__PURE__*/function (_React$Component) {
     key: "render",
     value: function render() {
       var _this2 = this;
+
       var youtubeIframe = function youtubeIframe() {
         return /*#__PURE__*/React.createElement(YouTube, {
           videoId: getYouTubeID(_this2.props.element.url),
@@ -171,6 +215,7 @@ var CustomStoryElementYoutube = /*#__PURE__*/function (_React$Component) {
           ref: _this2.videoRef
         });
       };
+
       if (this.props.loadIframeOnClick) {
         return /*#__PURE__*/React.createElement("div", {
           className: "thumbnail-wrapper"
@@ -187,7 +232,10 @@ var CustomStoryElementYoutube = /*#__PURE__*/function (_React$Component) {
       } else return /*#__PURE__*/React.createElement("div", null);
     }
   }]);
+
+  return CustomStoryElementYoutube;
 }(React.Component);
+
 var StoryElementYoutube = function StoryElementYoutube(props) {
   return /*#__PURE__*/React.createElement(WithLazy, {
     margin: "0px"
@@ -195,4 +243,5 @@ var StoryElementYoutube = function StoryElementYoutube(props) {
     return /*#__PURE__*/React.createElement(CustomStoryElementYoutube, props);
   });
 };
+
 export default StoryElementYoutube;

package/dist/es/components/update-on-interval.js

@@ -1,15 +1,17 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/inherits";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
 import { any, func, number } from 'prop-types';
 import React from 'react';
-
 /**
  * This render props component willupdate it's children via props while executing data loaders sent as props to the component.
  *
@@ -37,19 +39,26 @@ import React from 'react';
  * @hideconstructor
  * @category Other
  */
+
 export var UpdateOnInterval = /*#__PURE__*/function (_React$Component) {
+  _inherits(UpdateOnInterval, _React$Component);
+
+  var _super = /*#__PURE__*/_createSuper(UpdateOnInterval);
+
   function UpdateOnInterval(props) {
     var _this;
+
     _classCallCheck(this, UpdateOnInterval);
-    _this = _callSuper(this, UpdateOnInterval, [props]);
+
+    _this = _super.call(this, props);
     _this.fetchIntervalIndex = -1;
     _this.state = {
       data: _this.props.initData
     };
     return _this;
   }
-  _inherits(UpdateOnInterval, _React$Component);
-  return _createClass(UpdateOnInterval, [{
+
+  _createClass(UpdateOnInterval, [{
     key: "componentDidMount",
     value: function componentDidMount() {
       this.registerInterval();
@@ -63,6 +72,7 @@ export var UpdateOnInterval = /*#__PURE__*/function (_React$Component) {
     key: "registerInterval",
     value: function registerInterval() {
       var _this2 = this;
+
       this.fetchIntervalIndex = setInterval(function () {
         return _this2.setData();
       }, this.props.interval);
@@ -75,37 +85,46 @@ export var UpdateOnInterval = /*#__PURE__*/function (_React$Component) {
   }, {
     key: "setData",
     value: function () {
-      var _setData = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var data, _t;
-        return _regeneratorRuntime.wrap(function (_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              if (!(typeof this.props.dataLoader === 'function')) {
-                _context.next = 2;
+      var _setData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var data;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(typeof this.props.dataLoader === 'function')) {
+                  _context.next = 6;
+                  break;
+                }
+
+                _context.next = 3;
+                return this.props.dataLoader();
+
+              case 3:
+                _context.t0 = _context.sent;
+                _context.next = 7;
                 break;
-              }
-              _context.next = 1;
-              return this.props.dataLoader();
-            case 1:
-              _t = _context.sent;
-              _context.next = 3;
-              break;
-            case 2:
-              _t = {};
-            case 3:
-              data = _t;
-              this.setState({
-                data: data
-              });
-            case 4:
-            case "end":
-              return _context.stop();
+
+              case 6:
+                _context.t0 = {};
+
+              case 7:
+                data = _context.t0;
+                this.setState({
+                  data: data
+                });
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
           }
         }, _callee, this);
       }));
+
       function setData() {
         return _setData.apply(this, arguments);
       }
+
       return setData;
     }()
   }, {
@@ -118,6 +137,8 @@ export var UpdateOnInterval = /*#__PURE__*/function (_React$Component) {
       });
     }
   }]);
+
+  return UpdateOnInterval;
 }(React.Component);
 UpdateOnInterval.defaultProps = {
   interval: 30000,

package/dist/es/components/with-client-side-only.js

@@ -1,6 +1,5 @@
 import { connect } from "react-redux";
 import { mapStateToProps, mapDispatchToProps } from './impl/client-side-only-impl';
-
 /**
  * This component calls the render prop with `clientSideRendered` = true if the client side is completely loaded, and false during SSR and initial bootup.
  *
@@ -16,11 +15,13 @@ import { mapStateToProps, mapDispatchToProps } from './impl/client-side-only-imp
  * @component
  * @category Other
  */
+
 export var WithClientSideOnly = /*#__PURE__*/connect(mapStateToProps, mapDispatchToProps)(WithClientSideOnlyBase);
+
 function WithClientSideOnlyBase(_ref) {
   var _ref$clientSideRender = _ref.clientSideRendered,
-    clientSideRendered = _ref$clientSideRender === void 0 ? false : _ref$clientSideRender,
-    children = _ref.children;
+      clientSideRendered = _ref$clientSideRender === void 0 ? false : _ref$clientSideRender,
+      children = _ref.children;
   return children({
     clientSideRendered: clientSideRendered
   });

package/dist/es/components/with-error.js

@@ -1,17 +1,20 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/inherits";
-function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
 import React from 'react';
+
 function defaultErrorFn(props) {
   return /*#__PURE__*/React.createElement("span", {
     className: "qt-error"
   });
 }
-
 /**
  * This function can be used to generate a wrapper component that implements `componentDidCatch()`.
  *
@@ -32,20 +35,28 @@ function defaultErrorFn(props) {
  * @category Other
  * @returns {Component} A component with errors caught
  */
+
+
 export function withError(clazz) {
   var errorFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultErrorFn;
   return /*#__PURE__*/function (_React$Component) {
+    _inherits(WithError, _React$Component);
+
+    var _super = _createSuper(WithError);
+
     function WithError(props) {
       var _this;
+
       _classCallCheck(this, WithError);
-      _this = _callSuper(this, WithError, [props]);
+
+      _this = _super.call(this, props);
       _this.state = {
         errored: false
       };
       return _this;
     }
-    _inherits(WithError, _React$Component);
-    return _createClass(WithError, [{
+
+    _createClass(WithError, [{
       key: "componentDidCatch",
       value: function componentDidCatch(e) {
         console && e && console.log("Caught Exception: ".concat(e.message || e));
@@ -72,5 +83,7 @@ export function withError(clazz) {
         }
       }
     }]);
+
+    return WithError;
   }(React.Component);
 }

package/dist/es/components/with-host-url.js

@@ -1,31 +1,34 @@
 import { func, string } from "prop-types";
 import { connect } from "react-redux";
+
 function WithHostUrlBase(_ref) {
   var children = _ref.children,
-    primaryHostUrl = _ref.primaryHostUrl,
-    currentHostUrl = _ref.currentHostUrl;
+      primaryHostUrl = _ref.primaryHostUrl,
+      currentHostUrl = _ref.currentHostUrl;
   return children({
     primaryHostUrl: primaryHostUrl,
     currentHostUrl: currentHostUrl
   });
 }
+
 WithHostUrlBase.propTypes = {
   children: func.isRequired,
   primaryHostUrl: string,
   currentHostUrl: string
 };
+
 function mapStateToProps(_ref2) {
   var _ref2$qt = _ref2.qt,
-    qt = _ref2$qt === void 0 ? {} : _ref2$qt;
+      qt = _ref2$qt === void 0 ? {} : _ref2$qt;
   return {
     primaryHostUrl: qt.primaryHostUrl,
     currentHostUrl: qt.currentHostUrl
   };
 }
+
 function mapDispatchToProps(dispatch) {
   return {};
 }
-
 /**
  * This component can be used to get access to the `currentHostUrl` and `primaryHostUrl`, as configured within the editor.
  *
@@ -43,4 +46,6 @@ function mapDispatchToProps(dispatch) {
  * @component
  * @category Other
  */
+
+
 export var WithHostUrl = /*#__PURE__*/connect(mapStateToProps, mapDispatchToProps)(WithHostUrlBase);

package/dist/es/components/with-lazy.js

@@ -1,13 +1,15 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/inherits";
-function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
 import { func, number, string } from 'prop-types';
 import React from 'react';
-
 /**
  * This component can be used to load some DOM just before it scrolls into the screen. Currently, it does not support unloading. The `margin` prop is passed to `IntersectionObserver`.
  *
@@ -23,19 +25,26 @@ import React from 'react';
  * @hideconstructor
  * @category Other
  */
+
 export var WithLazy = /*#__PURE__*/function (_React$Component) {
+  _inherits(WithLazy, _React$Component);
+
+  var _super = /*#__PURE__*/_createSuper(WithLazy);
+
   function WithLazy(props) {
     var _this;
+
     _classCallCheck(this, WithLazy);
-    _this = _callSuper(this, WithLazy, [props]);
+
+    _this = _super.call(this, props);
     _this.state = {
       loaded: false
     };
     _this.observerRef = /*#__PURE__*/React.createRef();
     return _this;
   }
-  _inherits(WithLazy, _React$Component);
-  return _createClass(WithLazy, [{
+
+  _createClass(WithLazy, [{
     key: "render",
     value: function render() {
       if (this.state.loaded) {
@@ -53,6 +62,7 @@ export var WithLazy = /*#__PURE__*/function (_React$Component) {
     key: "componentDidMount",
     value: function componentDidMount() {
       var _this2 = this;
+
       this.observer = new global.IntersectionObserver(function (entries, observer) {
         return _this2.observerCallback(entries, observer);
       }, {
@@ -69,14 +79,18 @@ export var WithLazy = /*#__PURE__*/function (_React$Component) {
     key: "observerCallback",
     value: function observerCallback(entries, observer) {
       var _this3 = this;
+
       entries.forEach(function (entry) {
         if (entry.isIntersecting || entry.isIntersecting === undefined) {
           _this3.setState({
             loaded: true
           });
+
           observer.disconnect();
         }
       });
     }
   }]);
+
+  return WithLazy;
 }(React.Component);