react-vk/dist/react-vk.umd.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
  (global = global || self, factory(global.ReactVK = {}, global.React));
}(this, function (exports, React) { 'use strict';

  React = React && React.hasOwnProperty('default') ? React['default'] : React;

  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 _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 _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};
      var ownKeys = Object.keys(source);

      if (typeof Object.getOwnPropertySymbols === 'function') {
        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
        }));
      }

      ownKeys.forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    }

    return target;
  }

  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 _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  var VKContext = React.createContext();

  /* global document, window */
  var VKApi =
  /*#__PURE__*/
  function () {
    function VKApi(apiId) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, VKApi);

      this.apiId = apiId;
      this.options = options;
      this.promise = null;
      this.init();
    }

    _createClass(VKApi, [{
      key: "init",
      value: function init() {
        var apiId = this.apiId,
            _this$options = this.options,
            version = _this$options.version,
            onlyWidgets = _this$options.onlyWidgets;
        if (this.promise) return this.promise;
        this.promise = new Promise(function (resolve) {
          var baseUrl = "https://vk.com/js/api/openapi.js?".concat(version);

          window.vkAsyncInit = function () {
            if (apiId) {
              window.VK.init({
                apiId: apiId,
                onlyWidgets: onlyWidgets
              });
            }

            resolve(window.VK);
          };

          if (document.getElementById("vk-openapi")) {
            return;
          }

          var script = document.createElement("script");
          script.type = "text/javascript";
          script.id = "vk-openapi";
          script.src = baseUrl;
          script.async = true;
          document.head.appendChild(script);
        });
        return this.promise;
      }
    }]);

    return VKApi;
  }();

  var VKInstance = null;

  var VK =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(VK, _React$Component);

    function VK() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, VK);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(VK)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "_mounted", true);

      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "state", {
        vk: null
      });

      return _this;
    }

    _createClass(VK, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;

        var _this$props = this.props,
            onApiAvailable = _this$props.onApiAvailable,
            apiId = _this$props.apiId;

        if (typeof window !== "undefined" && window.document && window.document.createElement) {
          this.VKinit().then(function (vk) {
            onApiAvailable(vk);

            if (apiId) {
              vk.init({
                apiId: apiId
              });
            }

            if (_this2._mounted) _this2.setState({
              vk: vk
            });
          });
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this._mounted = false;
      }
    }, {
      key: "VKinit",
      value: function VKinit() {
        var _this$props2 = this.props,
            apiId = _this$props2.apiId,
            options = _this$props2.options;

        if (!this.vk) {
          this.vk = VKInstance || new VKApi(apiId, options);
          VKInstance = this.vk;
        }

        return this.vk.init();
      }
    }, {
      key: "render",
      value: function render() {
        var vk = this.state.vk;
        var children = this.props.children;
        return vk ? React.createElement(VKContext.Provider, {
          value: {
            vk: vk
          }
        }, children) : null;
      }
    }]);

    return VK;
  }(React.Component);

  _defineProperty(VK, "defaultProps", {
    apiId: null,
    options: {
      version: 160,
      onlyWidgets: true
    },
    onApiAvailable: function onApiAvailable() {}
  });

  var AllowMessagesFromCommunity =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(AllowMessagesFromCommunity, _React$Component);

    function AllowMessagesFromCommunity() {
      _classCallCheck(this, AllowMessagesFromCommunity);

      return _possibleConstructorReturn(this, _getPrototypeOf(AllowMessagesFromCommunity).apply(this, arguments));
    }

    _createClass(AllowMessagesFromCommunity, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        var vk = this.context.vk;
        vk.Observer.unsubscribe("widgets.allowMessagesFromCommunity.allowed");
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options,
            groupId = _this$props.groupId,
            onAllow = _this$props.onAllow,
            onDeny = _this$props.onDeny;
        vk.Widgets.AllowMessagesFromCommunity(elementId, options, groupId);
        vk.Observer.subscribe("widgets.allowMessagesFromCommunity.allowed", function (userId) {
          return onAllow(userId);
        });
        vk.Observer.subscribe("widgets.allowMessagesFromCommunity.denied", function (userId) {
          return onDeny(userId);
        });
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return AllowMessagesFromCommunity;
  }(React.Component);

  _defineProperty(AllowMessagesFromCommunity, "contextType", VKContext);

  _defineProperty(AllowMessagesFromCommunity, "defaultProps", {
    elementId: "vk_send_message",
    options: {
      height: 24
    },
    onAllow: function onAllow() {},
    onDeny: function onDeny() {}
  });

  var Application =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Application, _React$Component);

    function Application() {
      _classCallCheck(this, Application);

      return _possibleConstructorReturn(this, _getPrototypeOf(Application).apply(this, arguments));
    }

    _createClass(Application, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            appId = _this$props.appId,
            options = _this$props.options;
        vk.Widgets.App(elementId, appId, options);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Application;
  }(React.Component);

  _defineProperty(Application, "contextType", VKContext);

  _defineProperty(Application, "defaultProps", {
    elementId: "vk_app",
    options: {
      mode: 1
    }
  });

  var Auth =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Auth, _React$Component);

    function Auth() {
      _classCallCheck(this, Auth);

      return _possibleConstructorReturn(this, _getPrototypeOf(Auth).apply(this, arguments));
    }

    _createClass(Auth, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options;

        var copy = _objectSpread({}, options);

        copy.onAuth = function (uid, first_name, last_name, photo, photo_rec, hash) {
          return options.onAuth(uid, first_name, last_name, photo, photo_rec, hash);
        };

        vk.Widgets.Auth(elementId, copy);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Auth;
  }(React.Component);

  _defineProperty(Auth, "contextType", VKContext);

  _defineProperty(Auth, "defaultProps", {
    elementId: "vk_auth",
    options: {
      width: 300,
      onAuth: function onAuth() {}
    }
  });

  var Comments =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Comments, _React$Component);

    function Comments() {
      _classCallCheck(this, Comments);

      return _possibleConstructorReturn(this, _getPrototypeOf(Comments).apply(this, arguments));
    }

    _createClass(Comments, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        var vk = this.context.vk;
        vk.Observer.unsubscribe("widgets.comments.new_comment");
        vk.Observer.unsubscribe("widgets.comments.delete_comment");
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options,
            pageId = _this$props.pageId,
            onNewComment = _this$props.onNewComment,
            onDeleteComment = _this$props.onDeleteComment;
        vk.Widgets.Comments(elementId, options, pageId);
        vk.Observer.subscribe("widgets.comments.new_comment", function (num, last_comment, date, sign) {
          return onNewComment(num, last_comment, date, sign);
        });
        vk.Observer.subscribe("widgets.comments.delete_comment", onDeleteComment);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Comments;
  }(React.Component);

  _defineProperty(Comments, "contextType", VKContext);

  _defineProperty(Comments, "defaultProps", {
    elementId: "vk_comments",
    options: {
      height: 0,
      limit: 10,
      attach: "*",
      autoPublish: 0,
      mini: "auto",
      norealtime: 0
    },
    pageId: null,
    onNewComment: function onNewComment() {},
    onDeleteComment: function onDeleteComment() {}
  });

  var CommentsBrowse =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(CommentsBrowse, _React$Component);

    function CommentsBrowse() {
      _classCallCheck(this, CommentsBrowse);

      return _possibleConstructorReturn(this, _getPrototypeOf(CommentsBrowse).apply(this, arguments));
    }

    _createClass(CommentsBrowse, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options;
        vk.Widgets.CommentsBrowse(elementId, options);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return CommentsBrowse;
  }(React.Component);

  _defineProperty(CommentsBrowse, "contextType", VKContext);

  _defineProperty(CommentsBrowse, "defaultProps", {
    elementId: "vk_comments_browse",
    options: {
      height: 0,
      limit: 10,
      mini: "auto",
      norealtime: 0
    }
  });

  var CommunityMessages =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(CommunityMessages, _React$Component);

    function CommunityMessages() {
      _classCallCheck(this, CommunityMessages);

      return _possibleConstructorReturn(this, _getPrototypeOf(CommunityMessages).apply(this, arguments));
    }

    _createClass(CommunityMessages, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            groupId = _this$props.groupId,
            options = _this$props.options,
            onMount = _this$props.onMount;
        var widget = vk.Widgets.CommunityMessages(elementId, groupId, options);
        onMount(widget, elementId);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return CommunityMessages;
  }(React.Component);

  _defineProperty(CommunityMessages, "contextType", VKContext);

  _defineProperty(CommunityMessages, "defaultProps", {
    elementId: "vk_community_messages",
    options: {
      onCanNotWrite: function onCanNotWrite() {},
      welcomeScreen: 1,
      expandTimeout: 0,
      expanded: 0,
      widgetPosition: "right",
      buttonType: "blue_circle",
      disableButtonTooltip: 0
    },
    onMount: function onMount() {}
  });

  var ContactUs =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(ContactUs, _React$Component);

    function ContactUs() {
      _classCallCheck(this, ContactUs);

      return _possibleConstructorReturn(this, _getPrototypeOf(ContactUs).apply(this, arguments));
    }

    _createClass(ContactUs, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options,
            ownerId = _this$props.ownerId;
        vk.Widgets.ContactUs(elementId, options, -ownerId);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return ContactUs;
  }(React.Component);

  _defineProperty(ContactUs, "contextType", VKContext);

  _defineProperty(ContactUs, "defaultProps", {
    elementId: "vk_contact_us",
    options: {
      height: 24
    }
  });

  var Group =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Group, _React$Component);

    function Group() {
      _classCallCheck(this, Group);

      return _possibleConstructorReturn(this, _getPrototypeOf(Group).apply(this, arguments));
    }

    _createClass(Group, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        var vk = this.context.vk;
        vk.Observer.unsubscribe("widgets.groups.joined");
        vk.Observer.unsubscribe("widgets.groups.leaved");
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options,
            groupId = _this$props.groupId,
            onJoin = _this$props.onJoin,
            onLeave = _this$props.onLeave;
        vk.Widgets.Group(elementId, options, groupId);
        vk.Observer.subscribe("widgets.groups.joined", onJoin);
        vk.Observer.subscribe("widgets.groups.leaved", onLeave);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Group;
  }(React.Component);

  _defineProperty(Group, "contextType", VKContext);

  _defineProperty(Group, "defaultProps", {
    elementId: "vk_groups",
    options: {
      width: "auto",
      mode: 3,
      no_cover: 1,
      wide: 1
    },
    onJoin: function onJoin() {},
    onLeave: function onLeave() {}
  });

  var Like =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Like, _React$Component);

    function Like() {
      _classCallCheck(this, Like);

      return _possibleConstructorReturn(this, _getPrototypeOf(Like).apply(this, arguments));
    }

    _createClass(Like, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        var vk = this.context.vk;
        vk.Observer.unsubscribe("widgets.like.liked");
        vk.Observer.unsubscribe("widgets.like.unliked");
        vk.Observer.unsubscribe("widgets.like.shared");
        vk.Observer.unsubscribe("widgets.like.unshared");
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options,
            pageId = _this$props.pageId,
            onLike = _this$props.onLike,
            onUnlike = _this$props.onUnlike,
            onShare = _this$props.onShare,
            onUnshare = _this$props.onUnshare;

        if (pageId) {
          vk.Widgets.Like(elementId, options, pageId);
        } else {
          vk.Widgets.Like(elementId, options);
        }

        vk.Observer.subscribe("widgets.like.liked", function (quantity) {
          return onLike(quantity);
        });
        vk.Observer.subscribe("widgets.like.unliked", function (quantity) {
          return onUnlike(quantity);
        });
        vk.Observer.subscribe("widgets.like.shared", function (quantity) {
          return onShare(quantity);
        });
        vk.Observer.subscribe("widgets.like.unshared", function (quantity) {
          return onUnshare(quantity);
        });
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Like;
  }(React.Component);

  _defineProperty(Like, "contextType", VKContext);

  _defineProperty(Like, "defaultProps", {
    elementId: "vk_like",
    options: {
      type: "full",
      width: 350,
      height: 22,
      verb: 0
    },
    pageId: null,
    onLike: function onLike() {},
    onUnlike: function onUnlike() {},
    onShare: function onShare() {},
    onUnshare: function onUnshare() {}
  });

  var Playlist =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Playlist, _React$Component);

    function Playlist() {
      _classCallCheck(this, Playlist);

      return _possibleConstructorReturn(this, _getPrototypeOf(Playlist).apply(this, arguments));
    }

    _createClass(Playlist, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            ownerId = _this$props.ownerId,
            playlistId = _this$props.playlistId,
            hash = _this$props.hash,
            options = _this$props.options;
        vk.Widgets.Playlist(elementId, -ownerId, playlistId, hash, options);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Playlist;
  }(React.Component);

  _defineProperty(Playlist, "contextType", VKContext);

  _defineProperty(Playlist, "defaultProps", {
    elementId: "vk_playlist",
    options: {}
  });

  var Poll =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Poll, _React$Component);

    function Poll() {
      _classCallCheck(this, Poll);

      return _possibleConstructorReturn(this, _getPrototypeOf(Poll).apply(this, arguments));
    }

    _createClass(Poll, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options,
            pollId = _this$props.pollId;
        vk.Widgets.Poll(elementId, options, pollId);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Poll;
  }(React.Component);

  _defineProperty(Poll, "contextType", VKContext);

  _defineProperty(Poll, "defaultProps", {
    elementId: "vk_poll",
    options: {
      height: 24
    }
  });

  var Post =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Post, _React$Component);

    function Post() {
      _classCallCheck(this, Post);

      return _possibleConstructorReturn(this, _getPrototypeOf(Post).apply(this, arguments));
    }

    _createClass(Post, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            ownerId = _this$props.ownerId,
            postId = _this$props.postId,
            hash = _this$props.hash,
            options = _this$props.options;
        vk.Widgets.Post(elementId, ownerId, postId, hash, options);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Post;
  }(React.Component);

  _defineProperty(Post, "contextType", VKContext);

  _defineProperty(Post, "defaultProps", {
    elementId: "vk_post",
    options: {}
  });

  var Recommended =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Recommended, _React$Component);

    function Recommended() {
      _classCallCheck(this, Recommended);

      return _possibleConstructorReturn(this, _getPrototypeOf(Recommended).apply(this, arguments));
    }

    _createClass(Recommended, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options;
        vk.Widgets.Recommended(elementId, options);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Recommended;
  }(React.Component);

  _defineProperty(Recommended, "contextType", VKContext);

  _defineProperty(Recommended, "defaultProps", {
    elementId: "vk_recommend",
    options: {
      limit: 5,
      max: 20,
      period: "week",
      sort: "friend_like",
      target: "parent"
    }
  });

  var Subscribe =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Subscribe, _React$Component);

    function Subscribe() {
      _classCallCheck(this, Subscribe);

      return _possibleConstructorReturn(this, _getPrototypeOf(Subscribe).apply(this, arguments));
    }

    _createClass(Subscribe, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        var vk = this.context.vk;
        vk.Observer.unsubscribe("widgets.subscribed");
        vk.Observer.unsubscribe("widgets.unsubscribed");
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            options = _this$props.options,
            ownerId = _this$props.ownerId,
            onSubscribe = _this$props.onSubscribe,
            onUnsubscribe = _this$props.onUnsubscribe;
        vk.Widgets.Subscribe(elementId, options, ownerId);
        vk.Observer.subscribe("widgets.subscribed", onSubscribe);
        vk.Observer.subscribe("widgets.unsubscribed", onUnsubscribe);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Subscribe;
  }(React.Component);

  _defineProperty(Subscribe, "contextType", VKContext);

  _defineProperty(Subscribe, "defaultProps", {
    elementId: "vk_subscribe",
    options: {
      mode: 0,
      soft: 0
    },
    onSubscribe: function onSubscribe() {},
    onUnsubscribe: function onUnsubscribe() {}
  });

  var Post$1 =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(Post, _React$Component);

    function Post() {
      _classCallCheck(this, Post);

      return _possibleConstructorReturn(this, _getPrototypeOf(Post).apply(this, arguments));
    }

    _createClass(Post, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.mount();
      }
    }, {
      key: "mount",
      value: function mount() {
        var vk = this.context.vk;
        var _this$props = this.props,
            elementId = _this$props.elementId,
            articleUrl = _this$props.articleUrl;
        vk.Widgets.Article(elementId, articleUrl);
      }
    }, {
      key: "render",
      value: function render() {
        var elementId = this.props.elementId;
        return React.createElement("div", {
          id: elementId
        });
      }
    }]);

    return Post;
  }(React.Component);

  _defineProperty(Post$1, "contextType", VKContext);

  _defineProperty(Post$1, "defaultProps", {
    elementId: "vk_article"
  });

  exports.default = VK;
  exports.AllowMessagesFromCommunity = AllowMessagesFromCommunity;
  exports.Application = Application;
  exports.Auth = Auth;
  exports.Comments = Comments;
  exports.CommentsBrowse = CommentsBrowse;
  exports.CommunityMessages = CommunityMessages;
  exports.ContactUs = ContactUs;
  exports.Group = Group;
  exports.Like = Like;
  exports.Playlist = Playlist;
  exports.Poll = Poll;
  exports.Post = Post;
  exports.Recommended = Recommended;
  exports.Subscribe = Subscribe;
  exports.Article = Post$1;

  Object.defineProperty(exports, '__esModule', { value: true });

}));