station 0.0.0 → 0.0.100

data/lib/nexmo_developer/vendor/assets/javascripts/volta/components/volta.dropdown.js

@@ -0,0 +1,145 @@
+/**
+ * Copyright (c) 2018-present, Vonage. All rights reserved.
+ *
+ * Dropdowns (requires core)
+ */
+
+'use strict';
+
+Volta.dropdown = function () {
+	var _class = {
+		wrapper: 'Vlt-dropdown',
+		block: 'Vlt-dropdown__block',
+		btn: 'Vlt-dropdown__trigger',
+		btnLegacy: 'Vlt-dropdown__btn',
+		dismissed: 'Vlt-callout--dismissed',
+		expanded: 'Vlt-dropdown--expanded',
+		label: 'Vlt-dropdown__label',
+		link: 'Vlt-dropdown__link',
+		noCloseLink: 'Vlt-dropdown__link--noclose',
+		noCloseBlock: 'Vlt-dropdown__block--noclose',
+		panel: 'Vlt-dropdown__panel',
+		panelContent: 'Vlt-dropdown__panel__content',
+		selection: 'Vlt-dropdown__selection',
+		switch: 'Vlt-switch',
+		switchSlider: 'Vlt-switch__slider'
+	}
+
+	function Dropdown() {}
+
+	Dropdown.prototype = {
+		init: function(element, supressClickHandler) {
+			this.dropdown = element;
+			this.selection = this.dropdown.querySelector('.' + _class.selection);
+			this.isSelectionVisible = !!this.selection;
+			this.btn = this.dropdown.querySelector('.' + _class.btn) || this.dropdown.querySelector('.' + _class.btnLegacy);
+			this._suppress = supressClickHandler;
+
+			if(!this._suppress) {
+				this._addEventListener();
+			}
+		},
+		_addEventListener: function(){
+			var openHandler = this.open.bind(this);
+			this.dropdown.addEventListener('click', openHandler, { once: true })
+		},
+		close: function(text) {
+			if(text) {
+				this._setDropdownSelectionText(text);
+			}
+			this.dropdown.classList.remove(_class.expanded);
+
+			if(!this._suppress){
+				this._addEventListener();
+			}
+
+		},
+		_closeEventHandler: undefined,
+		_closeEvent: function(e) {
+			var targetIsPanel = Volta._hasClass(e.target, _class.panel);
+			var parentIsPanel = Volta._closest(e.target, '.' + _class.panelContent, _class.panel) !== null;
+			var parentLink = Volta._closest(e.target, '.' + _class.link, _class.wrapper);
+			var parentIsLink = parentLink && parentLink.length === 1;
+			var isSwitchSlider = Volta._hasClass(e.target, _class.switchSlider);
+			var isParentSwitch = Volta._closest(e.target,'.' + _class.switch, _class.link);
+			var isNoClose = Volta._hasClass(e.target, _class.noCloseLink) || Volta._hasClass(e.target, _class.noCloseBlock);
+			var isNoCloseParent = Volta._closest(e.target,'.' + _class.noCloseLink, _class.link) || Volta._closest(e.target,'.' + _class.noCloseBlock, _class.noCloseBlock);
+			var isInput = e.target instanceof HTMLInputElement;
+
+			if(!targetIsPanel && !parentIsPanel && !parentIsLink && !isNoClose && !isInput && !isNoCloseParent) {
+				e.preventDefault();
+				e.stopPropagation();
+			}
+
+			if(isSwitchSlider || isParentSwitch || isNoClose || isInput || isNoCloseParent) {
+				return null;
+			}
+
+			var text;
+			if(parentIsPanel && Volta._hasClass(e.target, _class.label)) {
+				text = e.target.innerHTML;
+			} else if (parentIsPanel) {
+				var label = e.target.querySelector('.' + _class.label);
+				if(label) {
+					text = label.innerHTML;
+				}
+			}
+
+			this.close(text);
+
+			document.querySelector('body').removeEventListener('click', this._closeEventHandler );
+		},
+		open: function(event) {
+			if(event) {
+				event.preventDefault();
+				event.stopPropagation();
+			}
+
+			this.dropdown.classList.add(_class.expanded);
+
+			if(!this._suppress){
+				this._closeEventHandler = this._closeEvent.bind(this);
+				document.querySelector('body').addEventListener('click', this._closeEventHandler );
+			}
+		},
+		_setDropdownSelectionText: function(text) {
+			if(this.isSelectionVisible) {
+				this.selection.innerText = text;
+			} else {
+				this.btn.innerText = text;
+				this.btn.value = text;
+			}
+		},
+		_suppress: false
+	}
+
+	return {
+		create: create,
+		init: attachDropdownHandlers
+	}
+
+	/**
+	 *	@public
+	 *
+	 *	@description Attach a listeners to dropdowns
+	 */
+	function attachDropdownHandlers() {
+		document.querySelectorAll('.' + _class.wrapper).forEach(attachHandler);
+
+		function attachHandler(dropdown) {
+			create(dropdown);
+		}
+	}
+
+	/**
+	 *	@private
+	 *
+	 *	@description Create a dropdown element
+	 *  @param {HTMLElement} element
+ 	 */
+	function create(element){
+		var dropdown = Object.create(Dropdown.prototype, {})
+		dropdown.init(element);
+		return dropdown;
+	}
+}();

data/lib/nexmo_developer/vendor/assets/javascripts/volta/components/volta.flash.js

@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) 2018-present, Vonage. All rights reserved.
+ *	
+ * Tabs (requires core)
+ */
+
+'use strict';
+
+Volta.flash = function () {	
+	var _class = {
+		flash: 'Vlt-flash',
+		trigger: 'Vlt-flash-trigger',
+		visible: 'Vlt-flash_visible'
+	}
+
+	var gap = 20,
+		openBottomFlashes = [],
+		openTopFlashes = [],
+		timeouts =[];
+
+	return {
+		closeAll: closeAll,
+		init: attachFlashHandlers,
+		show: show
+	}
+
+	/**   
+	 *	@public
+	 *	
+	 *	@description Attach a click listener to each flash's trigger on the screen
+	 *  @param {HTMLElement} element 
+	 */
+	function attachFlashHandlers() {
+		var triggers = document.querySelectorAll('.' + _class.trigger);
+
+		if(triggers.length === 0) {
+			return;
+		}
+
+		triggers.forEach(attachHandler);
+		
+		function attachHandler(trigger) {
+			trigger.addEventListener('click', function() {
+				if(trigger.dataset.flash) {
+					var flash = document.querySelector('#' + trigger.dataset.flash);
+					show(flash);
+				} else {
+					console.warn("Volta: flash trigger is missing data-flash attribute");
+				}				
+			});
+		}
+	}
+
+	/**   
+	 *	@public
+	 *	
+	 *	@description Close all open flashes
+	 */
+	function closeAll() {		
+		if(timeouts.length > 0) {
+			timeouts.forEach(function(timeout){
+				clearTimeout(timeout);
+			});
+		}
+		if(openBottomFlashes.length > 0) {
+			clearQueue(openBottomFlashes);
+		}
+		if(openTopFlashes.length > 0) {
+			clearQueue(openTopFlashes);
+		}
+		
+		timeouts = [];
+		openBottomFlashes = [];
+		openTopFlashes = [];
+
+		function clearQueue(elementArr) {
+			elementArr.forEach(function(element){
+				_hide(element);
+			});	
+			elementArr = [];
+		}
+	}
+
+	/**   
+	 *	@public
+	 *	
+	 *	@description Show the flash
+	 *  @param {HTMLElement} element 
+	 */
+	function show(elementOrId, time) {
+		if(!elementOrId || elementOrId.length == 0) {
+			return;
+		}
+		
+		time = time || 5000;
+
+		var element = !elementOrId.classList ? document.querySelector('#' + elementOrId) : elementOrId;
+		var position = Volta._hasClass(element, 'Vlt-flash--bottom') ? 'bottom' : 'top';
+		var arr = position === 'bottom' ? openBottomFlashes : openTopFlashes;
+
+		if(arr.indexOf(element) !== -1) {
+			return;
+		}
+		
+		_setFlashPosition(arr, element, position);
+
+		arr.push(element);
+				
+		element.classList.add(_class.visible);
+		
+		var hideTimeout = setTimeout(function(){
+			_hide(element, true);
+			Volta._removeFromArr(timeouts, hideTimeout);
+		}, time);
+
+		timeouts.push(hideTimeout);
+	}
+
+	/**   
+	 *	@private
+	 *	@description Hide the flash
+	 *  @param {HTMLElement} element 
+	 */
+	function _hide(element, shouldRemove) {
+		var position = Volta._hasClass(element, 'Vlt-flash--bottom') ? 'bottom' : 'top';
+		var arr = position === 'bottom' ? openBottomFlashes : openTopFlashes;
+		
+		if(shouldRemove) {
+			Volta._removeFromArr(arr, element);
+		}
+
+		_updateFlashPositions(arr, element, position);
+
+		element.style[position] = '';
+		element.classList.remove(_class.visible);
+	}
+
+	/**   
+	 *	@private
+	 *	@description Set the position of the flash
+	 *  @param {HTMLElement} element 
+	 */
+	function _setFlashPosition(arr, element, position) {
+		var positionPx = arr.reduce(function(px, flash) {
+			return px + flash.clientHeight;				
+		}, 0);
+		if(positionPx > 0) {
+			element.style[position] = (gap * arr.length) + gap + positionPx + 'px';
+		}
+	}
+
+	/**   
+	 *	@private
+	 *	@description Update the position of all the visible flashes
+	 *  @param {Array} arr
+	 *  @param {HTMLElement} element 
+	 *  @param {string} position 
+	 */
+	function _updateFlashPositions(arr, element, position){
+		if(arr.length > 0) {
+			var elementHeight = element.clientHeight;
+
+			arr.forEach(function(flash) {
+				var newPosition;
+
+				if(position === 'bottom') {
+					newPosition = Number(flash.style.bottom.substring(0, flash.style.bottom.length - 2));
+				} else {
+					newPosition = flash.getBoundingClientRect()[position];				
+				}
+				flash.style[position] = newPosition -elementHeight - gap + "px";		
+			});
+		}
+	}
+}();

data/lib/nexmo_developer/vendor/assets/javascripts/volta/components/volta.modal.js

@@ -0,0 +1,312 @@
+/**
+ * Copyright (c) 2018-present, Vonage. All rights reserved.
+ *
+ * Modals (requires core)
+ */
+
+'use strict';
+
+Volta.modal = function () {
+	var _class = {
+		auto: 'Vlt-modal--auto',
+		bodyModalOpen: 'Vlt-body--modal-open',
+		cancel: 'Vlt-modal__cancel',
+		confirm: 'Vlt-modal__confirm',
+		content: 'Vlt-modal__content',
+		modal: 'Vlt-modal',
+		out: 'Vlt-modal--out',
+		panel: 'Vlt-modal__panel',
+		trigger: 'Vlt-modal-trigger',
+		visible: 'Vlt-modal_visible',
+		dismiss: 'Vlt-modal__dismiss',
+	}
+
+	var body,
+		dismissModalHandler,
+		cancelModalHandler,
+		confirmModalHandler,
+		escHandler,
+		clickHandler,
+		escAttached;
+
+	function Modal() {}
+
+	Modal.prototype = {
+		attachButtons: function() {
+			var _this = this;
+			_this.dismissBtn = _this.modal.querySelector('.' + _class.dismiss);
+
+		    if(_this.dismissBtn) {
+		    	dismissModalHandler = dismissModal.bind(_this);
+		    	_this.dismissBtn.addEventListener('click', dismissModalHandler);
+		    }
+
+		    _this.cancelBtn = _this.modal.querySelector('.' + _class.cancel);
+
+		    if(_this.cancelBtn) {
+	    		cancelModalHandler = cancelModal.bind(_this);
+		    	_this.cancelBtn.addEventListener('click', cancelModalHandler);
+		    }
+
+		    _this.confirmBtn = _this.modal.querySelector('.' + _class.confirm);
+
+		    if(_this.confirmBtn) {
+		    	confirmModalHandler = confirmModal.bind(_this);
+		    	_this.confirmBtn.addEventListener('click', confirmModalHandler);
+		    }
+		},
+		html: function(newHtml) {
+			this.modal.innerHTML = newHtml;
+			return this;
+		},
+		init: function(elementOrId) {
+			if(elementOrId.length) {
+				this.modal = document.querySelector('#' + elementOrId);
+			} else {
+				this.modal = elementOrId;
+			}
+
+			this._callback = Volta._getFunction(this.modal.dataset.callback);
+		},
+		open: function(e) {
+		    if(e && e.preventDefault) {
+		        e.preventDefault();
+		    	e.stopPropagation();
+		    }
+
+		    this.modal.classList.remove(_class.out);
+		    this.modal.classList.add(_class.visible);
+		    this.attachButtons();
+
+		    disableScroll();
+
+		    if(!escAttached && !this.modal.dataset.disableEsc || this.modal.dataset.disableEsc === "false") {
+		    	escHandler = closeModalOnEscape.bind(this);
+		   		body.addEventListener('keyup', escHandler, { once: true });
+		   		escAttached = true;
+		    }
+
+		    if(!this.modal.dataset.disableClick || this.modal.dataset.disableClick === "false") {
+		    	clickHandler = closeModalOnClick.bind(this);
+		   		this.modal.addEventListener('click', clickHandler, { once: true });
+		    }
+		},
+		dismiss: function(e, confirmed) {
+			var _this = this;
+
+			if(e && e.preventDefault) {
+		    	e.preventDefault();
+		    	e.stopPropagation();
+			}
+
+			enableScroll();
+
+			if(_this.modal){
+				_this.modal.classList.remove(_class.visible);
+				_this.modal.classList.add(_class.out);
+			}
+
+			if(_this._callback) {
+				_this._callback(confirmed);
+			}
+
+			removeModal(_this);
+		}
+	}
+
+	return {
+		create: create,
+		init: attachModalHandlers
+	}
+
+	/**
+	 *	@public
+	 *
+	 *	@description Attach a click listener to each modals trigger on the screen, which will open the modal
+	 */
+	function attachModalHandlers() {
+		if(!body) {
+			body = document.querySelector('body');
+		}
+
+		var triggers = document.querySelectorAll('.' + _class.trigger);
+
+		if(triggers.length > 0) {
+			triggers.forEach(attachTriggerHandler);
+		}
+
+		//Not the recommended way to use modals
+		var modals = document.querySelectorAll('.' + _class.modal);
+
+		if(modals.length > 0) {
+			modals.forEach(attachModalHandler);
+		}
+
+		function attachModalHandler(modal) {
+			if(Volta._hasClass(modal, _class.auto)) {
+				var trigger = document.querySelector('#' + modal.dataset.trigger);
+				trigger.addEventListener('click', function() {
+					create(modal).open();
+				});
+			}
+		}
+
+		function attachTriggerHandler(trigger) {
+			if(trigger.dataset.modal) {
+				var modal = document.querySelector('#' + trigger.dataset.modal);
+
+				if(!modal) {
+					console.warn('Volta: modal ' + trigger.dataset.modal + ' cannot be found');
+				}
+
+				trigger.addEventListener('click', function() {
+					create(modal).open();
+				});
+			}
+		}
+	}
+
+    /**
+	 *	@private
+	 *
+	 *	@description Close the modal, triggered by cancel button, passes false to callback function
+	 *  @param {event} e
+	 */
+    function cancelModal(e) {
+		return this.dismiss(e, false);
+	}
+
+	/**
+	 *	@private
+	 *
+	 *	@description Close the modal, triggered by confirm button, passes true to callback function
+	 *  @param {event} e
+	 */
+    function confirmModal(e) {
+		return this.dismiss(e, true);
+	}
+
+    /**
+	 *	@private
+	 *
+	 *	@description Close the modal, triggered by 'x' button, passes false to callback function
+	 *  @param {event} e
+	 */
+    function dismissModal(e) {
+		return this.dismiss(e, false);
+    }
+
+    /**	@private
+	 *
+	 *	@description Close the modal, triggered by 'esc' key, passes false to callback function
+	 *  @param {event} e
+	 */
+    function closeModalOnEscape(e){
+    	if(e && e.keyCode === 27) {
+    		this.dismiss(e, false);
+    	} else {
+			body.addEventListener('click', escHandler, { once: true });
+    	}
+    }
+
+
+    /**	@private
+	 *
+	 *	@description Close the modal, triggered by 'body click, passes false to callback function
+	 *  @param {event} e
+	 */
+    function closeModalOnClick(e){
+    	if(!Volta._hasClass(e.target, _class.trigger)
+			&& !Volta._closest(e.target, '.' + _class.trigger, '.' + _class.trigger)
+    		&& !Volta._closest(e.target, '.' + _class.panel, '.' + _class.panel)) {
+    		this.dismiss(e, false);
+    	} else if(this.modal) {
+			this.modal.addEventListener('click', clickHandler, { once: true });
+    	}
+    }
+
+    /**
+	 *	@public
+	 *
+	 *	@description Create the modal object
+	 *  @param {HTMLElement|string} elementOrId Reference to the modal element or the id
+	 *. @return {Object} A modal object
+	 */
+    function create(elementOrId) {
+    	if(!body) {
+			body = document.querySelector('body');
+		}
+		var modal = Object.create(Modal.prototype, {})
+		modal.init(elementOrId);
+		return modal;
+    }
+
+    /**
+	 * Private functions to disable body scroll when modal is open
+     */
+    function disableScroll() {
+	    body.classList.add(_class.bodyModalOpen);
+		body.addEventListener('touchmove', preventScroll);
+
+		if (body.querySelector('.Vlt-main')) {
+			body.querySelector('.Vlt-main').addEventListener('touchmove', preventScroll);
+		} else {
+			body.addEventListener('touchmove', preventScroll);
+		}
+
+		body.querySelector('.' + _class.content).addEventListener('touchmove', allowScroll);
+    }
+
+    function enableScroll() {
+		body.classList.remove(_class.bodyModalOpen);
+		body.removeEventListener('touchmove', preventScroll);
+
+		if (body.querySelector('.Vlt-main')) {
+			body.querySelector('.Vlt-main').removeEventListener('touchmove', preventScroll);
+		} else {
+			body.removeEventListener('touchmove', preventScroll);
+		}
+		
+		var modalContent = body.querySelector('.' + _class.content);
+		if(modalContent) modalContent.removeEventListener('touchmove', allowScroll);
+    }
+
+    function allowScroll(e) {
+    	e.stopPropagation();
+    }
+
+    function preventScroll(e) {
+		e.preventDefault();
+    }
+
+  	/**
+	 *	@private
+	 *
+	 *	@description Remove the modal after dismiss, makes sure to delete the modal properties so it can be garbage collected, and removes event listeners
+	 *  @param {HTMLElement|string} elementOrId Reference to the modal element or the id
+	 */
+	function removeModal(modal) {
+		delete modal.modal;
+
+		if(modal.dismissBtn) {
+			modal.dismissBtn.removeEventListener('click', dismissModalHandler);
+		}
+
+		if(modal.cancelBtn) {
+			modal.cancelBtn.removeEventListener('click', cancelModalHandler);
+		}
+
+		if(modal.confirmBtn) {
+			modal.confirmBtn.removeEventListener('click', confirmModalHandler);
+		}
+
+		if(clickHandler) {
+   			body.removeEventListener('click', clickHandler);
+    	}
+
+    	if(escHandler) {
+    		body.removeEventListener('keyup', escHandler);
+    		escAttached = false;
+    	}
+	}
+}();