react-vk/dist/react-vk.esm.js

import React from '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"
});

export default VK;
export { AllowMessagesFromCommunity, Application, Auth, Comments, CommentsBrowse, CommunityMessages, ContactUs, Group, Like, Playlist, Poll, Post, Recommended, Subscribe, Post$1 as Article };