text: function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
    var c = arguments.length,
        r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
        d;
    if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
      if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    }
    return c > 3 && r && Object.defineProperty(target, key, r), r;
  };
  
  import * as React from 'react';
  import classNames from 'classnames';
  import omit from 'omit.js';
  import ResizeObserver from 'rc-resize-observer';
  import { ConfigConsumer } from '../config-provider';
  import { throttleByAnimationFrameDecorator } from '../_util/throttleByAnimationFrame';
  import { addObserveTarget, removeObserveTarget, getTargetRect, getFixedTop, getFixedBottom } from './utils';
  
  function getDefaultTarget() {
    return typeof window !== 'undefined' ? window : null;
  }
  
  var AffixStatus;
  
  (function (AffixStatus) {
    AffixStatus[AffixStatus["None"] = 0] = "None";
    AffixStatus[AffixStatus["Prepare"] = 1] = "Prepare";
  })(AffixStatus || (AffixStatus = {}));
  
  var Affix = /*#__PURE__*/function (_React$Component) {
    _inherits(Affix, _React$Component);
  
    var _super = _createSuper(Affix);
  
    function Affix() {
      var _this;
  
      _classCallCheck(this, Affix);
  
      _this = _super.apply(this, arguments);
      _this.state = {
        status: AffixStatus.None,
        lastAffix: false,
        prevTarget: null
      };
  
      _this.getOffsetTop = function () {
        var offsetBottom = _this.props.offsetBottom;
        var offsetTop = _this.props.offsetTop;
  
        if (offsetBottom === undefined && offsetTop === undefined) {
          offsetTop = 0;
        }
  
        return offsetTop;
      };
  
      _this.getOffsetBottom = function () {
        return _this.props.offsetBottom;
      };
  
      _this.savePlaceholderNode = function (node) {
        _this.placeholderNode = node;
      };
  
      _this.saveFixedNode = function (node) {
        _this.fixedNode = node;
      }; // =================== Measure ===================
  
  
      _this.measure = function () {
        var _this$state = _this.state,
            status = _this$state.status,
            lastAffix = _this$state.lastAffix;
        var _this$props = _this.props,
            target = _this$props.target,
            onChange = _this$props.onChange;
  
        if (status !== AffixStatus.Prepare || !_this.fixedNode || !_this.placeholderNode || !target) {
          return;
        }
  
        var offsetTop = _this.getOffsetTop();
  
        var offsetBottom = _this.getOffsetBottom();
  
        var targetNode = target();
  
        if (!targetNode) {
          return;
        }
  
        var newState = {
          status: AffixStatus.None
        };
        var targetRect = getTargetRect(targetNode);
        var placeholderReact = getTargetRect(_this.placeholderNode);
        var fixedTop = getFixedTop(placeholderReact, targetRect, offsetTop);
        var fixedBottom = getFixedBottom(placeholderReact, targetRect, offsetBottom);
  
        if (fixedTop !== undefined) {
          newState.affixStyle = {
            position: 'fixed',
            top: fixedTop,
            width: placeholderReact.width,
            height: placeholderReact.height
          };
          newState.placeholderStyle = {
            width: placeholderReact.width,
            height: placeholderReact.height
          };
        } else if (fixedBottom !== undefined) {
          newState.affixStyle = {
            position: 'fixed',
            bottom: fixedBottom,
            width: placeholderReact.width,
            height: placeholderReact.height
          };
          newState.placeholderStyle = {
            width: placeholderReact.width,
            height: placeholderReact.height
          };
        }
  
        newState.lastAffix = !!newState.affixStyle;
  
        if (onChange && lastAffix !== newState.lastAffix) {
          onChange(newState.lastAffix);
        }
  
        _this.setState(newState);
      }; // @ts-ignore TS6133
  
  
      _this.prepareMeasure = function () {
        // event param is used before. Keep compatible ts define here.
        _this.setState({
          status: AffixStatus.Prepare,
          affixStyle: undefined,
          placeholderStyle: undefined
        }); // Test if `updatePosition` called
  
  
        if (process.env.NODE_ENV === 'test') {
          var onTestUpdatePosition = _this.props.onTestUpdatePosition;
  
          if (onTestUpdatePosition) {
            onTestUpdatePosition();
          }
        }
      }; // =================== Render ===================
  
  
      _this.renderAffix = function (_ref) {
        var getPrefixCls = _ref.getPrefixCls;
        var _this$state2 = _this.state,
            affixStyle = _this$state2.affixStyle,
            placeholderStyle = _this$state2.placeholderStyle;
        var _this$props2 = _this.props,
            prefixCls = _this$props2.prefixCls,
            children = _this$props2.children;
        var className = classNames(_defineProperty({}, getPrefixCls('affix', prefixCls), affixStyle));
        var props = omit(_this.props, ['prefixCls', 'offsetTop', 'offsetBottom', 'target', 'onChange']); // Omit this since `onTestUpdatePosition` only works on test.
  
        if (process.env.NODE_ENV === 'test') {
          props = omit(props, ['onTestUpdatePosition']);
        }
  
        return /*#__PURE__*/React.createElement(ResizeObserver, {
          onResize: function onResize() {
            _this.updatePosition();
          }
        }, /*#__PURE__*/React.createElement("div", _extends({}, props, {
          ref: _this.savePlaceholderNode
        }), affixStyle && /*#__PURE__*/React.createElement("div", {
          style: placeholderStyle,
          "aria-hidden": "true"
        }), /*#__PURE__*/React.createElement("div", {
          className: className,
          ref: _this.saveFixedNode,
          style: affixStyle
        }, /*#__PURE__*/React.createElement(ResizeObserver, {
          onResize: function onResize() {
            _this.updatePosition();
          }
        }, children))));
      };
  
      return _this;
    } // Event handler
  
  
    _createClass(Affix, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;
  
        var target = this.props.target;
  
        if (target) {
          // [Legacy] Wait for parent component ref has its value.
          // We should use target as directly element instead of function which makes element check hard.
          this.timeout = setTimeout(function () {
            addObserveTarget(target(), _this2); // Mock Event object.
  
            _this2.updatePosition();
          });
        }
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps) {
        var prevTarget = this.state.prevTarget;
        var target = this.props.target;
        var newTarget = null;
  
        if (target) {
          newTarget = target() || null;
        }
  
        if (prevTarget !== newTarget) {
          removeObserveTarget(this);
  
          if (newTarget) {
            addObserveTarget(newTarget, this); // Mock Event object.
  
            this.updatePosition();
          }
  
          this.setState({
            prevTarget: newTarget
          });
        }
  
        if (prevProps.offsetTop !== this.props.offsetTop || prevProps.offsetBottom !== this.props.offsetBottom) {
          this.updatePosition();
        }
  
        this.measure();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        clearTimeout(this.timeout);
        removeObserveTarget(this);
        this.updatePosition.cancel(); // https://github.com/ant-design/ant-design/issues/22683
  
        this.lazyUpdatePosition.cancel();
      } // Handle realign logic
  
    }, {
      key: "updatePosition",
      value: function updatePosition() {
        this.prepareMeasure();
      }
    }, {
      key: "lazyUpdatePosition",
      value: function lazyUpdatePosition() {
        var target = this.props.target;
        var affixStyle = this.state.affixStyle; // Check position change before measure to make Safari smooth
  
        if (target && affixStyle) {
          var offsetTop = this.getOffsetTop();
          var offsetBottom = this.getOffsetBottom();
          var targetNode = target();
  
          if (targetNode && this.placeholderNode) {
            var targetRect = getTargetRect(targetNode);
            var placeholderReact = getTargetRect(this.placeholderNode);
            var fixedTop = getFixedTop(placeholderReact, targetRect, offsetTop);
            var fixedBottom = getFixedBottom(placeholderReact, targetRect, offsetBottom);
  
            if (fixedTop !== undefined && affixStyle.top === fixedTop || fixedBottom !== undefined && affixStyle.bottom === fixedBottom) {
              return;
            }
          }
        } // Directly call prepare measure since it's already throttled.
  
  
        this.prepareMeasure();
      }
    }, {
      key: "render",
      value: function render() {
        return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderAffix);
      }
    }]);
  
    return Affix;
  }(React.Component);
  
  Affix.defaultProps = {
    target: getDefaultTarget
  };
  
  __decorate([throttleByAnimationFrameDecorator()], Affix.prototype, "updatePosition", null);
  
  __decorate([throttleByAnimationFrameDecorator()], Affix.prototype, "lazyUpdatePosition", null);
  
  export default Affix;