@agilemotion/oui-react-js 1.3.8 → 1.3.9

package/dist/components/media/TrainingRoom.js

@@ -0,0 +1,531 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _Utils = _interopRequireDefault(require("../../Utils"));
+
+require("./Video.css");
+
+var _Icon = _interopRequireDefault(require("../Icon"));
+
+var _ApplicationContext = _interopRequireDefault(require("../../ApplicationContext"));
+
+var _Toolbar = _interopRequireDefault(require("./Toolbar"));
+
+var _Media = _interopRequireDefault(require("../../js/Media"));
+
+var _VCRoom = require("./VCRoom");
+
+var _VCRoomWorkspace = _interopRequireDefault(require("./VCRoomWorkspace"));
+
+var _VCEventType = require("./VCEventType");
+
+var _Alert = _interopRequireDefault(require("react-bootstrap/Alert"));
+
+var _VCEventManager = _interopRequireDefault(require("./VCEventManager"));
+
+var _SocketManager = _interopRequireDefault(require("../SocketManager"));
+
+var _ClosablePanel = _interopRequireDefault(require("./ClosablePanel"));
+
+var _SideBarContent = _interopRequireDefault(require("./SideBarContent"));
+
+var _RestUtils = require("../../RestUtils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const Status = {
+  LOBBY: 'LOBBY',
+  SESSION: 'SESSION',
+  SESSION_ENDED: 'SESSION_ENDED',
+  SYSTEM_ERROR: 'SYSTEM_ERROR',
+  CONNECTION_ERROR: 'CONNECTION_ERROR',
+  STREAM_ERROR: 'STREAM_ERROR'
+};
+const location = window.location.protocol + '//' + window.location.hostname;
+
+const TrainingRoom = /*#__PURE__*/_react.default.memo( /*#__PURE__*/_react.default.forwardRef((props, ref) => {
+  const recordRef = (0, _react.useRef)();
+  const [hasUnreadChats, setHasUnreadChats] = (0, _react.useState)(null);
+  const [participants, setParticipants] = (0, _react.useState)([]);
+  const [handRaised, setHandRaised] = (0, _react.useState)(false);
+  const [isRecording, setIsRecording] = (0, _react.useState)(false);
+  const [screenShared, setScreenShared] = (0, _react.useState)(null);
+  const [videoDisabled] = (0, _react.useState)(props.videoDisabled);
+  const [audioDisabled, setAudioDisabled] = (0, _react.useState)(props.audioDisabled);
+  const [videoMuted, setVideoMuted] = (0, _react.useState)(true);
+  const [audioMuted, setAudioMuted] = (0, _react.useState)(true);
+  const [displayState, setDisplayState] = (0, _react.useState)('MAXIMIZED');
+  const [roomStatus, setRoomStatus] = (0, _react.useState)(null);
+  const [someoneSharing, setSomeoneSharing] = (0, _react.useState)(null);
+  const [sideBarOpen, setSideBarOpen] = (0, _react.useState)(false);
+  const [sideBarTab, setSideBarTab] = (0, _react.useState)('');
+  const [allUserParticipantsLeft, setAllUserParticipantsLeft] = (0, _react.useState)(false);
+  const [lobbyWaitingList, setLobbyWaitingList] = (0, _react.useState)([]);
+  const [isHost, setIsHost] = (0, _react.useState)(false);
+  const [meetingParticipantGridMode, setMeetingParticipantGridMode] = (0, _react.useState)('DEFAULT');
+  const [autoPermit, setAutoPermit] = (0, _react.useState)(!props.calendarEvent.askToJoin);
+  const [rtpCapabilities, setRtpCapabilities] = (0, _react.useState)(null);
+  const [activityMessage, setActivityMessage] = (0, _react.useState)(null);
+  const [onloadScreenShareData, setOnloadScreenShareData] = (0, _react.useState)(null);
+  const [chatMessage, setChatMessage] = (0, _react.useState)(null);
+  const [chatSender, setChatSender] = (0, _react.useState)(null);
+  const [currentUserFullName, setCurrentUserFullName] = (0, _react.useState)(null);
+  const [eventHandler] = (0, _react.useState)({});
+  const [meetingChat, setMeetingChat] = (0, _react.useState)(null);
+  const shareScreenSource = (0, _react.useRef)();
+
+  const handler = () => {
+    return {
+      get id() {
+        return 'meeting-room-' + props.calendarEvent.id;
+      },
+
+      get participants() {
+        return participants;
+      },
+
+      on: (eventType, be) => {
+        switch (eventType) {
+          case _VCEventType.VCEventType.REQUEST_TO_JOIN_MEETING:
+            break;
+
+          case _VCEventType.VCEventType.USER_JOINED:
+            addUser(be.payload);
+            break;
+
+          case _VCEventType.VCEventType.USER_LEFT_MEETING:
+            removeUser(be.payload);
+            break;
+
+          case _VCEventType.VCEventType.AUDIO_VISUAL_SETTINGS_CHANGED:
+            onAVSettingsChange(be.payload);
+            break;
+
+          case _VCEventType.VCEventType.SYSTEM_EVENT:
+            alert(_VCEventType.VCEventType.SYSTEM_EVENT);
+            break;
+        }
+      }
+    };
+  };
+
+  const fetchChats = () => {
+    (0, _RestUtils.sendRequest)("".concat(location, "/api/v1/chat/fetchMeetingChat/").concat(props.calendarEvent.id), response => {
+      if (response && response.id) {
+        setMeetingChat(response);
+      }
+    }, e => {}, true, false);
+  };
+
+  const onAVSettingsChange = payload => {
+    let participant = participants.find(p => p.userId === payload.userId);
+
+    if (participant) {
+      participant.audioMuted = payload.audioMuted;
+      participant.videoMuted = payload.videoMuted;
+    }
+
+    _VCEventManager.default.fireEvent(_VCEventType.VCEventType.AUDIO_VISUAL_SETTINGS_CHANGED, payload);
+  };
+
+  function emitAVSettingsChange() {
+    _SocketManager.default.emitEvent(_VCEventType.VCEventType.AUDIO_VISUAL_SETTINGS_CHANGED, {
+      meetingId: props.calendarEvent.id,
+      userId: sessionStorage.getItem('username'),
+      audioMuted: audioMuted,
+      videoMuted: videoMuted
+    }).catch(error => {});
+  }
+
+  (0, _react.useEffect)(() => {
+    if (audioMuted !== null) {
+      onAVSettingsChange({
+        userId: sessionStorage.getItem('username'),
+        videoMuted,
+        audioMuted
+      });
+      emitAVSettingsChange();
+    }
+  }, [audioMuted]);
+  (0, _react.useEffect)(() => {
+    if (videoMuted !== null) {
+      onAVSettingsChange({
+        userId: sessionStorage.getItem('username'),
+        videoMuted,
+        audioMuted
+      });
+      emitAVSettingsChange();
+    }
+  }, [videoMuted]);
+
+  const handleMessageArrived = event => {
+    if (roomStatus === Status.SESSION && event.message && event.message.length > 0) {
+      setActivityMessage(event.message);
+      const messageTimeout = setTimeout(() => {
+        setActivityMessage(null);
+        clearTimeout(messageTimeout);
+      }, 4000);
+    }
+  };
+
+  const addUser = payload => {
+    console.log('ADD USER : ', payload);
+    addUserToParticipants(payload.user);
+    setAllUserParticipantsLeft(false);
+
+    if (roomStatus === Status.LOBBY) {
+      setRoomStatus(Status.SESSION);
+      setSideBarTab('People');
+      setSideBarOpen(true);
+    }
+
+    handleMessageArrived({
+      message: payload.user.name + ' has joined'
+    });
+  };
+
+  const removeUser = user => {
+    if (props.calendarEvent.id === user.meetingId) {
+      const userId = user.userId;
+      const find = participants.find(p => p.userId === userId);
+
+      if (find) {
+        const newParticipants = participants.filter(p => p.userId !== userId);
+
+        if (newParticipants.length === 0) {
+          setParticipants(newParticipants);
+          setAllUserParticipantsLeft(true);
+          setRoomStatus(Status.LOBBY);
+        }
+      }
+    }
+  };
+
+  const handleSidebarToggle = e => {
+    let paper = document.getElementById('meetingDialogPaper');
+
+    if (e.detail.open) {
+      paper.style.margin = '54px 0 0 136px';
+    } else {
+      paper.style.margin = '54px 0 0 0';
+    }
+  };
+
+  (0, _react.useEffect)(() => {
+    eventHandler.api = handler();
+  });
+  (0, _react.useEffect)(() => {
+    if (props.settings) {
+      setAudioMuted(!props.settings.audioOn);
+      setVideoMuted(!props.settings.videoOn);
+    }
+  }, [props.settings]);
+  (0, _react.useEffect)(() => {
+    _VCEventManager.default.removeSubscriptions(eventHandler);
+
+    _VCEventManager.default.addSubscriptions(eventHandler, _VCEventType.VCEventType.REQUEST_TO_JOIN_MEETING, _VCEventType.VCEventType.USER_JOINED, _VCEventType.VCEventType.USER_LEFT_MEETING, _VCEventType.VCEventType.SYSTEM_EVENT, _VCEventType.VCEventType.SOCKET_CONNECT, _VCEventType.VCEventType.SOCKET_DISCONNECT, _VCEventType.VCEventType.PEER_DISCONNECT, _VCEventType.VCEventType.CONSUMER_TRANSPORT_FAILED, _VCEventType.VCEventType.CREATE_TRANSPORT_FAILED);
+
+    document.addEventListener('sideBarToggleEvent', handleSidebarToggle);
+
+    _ApplicationContext.default.setHasActiveMeeting(true);
+
+    return () => {
+      _VCEventManager.default.removeSubscriptions(eventHandler);
+
+      document.removeEventListener('sideBarToggleEvent', handleSidebarToggle);
+
+      if (_ApplicationContext.default.hasActiveMeeting()) {
+        _SocketManager.default.leaveMeeting(props.calendarEvent.id);
+
+        _ApplicationContext.default.setHasActiveMeeting(false);
+      }
+    };
+  }, []);
+
+  _react.default.useEffect(() => {
+    _ApplicationContext.default.setHasActiveMeeting(true);
+
+    let userFullName;
+
+    if (props.calendarEvent.host.username === sessionStorage.getItem('username')) {
+      userFullName = props.calendarEvent.host.name;
+    } else {
+      userFullName = props.calendarEvent.attendees.find(a => a.username === sessionStorage.getItem('username')).name;
+    }
+
+    setCurrentUserFullName(userFullName);
+    setIsHost(props.calendarEvent.host.username === sessionStorage.getItem('username'));
+
+    try {
+      _Media.default.joinMeeting(props.calendarEvent, props.settings, userFullName).then(response => {
+        console.log('JOIN RESPONSE : ', response);
+        createParticipants(response.participants);
+        setRtpCapabilities(response.rtpCapabilities);
+        setOnloadScreenShareData(response.shareScreenProducerData);
+        setRoomStatus(participants.length > 0 ? Status.SESSION : Status.LOBBY);
+      }).catch(e => {
+        setRoomStatus(e.message);
+      });
+    } catch (e) {
+      setRoomStatus(Status.SYSTEM_ERROR);
+    }
+
+    return () => {
+      _ApplicationContext.default.setHasActiveMeeting(false);
+    };
+  }, []);
+
+  function addUserToParticipants(user) {
+    // Typically, a user shoud not exist. We are ensuring that there are never duplicates
+    console.log('SEARCHING PARTICIPANT : ' + user.userId);
+    console.log(participants);
+    let participant = participants.find(u => u.userId === user.userId);
+
+    if (participant) {
+      console.log('FOUND EXISTING PARTICIPANT : ', participant);
+      participant.name = user.name;
+      participant.avatar = user.avatar;
+      participant.audioMuted = user.audioMuted;
+      participant.videoMuted = user.videoMuted;
+      participant.producers = user.producers;
+    } else {
+      console.log('DID NOT FIND EXISTING PARTICIPANT : ', participant);
+      participant = {
+        userId: user.userId,
+        name: user.name,
+        avatar: user.avatar,
+        audioMuted: user.audioMuted,
+        videoMuted: user.videoMuted,
+        producers: user.producers
+      };
+      participants.push(participant);
+      setParticipants([].concat(participants));
+    }
+  }
+
+  const changeOtherParticipantAVSettings = (userId, audioMuted, videoMuted) => {};
+
+  const createParticipants = users => {
+    console.log('ALL USERS received and creating participants : ', users);
+    users.forEach(user => {
+      console.log('ADDING ITEM TO PARTICIPANTS : ', user);
+      addUserToParticipants(user);
+    });
+    setAllUserParticipantsLeft(false);
+
+    if (participants.length > 0) {
+      if (roomStatus === Status.LOBBY) {
+        setRoomStatus(Status.SESSION);
+        setSideBarOpen(true);
+      }
+    }
+  };
+
+  const hangUp = () => {
+    _SocketManager.default.leaveMeeting(props.calendarEvent.id);
+
+    _ApplicationContext.default.setHasActiveMeeting(false);
+
+    _ApplicationContext.default.removeLoadedGraph(true);
+
+    setSideBarOpen(false);
+    setSideBarTab('');
+  };
+
+  return /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      width: '100%',
+      height: '100%',
+      border: '1px solid #e2e2e2',
+      borderRadius: '4px'
+    }
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: 'row no-margin no-padding w-100 h-100'
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: 'col no-margin no-padding',
+    style: {
+      display: displayState === 'MAXIMIZED' ? 'inherit' : 'none'
+    }
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: 'row no-margin no-padding w-100 h-100'
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      width: '100%',
+      borderBottom: '1px solid #e2e2e2'
+    }
+  }, /*#__PURE__*/_react.default.createElement(_Toolbar.default, {
+    eventHandler: {
+      onMuteVideo: muted => {
+        setVideoMuted(muted);
+      },
+      onMuteAudio: muted => {
+        setAudioMuted(muted);
+      },
+      endCall: () => {
+        hangUp();
+      },
+      showChat: () => {
+        fetchChats();
+      },
+      showPeople: () => {
+        setSideBarTab('People');
+        setSideBarOpen(true);
+      }
+    },
+    hasUnreadChats: hasUnreadChats,
+    participants: participants,
+    handRaised: handRaised,
+    videoDisabled: videoDisabled,
+    audioDisabled: audioDisabled,
+    videoMuted: videoMuted,
+    audioMuted: audioMuted,
+    displayState: displayState,
+    roomStatus: roomStatus,
+    isHost: props.calendarEvent.host.username === sessionStorage.getItem('username'),
+    autoPermit: !props.calendarEvent.host.askToJoin,
+    someoneSharing: someoneSharing,
+    screenShared: screenShared,
+    isRecording: isRecording
+  })), roomStatus === Status.SYSTEM_ERROR && /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      color: 'rgb(235, 63, 33)',
+      padding: '32px',
+      fontSize: '24px',
+      width: '100%',
+      height: '100%'
+    },
+    className: 'centered-flex-box'
+  }, _VCRoom.SYSTEM_ERROR_MESSAGE), roomStatus === Status.CONNECTION_ERROR && /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      color: 'rgb(235, 63, 33)',
+      padding: '32px',
+      fontSize: '24px',
+      width: '100%',
+      height: '100%'
+    },
+    className: 'centered-flex-box'
+  }, /*#__PURE__*/_react.default.createElement("div", null, _VCRoom.SYSTEM_ERROR_MESSAGE)), rtpCapabilities && participants && currentUserFullName && (roomStatus === Status.SESSION || roomStatus === Status.LOBBY) && /*#__PURE__*/_react.default.createElement(_VCRoomWorkspace.default, {
+    participants: participants,
+    mode: meetingParticipantGridMode,
+    audioMuted: audioMuted,
+    videoMuted: videoMuted,
+    meetingTitle: props.calendarEvent.title,
+    shareScreenSource: shareScreenSource.current,
+    meetingId: props.calendarEvent.id,
+    currentUserFullName: currentUserFullName,
+    onGridSetup: () => {
+      setSideBarTab('People');
+    },
+    roomStatus: roomStatus,
+    isHost: isHost,
+    screenShared: screenShared,
+    sharingHandler: someoneSharing => setSomeoneSharing(someoneSharing),
+    autoPermit: autoPermit,
+    rtpCapabilities: rtpCapabilities,
+    onloadScreenShareData: onloadScreenShareData,
+    allUserParticipantsLeft: allUserParticipantsLeft,
+    onAudioDeviceChange: device => {
+      setAudioDisabled(_Utils.default.isNull(device));
+    },
+    onHostAudioMute: participant => {
+      changeOtherParticipantAVSettings(participant.userId, true, participant.videoMuted);
+    },
+    onHostVideoMute: participant => {
+      changeOtherParticipantAVSettings(participant.userId, participant.audioMuted, true);
+    }
+  }))), sideBarOpen && sideBarTab && displayState === 'MAXIMIZED' && roomStatus === Status.SESSION && /*#__PURE__*/_react.default.createElement("div", {
+    className: 'closable-panel-container'
+  }, /*#__PURE__*/_react.default.createElement(_ClosablePanel.default, {
+    closeHandler: e => {
+      setSideBarOpen(false);
+      setSideBarTab(null);
+    },
+    title: sideBarTab
+  }, /*#__PURE__*/_react.default.createElement(_SideBarContent.default, {
+    meetingChat: meetingChat,
+    isHost: isHost,
+    tab: sideBarTab,
+    meetingId: props.calendarEvent.id,
+    participants: participants,
+    onHostAudioMute: participant => {
+      changeOtherParticipantAVSettings(participant.userId, true, participant.videoMuted);
+    },
+    onHostVideoMute: participant => {
+      changeOtherParticipantAVSettings(participant.userId, participant.audioMuted, true);
+    }
+  })))), /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      position: 'absolute',
+      right: '48px',
+      bottom: '48px'
+    }
+  }, /*#__PURE__*/_react.default.createElement(_Alert.default, {
+    variant: 'info',
+    show: activityMessage !== null,
+    fade: true
+  }, /*#__PURE__*/_react.default.createElement("p", {
+    style: {
+      color: 'rgba(255, 255, 255, 0.8)'
+    }
+  }, activityMessage)), /*#__PURE__*/_react.default.createElement(_Alert.default, {
+    variant: 'info',
+    show: chatMessage !== null,
+    fade: true
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: 'row',
+    style: {
+      borderBottom: '1px solid white',
+      paddingBottom: '8px'
+    }
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: 'col'
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: 'row'
+  }, /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement(_Icon.default, {
+    id: 'CHAT_BUBBLE'
+  })), /*#__PURE__*/_react.default.createElement("div", {
+    className: 'col'
+  }, /*#__PURE__*/_react.default.createElement("p", {
+    style: {
+      color: 'rgba(255, 255, 255, 0.8)'
+    }
+  }, chatSender))))), /*#__PURE__*/_react.default.createElement("div", {
+    className: 'row',
+    style: {
+      marginTop: '8px'
+    }
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: 'col'
+  }, /*#__PURE__*/_react.default.createElement("p", {
+    style: {
+      color: 'rgba(255, 255, 255, 0.8)'
+    }
+  }, chatMessage))))), /*#__PURE__*/_react.default.createElement(_react.Fragment, null, /*#__PURE__*/_react.default.createElement("div", {
+    style: {
+      display: 'none'
+    }
+  }, /*#__PURE__*/_react.default.createElement("video", {
+    hidden: false,
+    muted: true,
+    playsInline: true,
+    autoPlay: true,
+    ref: recordRef,
+    style: {
+      width: '200px',
+      height: '200px'
+    }
+  }))));
+}));
+
+var _default = TrainingRoom;
+exports.default = _default;

package/dist/components/media/Transports.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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; }
+
+class Transports {
+  constructor() {
+    _defineProperty(this, "closeProducerTransport", () => {
+      if (this.producerTransport) {
+        this.producerTransport.close();
+      }
+    });
+
+    _defineProperty(this, "setProducerTransport", producerTransport => {
+      this.producerTransport = producerTransport;
+    });
+
+    _defineProperty(this, "closeConsumerTransport", () => {
+      if (this.consumerTransport) {
+        this.consumerTransport.close();
+      }
+    });
+
+    _defineProperty(this, "setConsumerTransport", consumerTransport => {
+      this.consumerTransport = consumerTransport;
+    });
+  }
+
+}
+
+exports.default = Transports;

package/dist/components/media/VCEventManager.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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; }
+
+class VCEventManager {
+  constructor() {
+    _defineProperty(this, "addSubscriptions", (handler, ...eventTypes) => {
+      for (const eventType of eventTypes) {
+        this.subscriptions.push({
+          handler,
+          eventType
+        });
+      }
+    });
+
+    _defineProperty(this, "removeSubscriptions", eventHandler => {
+      if (eventHandler.api) {
+        this.subscriptions = this.subscriptions.filter(sub => {
+          var _sub$handler$api;
+
+          return ((_sub$handler$api = sub.handler.api) === null || _sub$handler$api === void 0 ? void 0 : _sub$handler$api.id) !== eventHandler.api.id;
+        });
+      }
+    });
+
+    if (!VCEventManager.instance) {
+      this.subscriptions = [];
+      VCEventManager.instance = this;
+    }
+
+    return VCEventManager.instance;
+  }
+  /**
+   * Adds a subscription bound by the given event type.
+   *
+   * @param handler the subscription to be added
+   * @param eventTypes the subscription to be added
+   */
+
+
+  /**
+   * Fires an event.
+   *
+   * @param eventType eventType the event type
+   * @param be the base event
+   * @return false if any subscriptions cancel the event.
+   */
+  async fireEvent(eventType, be) {
+    for (const subscription of this.subscriptions) {
+      if (subscription.eventType === eventType) {
+        subscription.handler.api.on(eventType, be);
+      }
+    }
+  }
+
+  /**
+   * Clears all event subscriptions
+   *
+   */
+  clearAllEventListeners() {
+    this.subscriptions.splice(0, this.subscriptions.length);
+  }
+
+}
+
+const instance = new VCEventManager(); //Object.freeze(instance);
+
+var _default = instance;
+exports.default = _default;