abstracted 0.0.6 → 0.0.14

data/vendor/assets/components/sweetalert/dev/modules/injected-html.js

@@ -0,0 +1,69 @@
+var injectedHTML = 
+
+  // Dark overlay
+  `<div class="sweet-overlay" tabIndex="-1"></div>` +
+
+  // Modal
+  `<div class="sweet-alert">` +
+
+    // Error icon
+    `<div class="sa-icon sa-error">
+      <span class="sa-x-mark">
+        <span class="sa-line sa-left"></span>
+        <span class="sa-line sa-right"></span>
+      </span>
+    </div>` +
+
+    // Warning icon
+    `<div class="sa-icon sa-warning">
+      <span class="sa-body"></span>
+      <span class="sa-dot"></span>
+    </div>` +
+
+    // Info icon
+    `<div class="sa-icon sa-info"></div>` +
+
+    // Success icon
+    `<div class="sa-icon sa-success">
+      <span class="sa-line sa-tip"></span>
+      <span class="sa-line sa-long"></span>
+
+      <div class="sa-placeholder"></div>
+      <div class="sa-fix"></div>
+    </div>` +
+
+    `<div class="sa-icon sa-custom"></div>` +
+
+    // Title, text and input
+    `<h2>Title</h2>
+    <p>Text</p>
+    <fieldset>
+      <input type="text" tabIndex="3" />
+      <div class="sa-input-error"></div>
+    </fieldset>` +
+
+    // Input errors
+    `<div class="sa-error-container">
+      <div class="icon">!</div>
+      <p>Not valid!</p>
+    </div>` +
+
+    // Cancel and confirm buttons
+    `<div class="sa-button-container">
+      <button class="cancel" tabIndex="2">Cancel</button>
+      <div class="sa-confirm-button-container">
+        <button class="confirm" tabIndex="1">OK</button>` + 
+
+        // Loading animation
+        `<div class="la-ball-fall">
+          <div></div>
+          <div></div>
+          <div></div>
+        </div>
+      </div>
+    </div>` +
+
+  // End of modal
+  `</div>`;
+
+export default injectedHTML;

data/vendor/assets/components/sweetalert/dev/modules/set-params.js

@@ -0,0 +1,221 @@
+var alertTypes = ['error', 'warning', 'info', 'success', 'input', 'prompt'];
+
+import {
+  isIE8
+} from './utils';
+
+import {
+  getModal,
+  getInput,
+  setFocusStyle
+} from './handle-swal-dom';
+
+import {
+  hasClass, addClass, removeClass,
+  escapeHtml,
+  _show, show, _hide, hide
+} from './handle-dom';
+
+
+/*
+ * Set type, text and actions on modal
+ */
+var setParameters = function(params) {
+  var modal = getModal();
+
+  var $title = modal.querySelector('h2');
+  var $text = modal.querySelector('p');
+  var $cancelBtn = modal.querySelector('button.cancel');
+  var $confirmBtn = modal.querySelector('button.confirm');
+
+  /*
+   * Title
+   */
+  $title.innerHTML = params.html ? params.title : escapeHtml(params.title).split('\n').join('<br>');
+
+  /*
+   * Text
+   */
+  $text.innerHTML = params.html ? params.text : escapeHtml(params.text || '').split('\n').join('<br>');
+  if (params.text) show($text);
+
+  /*
+   * Custom class
+   */
+  if (params.customClass) {
+    addClass(modal, params.customClass);
+    modal.setAttribute('data-custom-class', params.customClass);
+  } else {
+    // Find previously set classes and remove them
+    let customClass = modal.getAttribute('data-custom-class');
+    removeClass(modal, customClass);
+    modal.setAttribute('data-custom-class', '');
+  }
+
+  /*
+   * Icon
+   */
+  hide(modal.querySelectorAll('.sa-icon'));
+
+  if (params.type && !isIE8()) {
+
+    let validType = false;
+
+    for (let i = 0; i < alertTypes.length; i++) {
+      if (params.type === alertTypes[i]) {
+        validType = true;
+        break;
+      }
+    }
+
+    if (!validType) {
+      logStr('Unknown alert type: ' + params.type);
+      return false;
+    }
+
+    let typesWithIcons = ['success', 'error', 'warning', 'info'];
+    let $icon;
+
+    if (typesWithIcons.indexOf(params.type) !== -1) {
+      $icon = modal.querySelector('.sa-icon.' + 'sa-' + params.type);
+      show($icon);
+    }
+
+    let $input = getInput();
+
+    // Animate icon
+    switch (params.type) {
+
+      case 'success':
+        addClass($icon, 'animate');
+        addClass($icon.querySelector('.sa-tip'), 'animateSuccessTip');
+        addClass($icon.querySelector('.sa-long'), 'animateSuccessLong');
+        break;
+
+      case 'error':
+        addClass($icon, 'animateErrorIcon');
+        addClass($icon.querySelector('.sa-x-mark'), 'animateXMark');
+        break;
+
+      case 'warning':
+        addClass($icon, 'pulseWarning');
+        addClass($icon.querySelector('.sa-body'), 'pulseWarningIns');
+        addClass($icon.querySelector('.sa-dot'), 'pulseWarningIns');
+        break;
+
+      case 'input':
+      case 'prompt':
+        $input.setAttribute('type', params.inputType);
+        $input.value = params.inputValue;
+        $input.setAttribute('placeholder', params.inputPlaceholder);
+        addClass(modal, 'show-input');
+        setTimeout(function () {
+          $input.focus();
+          $input.addEventListener('keyup', swal.resetInputError);
+        }, 400);
+        break;
+    }
+  }
+
+  /*
+   * Custom image
+   */
+  if (params.imageUrl) {
+    let $customIcon = modal.querySelector('.sa-icon.sa-custom');
+
+    $customIcon.style.backgroundImage = 'url(' + params.imageUrl + ')';
+    show($customIcon);
+
+    let _imgWidth = 80;
+    let _imgHeight = 80;
+
+    if (params.imageSize) {
+      let dimensions = params.imageSize.toString().split('x');
+      let imgWidth = dimensions[0];
+      let imgHeight = dimensions[1];
+
+      if (!imgWidth || !imgHeight) {
+        logStr('Parameter imageSize expects value with format WIDTHxHEIGHT, got ' + params.imageSize);
+      } else {
+        _imgWidth = imgWidth;
+        _imgHeight = imgHeight;
+      }
+    }
+
+    $customIcon.setAttribute('style', $customIcon.getAttribute('style') + 'width:' + _imgWidth + 'px; height:' + _imgHeight + 'px');
+  }
+
+  /*
+   * Show cancel button?
+   */
+  modal.setAttribute('data-has-cancel-button', params.showCancelButton);
+  if (params.showCancelButton) {
+    $cancelBtn.style.display = 'inline-block';
+  } else {
+    hide($cancelBtn);
+  }
+
+  /*
+   * Show confirm button?
+   */
+  modal.setAttribute('data-has-confirm-button', params.showConfirmButton);
+  if (params.showConfirmButton) {
+    $confirmBtn.style.display = 'inline-block';
+  } else {
+    hide($confirmBtn);
+  }
+
+  /*
+   * Custom text on cancel/confirm buttons
+   */
+  if (params.cancelButtonText) {
+    $cancelBtn.innerHTML = escapeHtml(params.cancelButtonText);
+  }
+  if (params.confirmButtonText) {
+    $confirmBtn.innerHTML = escapeHtml(params.confirmButtonText);
+  }
+
+  /*
+   * Custom color on confirm button
+   */
+  if (params.confirmButtonColor) {
+    // Set confirm button to selected background color
+    $confirmBtn.style.backgroundColor = params.confirmButtonColor;
+
+    // Set the confirm button color to the loading ring
+    $confirmBtn.style.borderLeftColor = params.confirmLoadingButtonColor;
+    $confirmBtn.style.borderRightColor = params.confirmLoadingButtonColor;
+
+    // Set box-shadow to default focused button
+    setFocusStyle($confirmBtn, params.confirmButtonColor);
+  }
+
+  /*
+   * Allow outside click
+   */
+  modal.setAttribute('data-allow-outside-click', params.allowOutsideClick);
+
+  /*
+   * Callback function
+   */
+  var hasDoneFunction = params.doneFunction ? true : false;
+  modal.setAttribute('data-has-done-function', hasDoneFunction);
+
+  /*
+   * Animation
+   */
+  if (!params.animation) {
+    modal.setAttribute('data-animation', 'none');
+  } else if (typeof params.animation === 'string') {
+    modal.setAttribute('data-animation', params.animation); // Custom animation
+  } else {
+    modal.setAttribute('data-animation', 'pop');
+  }
+
+  /*
+   * Timer
+   */
+  modal.setAttribute('data-timer', params.timer);
+};
+
+export default setParameters;

data/vendor/assets/components/sweetalert/dev/modules/utils.js

@@ -0,0 +1,71 @@
+/*
+ * Allow user to pass their own params
+ */
+var extend = function(a, b) {
+  for (var key in b) {
+    if (b.hasOwnProperty(key)) {
+      a[key] = b[key];
+    }
+  }
+  return a;
+};
+
+/*
+ * Convert HEX codes to RGB values (#000000 -> rgb(0,0,0))
+ */
+var hexToRgb = function(hex) {
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? parseInt(result[1], 16) + ', ' + parseInt(result[2], 16) + ', ' + parseInt(result[3], 16) : null;
+};
+
+/*
+ * Check if the user is using Internet Explorer 8 (for fallbacks)
+ */
+var isIE8 = function() {
+  return (window.attachEvent && !window.addEventListener);
+};
+
+/*
+ * IE compatible logging for developers
+ */
+var logStr = function(string) {
+  if (window.console) {
+    // IE...
+    window.console.log('SweetAlert: ' + string);
+  }
+};
+
+/*
+ * Set hover, active and focus-states for buttons 
+ * (source: http://www.sitepoint.com/javascript-generate-lighter-darker-color)
+ */
+var colorLuminance = function(hex, lum) {
+  // Validate hex string
+  hex = String(hex).replace(/[^0-9a-f]/gi, '');
+  if (hex.length < 6) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+  }
+  lum = lum || 0;
+
+  // Convert to decimal and change luminosity
+  var rgb = '#';
+  var c;
+  var i;
+
+  for (i = 0; i < 3; i++) {
+    c = parseInt(hex.substr(i * 2, 2), 16);
+    c = Math.round(Math.min(Math.max(0, c + c * lum), 255)).toString(16);
+    rgb += ('00' + c).substr(c.length);
+  }
+
+  return rgb;
+};
+
+
+export {
+  extend,
+  hexToRgb,
+  isIE8,
+  logStr,
+  colorLuminance
+};

data/vendor/assets/components/sweetalert/dev/sweetalert.es6.js

@@ -0,0 +1,311 @@
+// SweetAlert
+// 2014-2015 (c) - Tristan Edwards
+// github.com/t4t5/sweetalert
+
+/*
+ * jQuery-like functions for manipulating the DOM
+ */
+import {
+  hasClass, addClass, removeClass,
+  escapeHtml,
+  _show, show, _hide, hide,
+  isDescendant,
+  getTopMargin,
+  fadeIn, fadeOut,
+  fireClick,
+  stopEventPropagation
+} from './modules/handle-dom';
+
+/*
+ * Handy utilities
+ */
+import {
+  extend,
+  hexToRgb,
+  isIE8,
+  logStr,
+  colorLuminance
+} from './modules/utils';
+
+/*
+ *  Handle sweetAlert's DOM elements
+ */
+import {
+  sweetAlertInitialize,
+  getModal,
+  getOverlay,
+  getInput,
+  setFocusStyle,
+  openModal,
+  resetInput,
+  fixVerticalPosition
+} from './modules/handle-swal-dom';
+
+
+// Handle button events and keyboard events
+import { handleButton, handleConfirm, handleCancel } from './modules/handle-click';
+import handleKeyDown from './modules/handle-key';
+
+
+// Default values
+import defaultParams from './modules/default-params';
+import setParameters from './modules/set-params';
+
+/*
+ * Remember state in cases where opening and handling a modal will fiddle with it.
+ * (We also use window.previousActiveElement as a global variable)
+ */
+var previousWindowKeyDown;
+var lastFocusedButton;
+
+
+/*
+ * Global sweetAlert function
+ * (this is what the user calls)
+ */
+var sweetAlert, swal;
+
+sweetAlert = swal = function() {
+  var customizations = arguments[0];
+
+  addClass(document.body, 'stop-scrolling');
+  resetInput();
+
+  /*
+   * Use argument if defined or default value from params object otherwise.
+   * Supports the case where a default value is boolean true and should be
+   * overridden by a corresponding explicit argument which is boolean false.
+   */
+  function argumentOrDefault(key) {
+    var args = customizations;
+    return (args[key] === undefined) ?  defaultParams[key] : args[key];
+  }
+
+  if (customizations === undefined) {
+    logStr('SweetAlert expects at least 1 attribute!');
+    return false;
+  }
+
+  var params = extend({}, defaultParams);
+
+  switch (typeof customizations) {
+
+    // Ex: swal("Hello", "Just testing", "info");
+    case 'string':
+      params.title = customizations;
+      params.text  = arguments[1] || '';
+      params.type  = arguments[2] || '';
+      break;
+
+    // Ex: swal({ title:"Hello", text: "Just testing", type: "info" });
+    case 'object':
+      if (customizations.title === undefined) {
+        logStr('Missing "title" argument!');
+        return false;
+      }
+
+      params.title = customizations.title;
+
+      for (let customName in defaultParams) {
+        params[customName] = argumentOrDefault(customName);
+      }
+
+      // Show "Confirm" instead of "OK" if cancel button is visible
+      params.confirmButtonText = params.showCancelButton ? 'Confirm' : defaultParams.confirmButtonText;
+      params.confirmButtonText = argumentOrDefault('confirmButtonText');
+
+      // Callback function when clicking on "OK"/"Cancel"
+      params.doneFunction = arguments[1] || null;
+
+      break;
+
+    default:
+      logStr('Unexpected type of argument! Expected "string" or "object", got ' + typeof customizations);
+      return false;
+
+  }
+
+  setParameters(params);
+  fixVerticalPosition();
+  openModal(arguments[1]);
+
+  // Modal interactions
+  var modal = getModal();
+
+
+  /*
+   * Make sure all modal buttons respond to all events
+   */
+  var $buttons = modal.querySelectorAll('button');
+  var buttonEvents = ['onclick', 'onmouseover', 'onmouseout', 'onmousedown', 'onmouseup', 'onfocus'];
+  var onButtonEvent = (e) => handleButton(e, params, modal);
+
+  for (let btnIndex = 0; btnIndex < $buttons.length; btnIndex++) {
+    for (let evtIndex = 0; evtIndex < buttonEvents.length; evtIndex++) {
+      let btnEvt = buttonEvents[evtIndex];
+      $buttons[btnIndex][btnEvt] = onButtonEvent;
+    }
+  }
+
+  // Clicking outside the modal dismisses it (if allowed by user)
+  getOverlay().onclick = onButtonEvent;
+
+  previousWindowKeyDown = window.onkeydown;
+
+  var onKeyEvent = (e) => handleKeyDown(e, params, modal);
+  window.onkeydown = onKeyEvent;
+
+  window.onfocus = function () {
+    // When the user has focused away and focused back from the whole window.
+    setTimeout(function () {
+      // Put in a timeout to jump out of the event sequence.
+      // Calling focus() in the event sequence confuses things.
+      if (lastFocusedButton !== undefined) {
+        lastFocusedButton.focus();
+        lastFocusedButton = undefined;
+      }
+    }, 0);
+  };
+  
+  // Show alert with enabled buttons always
+  swal.enableButtons();
+};
+
+
+
+/*
+ * Set default params for each popup
+ * @param {Object} userParams
+ */
+sweetAlert.setDefaults = swal.setDefaults = function(userParams) {
+  if (!userParams) {
+    throw new Error('userParams is required');
+  }
+  if (typeof userParams !== 'object') {
+    throw new Error('userParams has to be a object');
+  }
+
+  extend(defaultParams, userParams);
+};
+
+
+/*
+ * Animation when closing modal
+ */
+sweetAlert.close = swal.close = function() {
+  var modal = getModal();
+
+  fadeOut(getOverlay(), 5);
+  fadeOut(modal, 5);
+  removeClass(modal, 'showSweetAlert');
+  addClass(modal, 'hideSweetAlert');
+  removeClass(modal, 'visible');
+
+  /*
+   * Reset icon animations
+   */
+  var $successIcon = modal.querySelector('.sa-icon.sa-success');
+  removeClass($successIcon, 'animate');
+  removeClass($successIcon.querySelector('.sa-tip'), 'animateSuccessTip');
+  removeClass($successIcon.querySelector('.sa-long'), 'animateSuccessLong');
+
+  var $errorIcon = modal.querySelector('.sa-icon.sa-error');
+  removeClass($errorIcon, 'animateErrorIcon');
+  removeClass($errorIcon.querySelector('.sa-x-mark'), 'animateXMark');
+
+  var $warningIcon = modal.querySelector('.sa-icon.sa-warning');
+  removeClass($warningIcon, 'pulseWarning');
+  removeClass($warningIcon.querySelector('.sa-body'), 'pulseWarningIns');
+  removeClass($warningIcon.querySelector('.sa-dot'), 'pulseWarningIns');
+
+  // Reset custom class (delay so that UI changes aren't visible)
+  setTimeout(function() {
+    var customClass = modal.getAttribute('data-custom-class');
+    removeClass(modal, customClass);
+  }, 300);
+
+  // Make page scrollable again
+  removeClass(document.body, 'stop-scrolling');
+
+  // Reset the page to its previous state
+  window.onkeydown = previousWindowKeyDown;
+  if (window.previousActiveElement) {
+    window.previousActiveElement.focus();
+  }
+  lastFocusedButton = undefined;
+  clearTimeout(modal.timeout);
+
+  return true;
+};
+
+
+/*
+ * Validation of the input field is done by user
+ * If something is wrong => call showInputError with errorMessage
+ */
+sweetAlert.showInputError = swal.showInputError = function(errorMessage) {
+  var modal = getModal();
+
+  var $errorIcon = modal.querySelector('.sa-input-error');
+  addClass($errorIcon, 'show');
+
+  var $errorContainer = modal.querySelector('.sa-error-container');
+  addClass($errorContainer, 'show');
+
+  $errorContainer.querySelector('p').innerHTML = errorMessage;
+
+  setTimeout(function() {
+    sweetAlert.enableButtons();
+  }, 1);
+
+  modal.querySelector('input').focus();
+};
+
+
+/*
+ * Reset input error DOM elements
+ */
+sweetAlert.resetInputError = swal.resetInputError = function(event) {
+  // If press enter => ignore
+  if (event && event.keyCode === 13) {
+    return false;
+  }
+
+  var $modal = getModal();
+
+  var $errorIcon = $modal.querySelector('.sa-input-error');
+  removeClass($errorIcon, 'show');
+
+  var $errorContainer = $modal.querySelector('.sa-error-container');
+  removeClass($errorContainer, 'show');
+};
+
+/*
+ * Disable confirm and cancel buttons
+ */
+sweetAlert.disableButtons = swal.disableButtons = function(event) {
+  var modal = getModal();
+  var $confirmButton = modal.querySelector('button.confirm');
+  var $cancelButton = modal.querySelector('button.cancel');
+  $confirmButton.disabled = true;
+  $cancelButton.disabled = true;
+};
+
+/*
+ * Enable confirm and cancel buttons
+ */
+sweetAlert.enableButtons = swal.enableButtons = function(event) {
+  var modal = getModal();
+  var $confirmButton = modal.querySelector('button.confirm');
+  var $cancelButton = modal.querySelector('button.cancel');
+  $confirmButton.disabled = false;
+  $cancelButton.disabled = false;
+};
+
+if (typeof window !== 'undefined') {
+  // The 'handle-click' module requires
+  // that 'sweetAlert' was set as global.
+  window.sweetAlert = window.swal = sweetAlert;
+} else {
+  logStr('SweetAlert is a frontend module!');
+}