From 0a3f190a85c3b9c21442162215ea1a27d0b634ac Mon Sep 17 00:00:00 2001 From: lza_menace Date: Thu, 1 Jul 2021 09:46:55 -0700 Subject: [PATCH] fix bugs, fix auth logic --- xmrbackers/factory.py | 4 +- xmrbackers/routes/auth.py | 117 +- xmrbackers/static/css/noty-relax.css | 46 + xmrbackers/static/css/noty.css | 222 ++ xmrbackers/static/css/noty.css.map | 1 + xmrbackers/static/js/noty.js | 3124 ++++++++++++++++++++ xmrbackers/templates/auth/login.html | 47 + xmrbackers/templates/auth/register.html | 27 +- xmrbackers/templates/includes/head.html | 2 + xmrbackers/templates/includes/header.html | 23 +- xmrbackers/templates/includes/scripts.html | 8 - xmrbackers/templates/index.html | 13 +- 12 files changed, 3538 insertions(+), 96 deletions(-) create mode 100644 xmrbackers/static/css/noty-relax.css create mode 100644 xmrbackers/static/css/noty.css create mode 100644 xmrbackers/static/css/noty.css.map create mode 100644 xmrbackers/static/js/noty.js create mode 100644 xmrbackers/templates/auth/login.html diff --git a/xmrbackers/factory.py b/xmrbackers/factory.py index 9898119..efd264d 100644 --- a/xmrbackers/factory.py +++ b/xmrbackers/factory.py @@ -36,8 +36,8 @@ def create_app(): @login_manager.user_loader def load_user(user_id): from xmrbackers.models import User - user = User.query.get(user_id) - return user.id + user = User.get(user_id) + return user return app bcrypt = Bcrypt(create_app()) diff --git a/xmrbackers/routes/auth.py b/xmrbackers/routes/auth.py index e071ab9..da27e79 100644 --- a/xmrbackers/routes/auth.py +++ b/xmrbackers/routes/auth.py @@ -4,7 +4,7 @@ from quart import flash, redirect, url_for from flask_login import login_user, logout_user, current_user from xmrbackers.factory import bcrypt -from xmrbackers.forms import Register +from xmrbackers.forms import Register, Login from xmrbackers.models import User @@ -13,17 +13,18 @@ bp = Blueprint('auth', 'auth') @bp.route("/register", methods=["GET", "POST"]) async def register(): form = Register() - # if current_user.is_authenticated: - # flash('Already registered and authenticated.') - # return redirect(url_for('meta.index')) - # return 'gotem' + if current_user.is_authenticated: + await flash('Already registered and authenticated.') + return redirect(url_for('meta.index')) + if form.validate_on_submit(): # Check if email already exists - user = User.query.filter_by(email=form.email.data).first() + user = User.select().where( + User.email == form.email.data + ).first() if user: - flash('This email is already registered.') - # return redirect(url_for('auth.login')) - return 'gotem' + await flash('This email is already registered.') + return redirect(url_for('auth.login')) # Save new user user = User( @@ -34,65 +35,47 @@ async def register(): user.save() login_user(user) return redirect(url_for('meta.index')) + return await render_template("auth/register.html", form=form) -# -# @auth_bp.route("/login", methods=["GET", "POST"]) -# def login(): -# form = Login() -# if current_user.is_authenticated: -# flash('Already registered and authenticated.') -# return redirect(url_for('wallet.dashboard')) -# -# if form.validate_on_submit(): -# # Check if user doesn't exist -# user = User.query.filter_by(email=form.email.data).first() -# if not user: -# flash('Invalid username or password.') -# return redirect(url_for('auth.login')) -# -# # Check if password is correct -# password_matches = bcrypt.check_password_hash( -# user.password, -# form.password.data -# ) -# if not password_matches: -# flash('Invalid username or password.') -# return redirect(url_for('auth.login')) -# -# # Capture event, login user, and redirect to wallet page -# capture_event(user.id, 'login') -# login_user(user) -# return redirect(url_for('wallet.dashboard')) -# -# return render_template("auth/login.html", form=form) -# -# @auth_bp.route("/logout") -# def logout(): -# if current_user.is_authenticated: -# docker.stop_container(current_user.wallet_container) -# capture_event(current_user.id, 'stop_container') -# current_user.clear_wallet_data() -# capture_event(current_user.id, 'logout') -# logout_user() -# return redirect(url_for('meta.index')) -# -# @auth_bp.route("/delete", methods=["GET", "POST"]) -# @login_required -# def delete(): -# form = Delete() -# if form.validate_on_submit(): -# docker.stop_container(current_user.wallet_container) -# capture_event(current_user.id, 'stop_container') -# sleep(1) -# docker.delete_wallet_data(current_user.id) -# capture_event(current_user.id, 'delete_wallet') -# current_user.clear_wallet_data(reset_password=True, reset_wallet=True) -# flash('Successfully deleted wallet data') -# return redirect(url_for('wallet.setup')) -# else: -# flash('Please confirm deletion of the account') -# return redirect(url_for('wallet.dashboard')) -# + +@bp.route("/login", methods=["GET", "POST"]) +async def login(): + form = Login() + if current_user.is_authenticated: + await flash('Already logged in.') + return redirect(url_for('meta.index')) + + if form.validate_on_submit(): + # Check if user doesn't exist + user = User.select().where( + User.email == form.email.data + ).first() + if not user: + await flash('Invalid username or password.') + return redirect(url_for('auth.login')) + + # Check if password is correct + password_matches = bcrypt.check_password_hash( + user.password, + form.password.data + ) + if not password_matches: + await flash('Invalid username or password.') + return redirect(url_for('auth.login')) + + login_user(user) + return redirect(url_for('meta.index')) + + return await render_template("auth/login.html", form=form) + +@bp.route("/logout") +async def logout(): + if current_user.is_authenticated: + logout_user() + else: + await flash('Not authenticated!') + return redirect(url_for('meta.index')) + # @auth_bp.route("/reset/", methods=["GET", "POST"]) # def reset(hash): # hash = PasswordReset.query.filter(PasswordReset.hash==hash).first() diff --git a/xmrbackers/static/css/noty-relax.css b/xmrbackers/static/css/noty-relax.css new file mode 100644 index 0000000..f5f99ec --- /dev/null +++ b/xmrbackers/static/css/noty-relax.css @@ -0,0 +1,46 @@ +.noty_theme__relax.noty_bar { + margin: 4px 0; + overflow: hidden; + border-radius: 2px; + position: relative; } + .noty_theme__relax.noty_bar .noty_body { + padding: 10px; } + .noty_theme__relax.noty_bar .noty_buttons { + border-top: 1px solid #e7e7e7; + padding: 5px 10px; } + +.noty_theme__relax.noty_type__alert, +.noty_theme__relax.noty_type__notification { + background-color: #fff; + border: 1px solid #dedede; + color: #444; } + +.noty_theme__relax.noty_type__warning { + background-color: #FFEAA8; + border: 1px solid #FFC237; + color: #826200; } + .noty_theme__relax.noty_type__warning .noty_buttons { + border-color: #dfaa30; } + +.noty_theme__relax.noty_type__error { + background-color: #FF8181; + border: 1px solid #e25353; + color: #FFF; } + .noty_theme__relax.noty_type__error .noty_buttons { + border-color: darkred; } + +.noty_theme__relax.noty_type__info, +.noty_theme__relax.noty_type__information { + background-color: #78C5E7; + border: 1px solid #3badd6; + color: #FFF; } + .noty_theme__relax.noty_type__info .noty_buttons, + .noty_theme__relax.noty_type__information .noty_buttons { + border-color: #0B90C4; } + +.noty_theme__relax.noty_type__success { + background-color: #BCF5BC; + border: 1px solid #7cdd77; + color: darkgreen; } + .noty_theme__relax.noty_type__success .noty_buttons { + border-color: #50C24E; } diff --git a/xmrbackers/static/css/noty.css b/xmrbackers/static/css/noty.css new file mode 100644 index 0000000..ee33b8f --- /dev/null +++ b/xmrbackers/static/css/noty.css @@ -0,0 +1,222 @@ +.noty_layout_mixin, #noty_layout__top, #noty_layout__topLeft, #noty_layout__topCenter, #noty_layout__topRight, #noty_layout__bottom, #noty_layout__bottomLeft, #noty_layout__bottomCenter, #noty_layout__bottomRight, #noty_layout__center, #noty_layout__centerLeft, #noty_layout__centerRight { + position: fixed; + margin: 0; + padding: 0; + z-index: 9999999; + -webkit-transform: translateZ(0) scale(1, 1); + transform: translateZ(0) scale(1, 1); + -webkit-backface-visibility: hidden; + backface-visibility: hidden; + -webkit-font-smoothing: subpixel-antialiased; + filter: blur(0); + -webkit-filter: blur(0); + max-width: 90%; } + +#noty_layout__top { + top: 0; + left: 5%; + width: 90%; } + +#noty_layout__topLeft { + top: 20px; + left: 20px; + width: 325px; } + +#noty_layout__topCenter { + top: 5%; + left: 50%; + width: 325px; + -webkit-transform: translate(-webkit-calc(-50% - .5px)) translateZ(0) scale(1, 1); + transform: translate(calc(-50% - .5px)) translateZ(0) scale(1, 1); } + +#noty_layout__topRight { + top: 20px; + right: 20px; + width: 325px; } + +#noty_layout__bottom { + bottom: 0; + left: 5%; + width: 90%; } + +#noty_layout__bottomLeft { + bottom: 20px; + left: 20px; + width: 325px; } + +#noty_layout__bottomCenter { + bottom: 5%; + left: 50%; + width: 325px; + -webkit-transform: translate(-webkit-calc(-50% - .5px)) translateZ(0) scale(1, 1); + transform: translate(calc(-50% - .5px)) translateZ(0) scale(1, 1); } + +#noty_layout__bottomRight { + bottom: 20px; + right: 20px; + width: 325px; } + +#noty_layout__center { + top: 50%; + left: 50%; + width: 325px; + -webkit-transform: translate(-webkit-calc(-50% - .5px), -webkit-calc(-50% - .5px)) translateZ(0) scale(1, 1); + transform: translate(calc(-50% - .5px), calc(-50% - .5px)) translateZ(0) scale(1, 1); } + +#noty_layout__centerLeft { + top: 50%; + left: 20px; + width: 325px; + -webkit-transform: translate(0, -webkit-calc(-50% - .5px)) translateZ(0) scale(1, 1); + transform: translate(0, calc(-50% - .5px)) translateZ(0) scale(1, 1); } + +#noty_layout__centerRight { + top: 50%; + right: 20px; + width: 325px; + -webkit-transform: translate(0, -webkit-calc(-50% - .5px)) translateZ(0) scale(1, 1); + transform: translate(0, calc(-50% - .5px)) translateZ(0) scale(1, 1); } + +.noty_progressbar { + display: none; } + +.noty_has_timeout.noty_has_progressbar .noty_progressbar { + display: block; + position: absolute; + left: 0; + bottom: 0; + height: 3px; + width: 100%; + background-color: #646464; + opacity: 0.2; + filter: alpha(opacity=10); } + +.noty_bar { + -webkit-backface-visibility: hidden; + -webkit-transform: translate(0, 0) translateZ(0) scale(1, 1); + -ms-transform: translate(0, 0) scale(1, 1); + transform: translate(0, 0) scale(1, 1); + -webkit-font-smoothing: subpixel-antialiased; + overflow: hidden; } + +.noty_effects_open { + opacity: 0; + -webkit-transform: translate(50%); + -ms-transform: translate(50%); + transform: translate(50%); + -webkit-animation: noty_anim_in 0.5s cubic-bezier(0.68, -0.55, 0.265, 1.55); + animation: noty_anim_in 0.5s cubic-bezier(0.68, -0.55, 0.265, 1.55); + -webkit-animation-fill-mode: forwards; + animation-fill-mode: forwards; } + +.noty_effects_close { + -webkit-animation: noty_anim_out 0.5s cubic-bezier(0.68, -0.55, 0.265, 1.55); + animation: noty_anim_out 0.5s cubic-bezier(0.68, -0.55, 0.265, 1.55); + -webkit-animation-fill-mode: forwards; + animation-fill-mode: forwards; } + +.noty_fix_effects_height { + -webkit-animation: noty_anim_height 75ms ease-out; + animation: noty_anim_height 75ms ease-out; } + +.noty_close_with_click { + cursor: pointer; } + +.noty_close_button { + position: absolute; + top: 2px; + right: 2px; + font-weight: bold; + width: 20px; + height: 20px; + text-align: center; + line-height: 20px; + background-color: rgba(0, 0, 0, 0.05); + border-radius: 2px; + cursor: pointer; + -webkit-transition: all .2s ease-out; + transition: all .2s ease-out; } + +.noty_close_button:hover { + background-color: rgba(0, 0, 0, 0.1); } + +.noty_modal { + position: fixed; + width: 100%; + height: 100%; + background-color: #000; + z-index: 10000; + opacity: .3; + left: 0; + top: 0; } + +.noty_modal.noty_modal_open { + opacity: 0; + -webkit-animation: noty_modal_in .3s ease-out; + animation: noty_modal_in .3s ease-out; } + +.noty_modal.noty_modal_close { + -webkit-animation: noty_modal_out .3s ease-out; + animation: noty_modal_out .3s ease-out; + -webkit-animation-fill-mode: forwards; + animation-fill-mode: forwards; } + +@-webkit-keyframes noty_modal_in { + 100% { + opacity: .3; } } + +@keyframes noty_modal_in { + 100% { + opacity: .3; } } + +@-webkit-keyframes noty_modal_out { + 100% { + opacity: 0; } } + +@keyframes noty_modal_out { + 100% { + opacity: 0; } } + +@keyframes noty_modal_out { + 100% { + opacity: 0; } } + +@-webkit-keyframes noty_anim_in { + 100% { + -webkit-transform: translate(0); + transform: translate(0); + opacity: 1; } } + +@keyframes noty_anim_in { + 100% { + -webkit-transform: translate(0); + transform: translate(0); + opacity: 1; } } + +@-webkit-keyframes noty_anim_out { + 100% { + -webkit-transform: translate(50%); + transform: translate(50%); + opacity: 0; } } + +@keyframes noty_anim_out { + 100% { + -webkit-transform: translate(50%); + transform: translate(50%); + opacity: 0; } } + +@-webkit-keyframes noty_anim_height { + 100% { + height: 0; } } + +@keyframes noty_anim_height { + 100% { + height: 0; } } + +/*# sourceMappingURL=noty.css.map*/ + + +/* Custom */ +.noty_body { + text-align: center; +} diff --git a/xmrbackers/static/css/noty.css.map b/xmrbackers/static/css/noty.css.map new file mode 100644 index 0000000..70e0c46 --- /dev/null +++ b/xmrbackers/static/css/noty.css.map @@ -0,0 +1 @@ +{"version":3,"sources":[],"names":[],"mappings":"","file":"noty.css","sourceRoot":""} \ No newline at end of file diff --git a/xmrbackers/static/js/noty.js b/xmrbackers/static/js/noty.js new file mode 100644 index 0000000..bc148da --- /dev/null +++ b/xmrbackers/static/js/noty.js @@ -0,0 +1,3124 @@ +/* + @package NOTY - Dependency-free notification library + @version version: 3.2.0-beta + @contributors https://github.com/needim/noty/graphs/contributors + @documentation Examples and Documentation - https://ned.im/noty + @license Licensed under the MIT licenses: http://www.opensource.org/licenses/mit-license.php +*/ + +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define("Noty", [], factory); + else if(typeof exports === 'object') + exports["Noty"] = factory(); + else + root["Noty"] = factory(); +})(this, function() { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // identity function for calling harmony imports with the correct context +/******/ __webpack_require__.i = function(value) { return value; }; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { +/******/ configurable: false, +/******/ enumerable: true, +/******/ get: getter +/******/ }); +/******/ } +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 6); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.css = exports.deepExtend = exports.animationEndEvents = undefined; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +exports.inArray = inArray; +exports.stopPropagation = stopPropagation; +exports.generateID = generateID; +exports.outerHeight = outerHeight; +exports.addListener = addListener; +exports.hasClass = hasClass; +exports.addClass = addClass; +exports.removeClass = removeClass; +exports.remove = remove; +exports.classList = classList; +exports.visibilityChangeFlow = visibilityChangeFlow; +exports.createAudioElements = createAudioElements; + +var _api = __webpack_require__(1); + +var API = _interopRequireWildcard(_api); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +var animationEndEvents = exports.animationEndEvents = 'webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend'; + +function inArray(needle, haystack, argStrict) { + var key = void 0; + var strict = !!argStrict; + + if (strict) { + for (key in haystack) { + if (haystack.hasOwnProperty(key) && haystack[key] === needle) { + return true; + } + } + } else { + for (key in haystack) { + if (haystack.hasOwnProperty(key) && haystack[key] === needle) { + return true; + } + } + } + return false; +} + +function stopPropagation(evt) { + evt = evt || window.event; + + if (typeof evt.stopPropagation !== 'undefined') { + evt.stopPropagation(); + } else { + evt.cancelBubble = true; + } +} + +var deepExtend = exports.deepExtend = function deepExtend(out) { + out = out || {}; + + for (var i = 1; i < arguments.length; i++) { + var obj = arguments[i]; + + if (!obj) continue; + + for (var key in obj) { + if (obj.hasOwnProperty(key)) { + if (Array.isArray(obj[key])) { + out[key] = obj[key]; + } else if (_typeof(obj[key]) === 'object' && obj[key] !== null) { + out[key] = deepExtend(out[key], obj[key]); + } else { + out[key] = obj[key]; + } + } + } + } + + return out; +}; + +function generateID() { + var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + + var id = 'noty_' + prefix + '_'; + + id += 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) { + var r = Math.random() * 16 | 0; + var v = c === 'x' ? r : r & 0x3 | 0x8; + return v.toString(16); + }); + + return id; +} + +function outerHeight(el) { + var height = el.offsetHeight; + var style = window.getComputedStyle(el); + + height += parseInt(style.marginTop) + parseInt(style.marginBottom); + return height; +} + +var css = exports.css = function () { + var cssPrefixes = ['Webkit', 'O', 'Moz', 'ms']; + var cssProps = {}; + + function camelCase(string) { + return string.replace(/^-ms-/, 'ms-').replace(/-([\da-z])/gi, function (match, letter) { + return letter.toUpperCase(); + }); + } + + function getVendorProp(name) { + var style = document.body.style; + if (name in style) return name; + + var i = cssPrefixes.length; + var capName = name.charAt(0).toUpperCase() + name.slice(1); + var vendorName = void 0; + + while (i--) { + vendorName = cssPrefixes[i] + capName; + if (vendorName in style) return vendorName; + } + + return name; + } + + function getStyleProp(name) { + name = camelCase(name); + return cssProps[name] || (cssProps[name] = getVendorProp(name)); + } + + function applyCss(element, prop, value) { + prop = getStyleProp(prop); + element.style[prop] = value; + } + + return function (element, properties) { + var args = arguments; + var prop = void 0; + var value = void 0; + + if (args.length === 2) { + for (prop in properties) { + if (properties.hasOwnProperty(prop)) { + value = properties[prop]; + if (value !== undefined && properties.hasOwnProperty(prop)) { + applyCss(element, prop, value); + } + } + } + } else { + applyCss(element, args[1], args[2]); + } + }; +}(); + +function addListener(el, events, cb) { + var useCapture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + + events = events.split(' '); + for (var i = 0; i < events.length; i++) { + if (document.addEventListener) { + el.addEventListener(events[i], cb, useCapture); + } else if (document.attachEvent) { + el.attachEvent('on' + events[i], cb); + } + } +} + +function hasClass(element, name) { + var list = typeof element === 'string' ? element : classList(element); + return list.indexOf(' ' + name + ' ') >= 0; +} + +function addClass(element, name) { + var oldList = classList(element); + var newList = oldList + name; + + if (hasClass(oldList, name)) return; + + // Trim the opening space. + element.className = newList.substring(1); +} + +function removeClass(element, name) { + var oldList = classList(element); + var newList = void 0; + + if (!hasClass(element, name)) return; + + // Replace the class name. + newList = oldList.replace(' ' + name + ' ', ' '); + + // Trim the opening and closing spaces. + element.className = newList.substring(1, newList.length - 1); +} + +function remove(element) { + if (element.parentNode) { + element.parentNode.removeChild(element); + } +} + +function classList(element) { + return (' ' + (element && element.className || '') + ' ').replace(/\s+/gi, ' '); +} + +function visibilityChangeFlow() { + var hidden = void 0; + var visibilityChange = void 0; + if (typeof document.hidden !== 'undefined') { + // Opera 12.10 and Firefox 18 and later support + hidden = 'hidden'; + visibilityChange = 'visibilitychange'; + } else if (typeof document.msHidden !== 'undefined') { + hidden = 'msHidden'; + visibilityChange = 'msvisibilitychange'; + } else if (typeof document.webkitHidden !== 'undefined') { + hidden = 'webkitHidden'; + visibilityChange = 'webkitvisibilitychange'; + } + + function onVisibilityChange() { + API.PageHidden = document[hidden]; + handleVisibilityChange(); + } + + function onBlur() { + API.PageHidden = true; + handleVisibilityChange(); + } + + function onFocus() { + API.PageHidden = false; + handleVisibilityChange(); + } + + function handleVisibilityChange() { + if (API.PageHidden) stopAll();else resumeAll(); + } + + function stopAll() { + setTimeout(function () { + Object.keys(API.Store).forEach(function (id) { + if (API.Store.hasOwnProperty(id)) { + if (API.Store[id].options.visibilityControl) { + API.Store[id].stop(); + } + } + }); + }, 100); + } + + function resumeAll() { + setTimeout(function () { + Object.keys(API.Store).forEach(function (id) { + if (API.Store.hasOwnProperty(id)) { + if (API.Store[id].options.visibilityControl) { + API.Store[id].resume(); + } + } + }); + API.queueRenderAll(); + }, 100); + } + + if (visibilityChange) { + addListener(document, visibilityChange, onVisibilityChange); + } + + addListener(window, 'blur', onBlur); + addListener(window, 'focus', onFocus); +} + +function createAudioElements(ref) { + if (ref.hasSound) { + var audioElement = document.createElement('audio'); + + ref.options.sounds.sources.forEach(function (s) { + var source = document.createElement('source'); + source.src = s; + source.type = 'audio/' + getExtension(s); + audioElement.appendChild(source); + }); + + if (ref.barDom) { + ref.barDom.appendChild(audioElement); + } else { + document.querySelector('body').appendChild(audioElement); + } + + audioElement.volume = ref.options.sounds.volume; + + if (!ref.soundPlayed) { + audioElement.play(); + ref.soundPlayed = true; + } + + audioElement.onended = function () { + remove(audioElement); + }; + } +} + +function getExtension(fileName) { + return fileName.match(/\.([^.]+)$/)[1]; +} + +/***/ }), +/* 1 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Defaults = exports.Store = exports.Queues = exports.DefaultMaxVisible = exports.docTitle = exports.DocModalCount = exports.PageHidden = undefined; +exports.getQueueCounts = getQueueCounts; +exports.addToQueue = addToQueue; +exports.removeFromQueue = removeFromQueue; +exports.queueRender = queueRender; +exports.queueRenderAll = queueRenderAll; +exports.ghostFix = ghostFix; +exports.build = build; +exports.hasButtons = hasButtons; +exports.handleModal = handleModal; +exports.handleModalClose = handleModalClose; +exports.queueClose = queueClose; +exports.dequeueClose = dequeueClose; +exports.fire = fire; +exports.openFlow = openFlow; +exports.closeFlow = closeFlow; + +var _utils = __webpack_require__(0); + +var Utils = _interopRequireWildcard(_utils); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +var PageHidden = exports.PageHidden = false; +var DocModalCount = exports.DocModalCount = 0; + +var DocTitleProps = { + originalTitle: null, + count: 0, + changed: false, + timer: -1 +}; + +var docTitle = exports.docTitle = { + increment: function increment() { + DocTitleProps.count++; + + docTitle._update(); + }, + + decrement: function decrement() { + DocTitleProps.count--; + + if (DocTitleProps.count <= 0) { + docTitle._clear(); + return; + } + + docTitle._update(); + }, + + _update: function _update() { + var title = document.title; + + if (!DocTitleProps.changed) { + DocTitleProps.originalTitle = title; + document.title = '(' + DocTitleProps.count + ') ' + title; + DocTitleProps.changed = true; + } else { + document.title = '(' + DocTitleProps.count + ') ' + DocTitleProps.originalTitle; + } + }, + + _clear: function _clear() { + if (DocTitleProps.changed) { + DocTitleProps.count = 0; + document.title = DocTitleProps.originalTitle; + DocTitleProps.changed = false; + } + } +}; + +var DefaultMaxVisible = exports.DefaultMaxVisible = 5; + +var Queues = exports.Queues = { + global: { + maxVisible: DefaultMaxVisible, + queue: [] + } +}; + +var Store = exports.Store = {}; + +var Defaults = exports.Defaults = { + type: 'alert', + layout: 'topRight', + theme: 'mint', + text: '', + timeout: false, + progressBar: true, + closeWith: ['click'], + animation: { + open: 'noty_effects_open', + close: 'noty_effects_close' + }, + id: false, + force: false, + killer: false, + queue: 'global', + container: false, + buttons: [], + callbacks: { + beforeShow: null, + onShow: null, + afterShow: null, + onClose: null, + afterClose: null, + onClick: null, + onHover: null, + onTemplate: null + }, + sounds: { + sources: [], + volume: 1, + conditions: [] + }, + titleCount: { + conditions: [] + }, + modal: false, + visibilityControl: false + + /** + * @param {string} queueName + * @return {object} + */ +};function getQueueCounts() { + var queueName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'global'; + + var count = 0; + var max = DefaultMaxVisible; + + if (Queues.hasOwnProperty(queueName)) { + max = Queues[queueName].maxVisible; + Object.keys(Store).forEach(function (i) { + if (Store[i].options.queue === queueName && !Store[i].closed) count++; + }); + } + + return { + current: count, + maxVisible: max + }; +} + +/** + * @param {Noty} ref + * @return {void} + */ +function addToQueue(ref) { + if (!Queues.hasOwnProperty(ref.options.queue)) { + Queues[ref.options.queue] = { maxVisible: DefaultMaxVisible, queue: [] }; + } + + Queues[ref.options.queue].queue.push(ref); +} + +/** + * @param {Noty} ref + * @return {void} + */ +function removeFromQueue(ref) { + if (Queues.hasOwnProperty(ref.options.queue)) { + var queue = []; + Object.keys(Queues[ref.options.queue].queue).forEach(function (i) { + if (Queues[ref.options.queue].queue[i].id !== ref.id) { + queue.push(Queues[ref.options.queue].queue[i]); + } + }); + Queues[ref.options.queue].queue = queue; + } +} + +/** + * @param {string} queueName + * @return {void} + */ +function queueRender() { + var queueName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'global'; + + if (Queues.hasOwnProperty(queueName)) { + var noty = Queues[queueName].queue.shift(); + + if (noty) noty.show(); + } +} + +/** + * @return {void} + */ +function queueRenderAll() { + Object.keys(Queues).forEach(function (queueName) { + queueRender(queueName); + }); +} + +/** + * @param {Noty} ref + * @return {void} + */ +function ghostFix(ref) { + var ghostID = Utils.generateID('ghost'); + var ghost = document.createElement('div'); + ghost.setAttribute('id', ghostID); + Utils.css(ghost, { + height: Utils.outerHeight(ref.barDom) + 'px' + }); + + ref.barDom.insertAdjacentHTML('afterend', ghost.outerHTML); + + Utils.remove(ref.barDom); + ghost = document.getElementById(ghostID); + Utils.addClass(ghost, 'noty_fix_effects_height'); + Utils.addListener(ghost, Utils.animationEndEvents, function () { + Utils.remove(ghost); + }); +} + +/** + * @param {Noty} ref + * @return {void} + */ +function build(ref) { + findOrCreateContainer(ref); + + var markup = '
' + ref.options.text + '
' + buildButtons(ref) + '
'; + + ref.barDom = document.createElement('div'); + ref.barDom.setAttribute('id', ref.id); + Utils.addClass(ref.barDom, 'noty_bar noty_type__' + ref.options.type + ' noty_theme__' + ref.options.theme); + + ref.barDom.innerHTML = markup; + + fire(ref, 'onTemplate'); +} + +/** + * @param {Noty} ref + * @return {boolean} + */ +function hasButtons(ref) { + return !!(ref.options.buttons && Object.keys(ref.options.buttons).length); +} + +/** + * @param {Noty} ref + * @return {string} + */ +function buildButtons(ref) { + if (hasButtons(ref)) { + var buttons = document.createElement('div'); + Utils.addClass(buttons, 'noty_buttons'); + + Object.keys(ref.options.buttons).forEach(function (key) { + buttons.appendChild(ref.options.buttons[key].dom); + }); + + ref.options.buttons.forEach(function (btn) { + buttons.appendChild(btn.dom); + }); + return buttons.outerHTML; + } + return ''; +} + +/** + * @param {Noty} ref + * @return {void} + */ +function handleModal(ref) { + if (ref.options.modal) { + if (DocModalCount === 0) { + createModal(ref); + } + + exports.DocModalCount = DocModalCount += 1; + } +} + +/** + * @param {Noty} ref + * @return {void} + */ +function handleModalClose(ref) { + if (ref.options.modal && DocModalCount > 0) { + exports.DocModalCount = DocModalCount -= 1; + + if (DocModalCount <= 0) { + var modal = document.querySelector('.noty_modal'); + + if (modal) { + Utils.removeClass(modal, 'noty_modal_open'); + Utils.addClass(modal, 'noty_modal_close'); + Utils.addListener(modal, Utils.animationEndEvents, function () { + Utils.remove(modal); + }); + } + } + } +} + +/** + * @return {void} + */ +function createModal() { + var body = document.querySelector('body'); + var modal = document.createElement('div'); + Utils.addClass(modal, 'noty_modal'); + body.insertBefore(modal, body.firstChild); + Utils.addClass(modal, 'noty_modal_open'); + + Utils.addListener(modal, Utils.animationEndEvents, function () { + Utils.removeClass(modal, 'noty_modal_open'); + }); +} + +/** + * @param {Noty} ref + * @return {void} + */ +function findOrCreateContainer(ref) { + if (ref.options.container) { + ref.layoutDom = document.querySelector(ref.options.container); + return; + } + + var layoutID = 'noty_layout__' + ref.options.layout; + ref.layoutDom = document.querySelector('div#' + layoutID); + + if (!ref.layoutDom) { + ref.layoutDom = document.createElement('div'); + ref.layoutDom.setAttribute('id', layoutID); + ref.layoutDom.setAttribute('role', 'alert'); + ref.layoutDom.setAttribute('aria-live', 'polite'); + Utils.addClass(ref.layoutDom, 'noty_layout'); + document.querySelector('body').appendChild(ref.layoutDom); + } +} + +/** + * @param {Noty} ref + * @return {void} + */ +function queueClose(ref) { + if (ref.options.timeout) { + if (ref.options.progressBar && ref.progressDom) { + Utils.css(ref.progressDom, { + transition: 'width ' + ref.options.timeout + 'ms linear', + width: '0%' + }); + } + + clearTimeout(ref.closeTimer); + + ref.closeTimer = setTimeout(function () { + ref.close(); + }, ref.options.timeout); + } +} + +/** + * @param {Noty} ref + * @return {void} + */ +function dequeueClose(ref) { + if (ref.options.timeout && ref.closeTimer) { + clearTimeout(ref.closeTimer); + ref.closeTimer = -1; + + if (ref.options.progressBar && ref.progressDom) { + Utils.css(ref.progressDom, { + transition: 'width 0ms linear', + width: '100%' + }); + } + } +} + +/** + * @param {Noty} ref + * @param {string} eventName + * @return {void} + */ +function fire(ref, eventName) { + if (ref.listeners.hasOwnProperty(eventName)) { + ref.listeners[eventName].forEach(function (cb) { + if (typeof cb === 'function') { + cb.apply(ref); + } + }); + } +} + +/** + * @param {Noty} ref + * @return {void} + */ +function openFlow(ref) { + fire(ref, 'afterShow'); + queueClose(ref); + + Utils.addListener(ref.barDom, 'mouseenter', function () { + dequeueClose(ref); + }); + + Utils.addListener(ref.barDom, 'mouseleave', function () { + queueClose(ref); + }); +} + +/** + * @param {Noty} ref + * @return {void} + */ +function closeFlow(ref) { + delete Store[ref.id]; + ref.closing = false; + fire(ref, 'afterClose'); + + Utils.remove(ref.barDom); + + if (ref.layoutDom.querySelectorAll('.noty_bar').length === 0 && !ref.options.container) { + Utils.remove(ref.layoutDom); + } + + if (Utils.inArray('docVisible', ref.options.titleCount.conditions) || Utils.inArray('docHidden', ref.options.titleCount.conditions)) { + docTitle.decrement(); + } + + queueRender(ref.options.queue); +} + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.NotyButton = undefined; + +var _utils = __webpack_require__(0); + +var Utils = _interopRequireWildcard(_utils); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var NotyButton = exports.NotyButton = function NotyButton(html, classes, cb) { + var _this = this; + + var attributes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {}; + + _classCallCheck(this, NotyButton); + + this.dom = document.createElement('button'); + this.dom.innerHTML = html; + this.id = attributes.id = attributes.id || Utils.generateID('button'); + this.cb = cb; + Object.keys(attributes).forEach(function (propertyName) { + _this.dom.setAttribute(propertyName, attributes[propertyName]); + }); + Utils.addClass(this.dom, classes || 'noty_btn'); + + return this; +}; + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Push = exports.Push = function () { + function Push() { + var workerPath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '/service-worker.js'; + + _classCallCheck(this, Push); + + this.subData = {}; + this.workerPath = workerPath; + this.listeners = { + onPermissionGranted: [], + onPermissionDenied: [], + onSubscriptionSuccess: [], + onSubscriptionCancel: [], + onWorkerError: [], + onWorkerSuccess: [], + onWorkerNotSupported: [] + }; + return this; + } + + /** + * @param {string} eventName + * @param {function} cb + * @return {Push} + */ + + + _createClass(Push, [{ + key: 'on', + value: function on(eventName) { + var cb = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {}; + + if (typeof cb === 'function' && this.listeners.hasOwnProperty(eventName)) { + this.listeners[eventName].push(cb); + } + + return this; + } + }, { + key: 'fire', + value: function fire(eventName) { + var _this = this; + + var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + + if (this.listeners.hasOwnProperty(eventName)) { + this.listeners[eventName].forEach(function (cb) { + if (typeof cb === 'function') { + cb.apply(_this, params); + } + }); + } + } + }, { + key: 'create', + value: function create() { + console.log('NOT IMPLEMENTED YET'); + } + + /** + * @return {boolean} + */ + + }, { + key: 'isSupported', + value: function isSupported() { + var result = false; + + try { + result = window.Notification || window.webkitNotifications || navigator.mozNotification || window.external && window.external.msIsSiteMode() !== undefined; + } catch (e) {} + + return result; + } + + /** + * @return {string} + */ + + }, { + key: 'getPermissionStatus', + value: function getPermissionStatus() { + var perm = 'default'; + + if (window.Notification && window.Notification.permissionLevel) { + perm = window.Notification.permissionLevel; + } else if (window.webkitNotifications && window.webkitNotifications.checkPermission) { + switch (window.webkitNotifications.checkPermission()) { + case 1: + perm = 'default'; + break; + case 0: + perm = 'granted'; + break; + default: + perm = 'denied'; + } + } else if (window.Notification && window.Notification.permission) { + perm = window.Notification.permission; + } else if (navigator.mozNotification) { + perm = 'granted'; + } else if (window.external && window.external.msIsSiteMode() !== undefined) { + perm = window.external.msIsSiteMode() ? 'granted' : 'default'; + } + + return perm.toString().toLowerCase(); + } + + /** + * @return {string} + */ + + }, { + key: 'getEndpoint', + value: function getEndpoint(subscription) { + var endpoint = subscription.endpoint; + var subscriptionId = subscription.subscriptionId; + + // fix for Chrome < 45 + if (subscriptionId && endpoint.indexOf(subscriptionId) === -1) { + endpoint += '/' + subscriptionId; + } + + return endpoint; + } + + /** + * @return {boolean} + */ + + }, { + key: 'isSWRegistered', + value: function isSWRegistered() { + try { + return navigator.serviceWorker.controller.state === 'activated'; + } catch (e) { + return false; + } + } + + /** + * @return {void} + */ + + }, { + key: 'unregisterWorker', + value: function unregisterWorker() { + var self = this; + if ('serviceWorker' in navigator) { + navigator.serviceWorker.getRegistrations().then(function (registrations) { + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = registrations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var registration = _step.value; + + registration.unregister(); + self.fire('onSubscriptionCancel'); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + }); + } + } + + /** + * @return {void} + */ + + }, { + key: 'requestSubscription', + value: function requestSubscription() { + var _this2 = this; + + var userVisibleOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + var self = this; + var current = this.getPermissionStatus(); + var cb = function cb(result) { + if (result === 'granted') { + _this2.fire('onPermissionGranted'); + + if ('serviceWorker' in navigator) { + navigator.serviceWorker.register(_this2.workerPath).then(function () { + navigator.serviceWorker.ready.then(function (serviceWorkerRegistration) { + self.fire('onWorkerSuccess'); + serviceWorkerRegistration.pushManager.subscribe({ + userVisibleOnly: userVisibleOnly + }).then(function (subscription) { + var key = subscription.getKey('p256dh'); + var token = subscription.getKey('auth'); + + self.subData = { + endpoint: self.getEndpoint(subscription), + p256dh: key ? window.btoa(String.fromCharCode.apply(null, new Uint8Array(key))) : null, + auth: token ? window.btoa(String.fromCharCode.apply(null, new Uint8Array(token))) : null + }; + + self.fire('onSubscriptionSuccess', [self.subData]); + }).catch(function (err) { + self.fire('onWorkerError', [err]); + }); + }); + }); + } else { + self.fire('onWorkerNotSupported'); + } + } else if (result === 'denied') { + _this2.fire('onPermissionDenied'); + _this2.unregisterWorker(); + } + }; + + if (current === 'default') { + if (window.Notification && window.Notification.requestPermission) { + window.Notification.requestPermission(cb); + } else if (window.webkitNotifications && window.webkitNotifications.checkPermission) { + window.webkitNotifications.requestPermission(cb); + } + } else { + cb(current); + } + } + }]); + + return Push; +}(); + +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(process, global) {var require;/*! + * @overview es6-promise - a tiny implementation of Promises/A+. + * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald) + * @license Licensed under MIT license + * See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE + * @version 4.1.1 + */ + +(function (global, factory) { + true ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global.ES6Promise = factory()); +}(this, (function () { 'use strict'; + +function objectOrFunction(x) { + var type = typeof x; + return x !== null && (type === 'object' || type === 'function'); +} + +function isFunction(x) { + return typeof x === 'function'; +} + +var _isArray = undefined; +if (Array.isArray) { + _isArray = Array.isArray; +} else { + _isArray = function (x) { + return Object.prototype.toString.call(x) === '[object Array]'; + }; +} + +var isArray = _isArray; + +var len = 0; +var vertxNext = undefined; +var customSchedulerFn = undefined; + +var asap = function asap(callback, arg) { + queue[len] = callback; + queue[len + 1] = arg; + len += 2; + if (len === 2) { + // If len is 2, that means that we need to schedule an async flush. + // If additional callbacks are queued before the queue is flushed, they + // will be processed by this flush that we are scheduling. + if (customSchedulerFn) { + customSchedulerFn(flush); + } else { + scheduleFlush(); + } + } +}; + +function setScheduler(scheduleFn) { + customSchedulerFn = scheduleFn; +} + +function setAsap(asapFn) { + asap = asapFn; +} + +var browserWindow = typeof window !== 'undefined' ? window : undefined; +var browserGlobal = browserWindow || {}; +var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver; +var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && ({}).toString.call(process) === '[object process]'; + +// test for web worker but not in IE10 +var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined'; + +// node +function useNextTick() { + // node version 0.10.x displays a deprecation warning when nextTick is used recursively + // see https://github.com/cujojs/when/issues/410 for details + return function () { + return process.nextTick(flush); + }; +} + +// vertx +function useVertxTimer() { + if (typeof vertxNext !== 'undefined') { + return function () { + vertxNext(flush); + }; + } + + return useSetTimeout(); +} + +function useMutationObserver() { + var iterations = 0; + var observer = new BrowserMutationObserver(flush); + var node = document.createTextNode(''); + observer.observe(node, { characterData: true }); + + return function () { + node.data = iterations = ++iterations % 2; + }; +} + +// web worker +function useMessageChannel() { + var channel = new MessageChannel(); + channel.port1.onmessage = flush; + return function () { + return channel.port2.postMessage(0); + }; +} + +function useSetTimeout() { + // Store setTimeout reference so es6-promise will be unaffected by + // other code modifying setTimeout (like sinon.useFakeTimers()) + var globalSetTimeout = setTimeout; + return function () { + return globalSetTimeout(flush, 1); + }; +} + +var queue = new Array(1000); +function flush() { + for (var i = 0; i < len; i += 2) { + var callback = queue[i]; + var arg = queue[i + 1]; + + callback(arg); + + queue[i] = undefined; + queue[i + 1] = undefined; + } + + len = 0; +} + +function attemptVertx() { + try { + var r = require; + var vertx = __webpack_require__(9); + vertxNext = vertx.runOnLoop || vertx.runOnContext; + return useVertxTimer(); + } catch (e) { + return useSetTimeout(); + } +} + +var scheduleFlush = undefined; +// Decide what async method to use to triggering processing of queued callbacks: +if (isNode) { + scheduleFlush = useNextTick(); +} else if (BrowserMutationObserver) { + scheduleFlush = useMutationObserver(); +} else if (isWorker) { + scheduleFlush = useMessageChannel(); +} else if (browserWindow === undefined && "function" === 'function') { + scheduleFlush = attemptVertx(); +} else { + scheduleFlush = useSetTimeout(); +} + +function then(onFulfillment, onRejection) { + var _arguments = arguments; + + var parent = this; + + var child = new this.constructor(noop); + + if (child[PROMISE_ID] === undefined) { + makePromise(child); + } + + var _state = parent._state; + + if (_state) { + (function () { + var callback = _arguments[_state - 1]; + asap(function () { + return invokeCallback(_state, child, callback, parent._result); + }); + })(); + } else { + subscribe(parent, child, onFulfillment, onRejection); + } + + return child; +} + +/** + `Promise.resolve` returns a promise that will become resolved with the + passed `value`. It is shorthand for the following: + + ```javascript + let promise = new Promise(function(resolve, reject){ + resolve(1); + }); + + promise.then(function(value){ + // value === 1 + }); + ``` + + Instead of writing the above, your code now simply becomes the following: + + ```javascript + let promise = Promise.resolve(1); + + promise.then(function(value){ + // value === 1 + }); + ``` + + @method resolve + @static + @param {Any} value value that the returned promise will be resolved with + Useful for tooling. + @return {Promise} a promise that will become fulfilled with the given + `value` +*/ +function resolve$1(object) { + /*jshint validthis:true */ + var Constructor = this; + + if (object && typeof object === 'object' && object.constructor === Constructor) { + return object; + } + + var promise = new Constructor(noop); + resolve(promise, object); + return promise; +} + +var PROMISE_ID = Math.random().toString(36).substring(16); + +function noop() {} + +var PENDING = void 0; +var FULFILLED = 1; +var REJECTED = 2; + +var GET_THEN_ERROR = new ErrorObject(); + +function selfFulfillment() { + return new TypeError("You cannot resolve a promise with itself"); +} + +function cannotReturnOwn() { + return new TypeError('A promises callback cannot return that same promise.'); +} + +function getThen(promise) { + try { + return promise.then; + } catch (error) { + GET_THEN_ERROR.error = error; + return GET_THEN_ERROR; + } +} + +function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) { + try { + then$$1.call(value, fulfillmentHandler, rejectionHandler); + } catch (e) { + return e; + } +} + +function handleForeignThenable(promise, thenable, then$$1) { + asap(function (promise) { + var sealed = false; + var error = tryThen(then$$1, thenable, function (value) { + if (sealed) { + return; + } + sealed = true; + if (thenable !== value) { + resolve(promise, value); + } else { + fulfill(promise, value); + } + }, function (reason) { + if (sealed) { + return; + } + sealed = true; + + reject(promise, reason); + }, 'Settle: ' + (promise._label || ' unknown promise')); + + if (!sealed && error) { + sealed = true; + reject(promise, error); + } + }, promise); +} + +function handleOwnThenable(promise, thenable) { + if (thenable._state === FULFILLED) { + fulfill(promise, thenable._result); + } else if (thenable._state === REJECTED) { + reject(promise, thenable._result); + } else { + subscribe(thenable, undefined, function (value) { + return resolve(promise, value); + }, function (reason) { + return reject(promise, reason); + }); + } +} + +function handleMaybeThenable(promise, maybeThenable, then$$1) { + if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) { + handleOwnThenable(promise, maybeThenable); + } else { + if (then$$1 === GET_THEN_ERROR) { + reject(promise, GET_THEN_ERROR.error); + GET_THEN_ERROR.error = null; + } else if (then$$1 === undefined) { + fulfill(promise, maybeThenable); + } else if (isFunction(then$$1)) { + handleForeignThenable(promise, maybeThenable, then$$1); + } else { + fulfill(promise, maybeThenable); + } + } +} + +function resolve(promise, value) { + if (promise === value) { + reject(promise, selfFulfillment()); + } else if (objectOrFunction(value)) { + handleMaybeThenable(promise, value, getThen(value)); + } else { + fulfill(promise, value); + } +} + +function publishRejection(promise) { + if (promise._onerror) { + promise._onerror(promise._result); + } + + publish(promise); +} + +function fulfill(promise, value) { + if (promise._state !== PENDING) { + return; + } + + promise._result = value; + promise._state = FULFILLED; + + if (promise._subscribers.length !== 0) { + asap(publish, promise); + } +} + +function reject(promise, reason) { + if (promise._state !== PENDING) { + return; + } + promise._state = REJECTED; + promise._result = reason; + + asap(publishRejection, promise); +} + +function subscribe(parent, child, onFulfillment, onRejection) { + var _subscribers = parent._subscribers; + var length = _subscribers.length; + + parent._onerror = null; + + _subscribers[length] = child; + _subscribers[length + FULFILLED] = onFulfillment; + _subscribers[length + REJECTED] = onRejection; + + if (length === 0 && parent._state) { + asap(publish, parent); + } +} + +function publish(promise) { + var subscribers = promise._subscribers; + var settled = promise._state; + + if (subscribers.length === 0) { + return; + } + + var child = undefined, + callback = undefined, + detail = promise._result; + + for (var i = 0; i < subscribers.length; i += 3) { + child = subscribers[i]; + callback = subscribers[i + settled]; + + if (child) { + invokeCallback(settled, child, callback, detail); + } else { + callback(detail); + } + } + + promise._subscribers.length = 0; +} + +function ErrorObject() { + this.error = null; +} + +var TRY_CATCH_ERROR = new ErrorObject(); + +function tryCatch(callback, detail) { + try { + return callback(detail); + } catch (e) { + TRY_CATCH_ERROR.error = e; + return TRY_CATCH_ERROR; + } +} + +function invokeCallback(settled, promise, callback, detail) { + var hasCallback = isFunction(callback), + value = undefined, + error = undefined, + succeeded = undefined, + failed = undefined; + + if (hasCallback) { + value = tryCatch(callback, detail); + + if (value === TRY_CATCH_ERROR) { + failed = true; + error = value.error; + value.error = null; + } else { + succeeded = true; + } + + if (promise === value) { + reject(promise, cannotReturnOwn()); + return; + } + } else { + value = detail; + succeeded = true; + } + + if (promise._state !== PENDING) { + // noop + } else if (hasCallback && succeeded) { + resolve(promise, value); + } else if (failed) { + reject(promise, error); + } else if (settled === FULFILLED) { + fulfill(promise, value); + } else if (settled === REJECTED) { + reject(promise, value); + } +} + +function initializePromise(promise, resolver) { + try { + resolver(function resolvePromise(value) { + resolve(promise, value); + }, function rejectPromise(reason) { + reject(promise, reason); + }); + } catch (e) { + reject(promise, e); + } +} + +var id = 0; +function nextId() { + return id++; +} + +function makePromise(promise) { + promise[PROMISE_ID] = id++; + promise._state = undefined; + promise._result = undefined; + promise._subscribers = []; +} + +function Enumerator$1(Constructor, input) { + this._instanceConstructor = Constructor; + this.promise = new Constructor(noop); + + if (!this.promise[PROMISE_ID]) { + makePromise(this.promise); + } + + if (isArray(input)) { + this.length = input.length; + this._remaining = input.length; + + this._result = new Array(this.length); + + if (this.length === 0) { + fulfill(this.promise, this._result); + } else { + this.length = this.length || 0; + this._enumerate(input); + if (this._remaining === 0) { + fulfill(this.promise, this._result); + } + } + } else { + reject(this.promise, validationError()); + } +} + +function validationError() { + return new Error('Array Methods must be provided an Array'); +} + +Enumerator$1.prototype._enumerate = function (input) { + for (var i = 0; this._state === PENDING && i < input.length; i++) { + this._eachEntry(input[i], i); + } +}; + +Enumerator$1.prototype._eachEntry = function (entry, i) { + var c = this._instanceConstructor; + var resolve$$1 = c.resolve; + + if (resolve$$1 === resolve$1) { + var _then = getThen(entry); + + if (_then === then && entry._state !== PENDING) { + this._settledAt(entry._state, i, entry._result); + } else if (typeof _then !== 'function') { + this._remaining--; + this._result[i] = entry; + } else if (c === Promise$2) { + var promise = new c(noop); + handleMaybeThenable(promise, entry, _then); + this._willSettleAt(promise, i); + } else { + this._willSettleAt(new c(function (resolve$$1) { + return resolve$$1(entry); + }), i); + } + } else { + this._willSettleAt(resolve$$1(entry), i); + } +}; + +Enumerator$1.prototype._settledAt = function (state, i, value) { + var promise = this.promise; + + if (promise._state === PENDING) { + this._remaining--; + + if (state === REJECTED) { + reject(promise, value); + } else { + this._result[i] = value; + } + } + + if (this._remaining === 0) { + fulfill(promise, this._result); + } +}; + +Enumerator$1.prototype._willSettleAt = function (promise, i) { + var enumerator = this; + + subscribe(promise, undefined, function (value) { + return enumerator._settledAt(FULFILLED, i, value); + }, function (reason) { + return enumerator._settledAt(REJECTED, i, reason); + }); +}; + +/** + `Promise.all` accepts an array of promises, and returns a new promise which + is fulfilled with an array of fulfillment values for the passed promises, or + rejected with the reason of the first passed promise to be rejected. It casts all + elements of the passed iterable to promises as it runs this algorithm. + + Example: + + ```javascript + let promise1 = resolve(1); + let promise2 = resolve(2); + let promise3 = resolve(3); + let promises = [ promise1, promise2, promise3 ]; + + Promise.all(promises).then(function(array){ + // The array here would be [ 1, 2, 3 ]; + }); + ``` + + If any of the `promises` given to `all` are rejected, the first promise + that is rejected will be given as an argument to the returned promises's + rejection handler. For example: + + Example: + + ```javascript + let promise1 = resolve(1); + let promise2 = reject(new Error("2")); + let promise3 = reject(new Error("3")); + let promises = [ promise1, promise2, promise3 ]; + + Promise.all(promises).then(function(array){ + // Code here never runs because there are rejected promises! + }, function(error) { + // error.message === "2" + }); + ``` + + @method all + @static + @param {Array} entries array of promises + @param {String} label optional string for labeling the promise. + Useful for tooling. + @return {Promise} promise that is fulfilled when all `promises` have been + fulfilled, or rejected if any of them become rejected. + @static +*/ +function all$1(entries) { + return new Enumerator$1(this, entries).promise; +} + +/** + `Promise.race` returns a new promise which is settled in the same way as the + first passed promise to settle. + + Example: + + ```javascript + let promise1 = new Promise(function(resolve, reject){ + setTimeout(function(){ + resolve('promise 1'); + }, 200); + }); + + let promise2 = new Promise(function(resolve, reject){ + setTimeout(function(){ + resolve('promise 2'); + }, 100); + }); + + Promise.race([promise1, promise2]).then(function(result){ + // result === 'promise 2' because it was resolved before promise1 + // was resolved. + }); + ``` + + `Promise.race` is deterministic in that only the state of the first + settled promise matters. For example, even if other promises given to the + `promises` array argument are resolved, but the first settled promise has + become rejected before the other promises became fulfilled, the returned + promise will become rejected: + + ```javascript + let promise1 = new Promise(function(resolve, reject){ + setTimeout(function(){ + resolve('promise 1'); + }, 200); + }); + + let promise2 = new Promise(function(resolve, reject){ + setTimeout(function(){ + reject(new Error('promise 2')); + }, 100); + }); + + Promise.race([promise1, promise2]).then(function(result){ + // Code here never runs + }, function(reason){ + // reason.message === 'promise 2' because promise 2 became rejected before + // promise 1 became fulfilled + }); + ``` + + An example real-world use case is implementing timeouts: + + ```javascript + Promise.race([ajax('foo.json'), timeout(5000)]) + ``` + + @method race + @static + @param {Array} promises array of promises to observe + Useful for tooling. + @return {Promise} a promise which settles in the same way as the first passed + promise to settle. +*/ +function race$1(entries) { + /*jshint validthis:true */ + var Constructor = this; + + if (!isArray(entries)) { + return new Constructor(function (_, reject) { + return reject(new TypeError('You must pass an array to race.')); + }); + } else { + return new Constructor(function (resolve, reject) { + var length = entries.length; + for (var i = 0; i < length; i++) { + Constructor.resolve(entries[i]).then(resolve, reject); + } + }); + } +} + +/** + `Promise.reject` returns a promise rejected with the passed `reason`. + It is shorthand for the following: + + ```javascript + let promise = new Promise(function(resolve, reject){ + reject(new Error('WHOOPS')); + }); + + promise.then(function(value){ + // Code here doesn't run because the promise is rejected! + }, function(reason){ + // reason.message === 'WHOOPS' + }); + ``` + + Instead of writing the above, your code now simply becomes the following: + + ```javascript + let promise = Promise.reject(new Error('WHOOPS')); + + promise.then(function(value){ + // Code here doesn't run because the promise is rejected! + }, function(reason){ + // reason.message === 'WHOOPS' + }); + ``` + + @method reject + @static + @param {Any} reason value that the returned promise will be rejected with. + Useful for tooling. + @return {Promise} a promise rejected with the given `reason`. +*/ +function reject$1(reason) { + /*jshint validthis:true */ + var Constructor = this; + var promise = new Constructor(noop); + reject(promise, reason); + return promise; +} + +function needsResolver() { + throw new TypeError('You must pass a resolver function as the first argument to the promise constructor'); +} + +function needsNew() { + throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."); +} + +/** + Promise objects represent the eventual result of an asynchronous operation. The + primary way of interacting with a promise is through its `then` method, which + registers callbacks to receive either a promise's eventual value or the reason + why the promise cannot be fulfilled. + + Terminology + ----------- + + - `promise` is an object or function with a `then` method whose behavior conforms to this specification. + - `thenable` is an object or function that defines a `then` method. + - `value` is any legal JavaScript value (including undefined, a thenable, or a promise). + - `exception` is a value that is thrown using the throw statement. + - `reason` is a value that indicates why a promise was rejected. + - `settled` the final resting state of a promise, fulfilled or rejected. + + A promise can be in one of three states: pending, fulfilled, or rejected. + + Promises that are fulfilled have a fulfillment value and are in the fulfilled + state. Promises that are rejected have a rejection reason and are in the + rejected state. A fulfillment value is never a thenable. + + Promises can also be said to *resolve* a value. If this value is also a + promise, then the original promise's settled state will match the value's + settled state. So a promise that *resolves* a promise that rejects will + itself reject, and a promise that *resolves* a promise that fulfills will + itself fulfill. + + + Basic Usage: + ------------ + + ```js + let promise = new Promise(function(resolve, reject) { + // on success + resolve(value); + + // on failure + reject(reason); + }); + + promise.then(function(value) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Advanced Usage: + --------------- + + Promises shine when abstracting away asynchronous interactions such as + `XMLHttpRequest`s. + + ```js + function getJSON(url) { + return new Promise(function(resolve, reject){ + let xhr = new XMLHttpRequest(); + + xhr.open('GET', url); + xhr.onreadystatechange = handler; + xhr.responseType = 'json'; + xhr.setRequestHeader('Accept', 'application/json'); + xhr.send(); + + function handler() { + if (this.readyState === this.DONE) { + if (this.status === 200) { + resolve(this.response); + } else { + reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']')); + } + } + }; + }); + } + + getJSON('/posts.json').then(function(json) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Unlike callbacks, promises are great composable primitives. + + ```js + Promise.all([ + getJSON('/posts'), + getJSON('/comments') + ]).then(function(values){ + values[0] // => postsJSON + values[1] // => commentsJSON + + return values; + }); + ``` + + @class Promise + @param {function} resolver + Useful for tooling. + @constructor +*/ +function Promise$2(resolver) { + this[PROMISE_ID] = nextId(); + this._result = this._state = undefined; + this._subscribers = []; + + if (noop !== resolver) { + typeof resolver !== 'function' && needsResolver(); + this instanceof Promise$2 ? initializePromise(this, resolver) : needsNew(); + } +} + +Promise$2.all = all$1; +Promise$2.race = race$1; +Promise$2.resolve = resolve$1; +Promise$2.reject = reject$1; +Promise$2._setScheduler = setScheduler; +Promise$2._setAsap = setAsap; +Promise$2._asap = asap; + +Promise$2.prototype = { + constructor: Promise$2, + + /** + The primary way of interacting with a promise is through its `then` method, + which registers callbacks to receive either a promise's eventual value or the + reason why the promise cannot be fulfilled. + + ```js + findUser().then(function(user){ + // user is available + }, function(reason){ + // user is unavailable, and you are given the reason why + }); + ``` + + Chaining + -------- + + The return value of `then` is itself a promise. This second, 'downstream' + promise is resolved with the return value of the first promise's fulfillment + or rejection handler, or rejected if the handler throws an exception. + + ```js + findUser().then(function (user) { + return user.name; + }, function (reason) { + return 'default name'; + }).then(function (userName) { + // If `findUser` fulfilled, `userName` will be the user's name, otherwise it + // will be `'default name'` + }); + + findUser().then(function (user) { + throw new Error('Found user, but still unhappy'); + }, function (reason) { + throw new Error('`findUser` rejected and we're unhappy'); + }).then(function (value) { + // never reached + }, function (reason) { + // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'. + // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'. + }); + ``` + If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream. + + ```js + findUser().then(function (user) { + throw new PedagogicalException('Upstream error'); + }).then(function (value) { + // never reached + }).then(function (value) { + // never reached + }, function (reason) { + // The `PedgagocialException` is propagated all the way down to here + }); + ``` + + Assimilation + ------------ + + Sometimes the value you want to propagate to a downstream promise can only be + retrieved asynchronously. This can be achieved by returning a promise in the + fulfillment or rejection handler. The downstream promise will then be pending + until the returned promise is settled. This is called *assimilation*. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // The user's comments are now available + }); + ``` + + If the assimliated promise rejects, then the downstream promise will also reject. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // If `findCommentsByAuthor` fulfills, we'll have the value here + }, function (reason) { + // If `findCommentsByAuthor` rejects, we'll have the reason here + }); + ``` + + Simple Example + -------------- + + Synchronous Example + + ```javascript + let result; + + try { + result = findResult(); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + findResult(function(result, err){ + if (err) { + // failure + } else { + // success + } + }); + ``` + + Promise Example; + + ```javascript + findResult().then(function(result){ + // success + }, function(reason){ + // failure + }); + ``` + + Advanced Example + -------------- + + Synchronous Example + + ```javascript + let author, books; + + try { + author = findAuthor(); + books = findBooksByAuthor(author); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + + function foundBooks(books) { + + } + + function failure(reason) { + + } + + findAuthor(function(author, err){ + if (err) { + failure(err); + // failure + } else { + try { + findBoooksByAuthor(author, function(books, err) { + if (err) { + failure(err); + } else { + try { + foundBooks(books); + } catch(reason) { + failure(reason); + } + } + }); + } catch(error) { + failure(err); + } + // success + } + }); + ``` + + Promise Example; + + ```javascript + findAuthor(). + then(findBooksByAuthor). + then(function(books){ + // found books + }).catch(function(reason){ + // something went wrong + }); + ``` + + @method then + @param {Function} onFulfilled + @param {Function} onRejected + Useful for tooling. + @return {Promise} + */ + then: then, + + /** + `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same + as the catch block of a try/catch statement. + + ```js + function findAuthor(){ + throw new Error('couldn't find that author'); + } + + // synchronous + try { + findAuthor(); + } catch(reason) { + // something went wrong + } + + // async with promises + findAuthor().catch(function(reason){ + // something went wrong + }); + ``` + + @method catch + @param {Function} onRejection + Useful for tooling. + @return {Promise} + */ + 'catch': function _catch(onRejection) { + return this.then(null, onRejection); + } +}; + +/*global self*/ +function polyfill$1() { + var local = undefined; + + if (typeof global !== 'undefined') { + local = global; + } else if (typeof self !== 'undefined') { + local = self; + } else { + try { + local = Function('return this')(); + } catch (e) { + throw new Error('polyfill failed because global object is unavailable in this environment'); + } + } + + var P = local.Promise; + + if (P) { + var promiseToString = null; + try { + promiseToString = Object.prototype.toString.call(P.resolve()); + } catch (e) { + // silently ignored + } + + if (promiseToString === '[object Promise]' && !P.cast) { + return; + } + } + + local.Promise = Promise$2; +} + +// Strange compat.. +Promise$2.polyfill = polyfill$1; +Promise$2.Promise = Promise$2; + +return Promise$2; + +}))); + +//# sourceMappingURL=es6-promise.map + +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(7), __webpack_require__(8))) + +/***/ }), +/* 5 */ +/***/ (function(module, exports) { + +// removed by extract-text-webpack-plugin + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /* global VERSION */ + +__webpack_require__(5); + +var _es6Promise = __webpack_require__(4); + +var _es6Promise2 = _interopRequireDefault(_es6Promise); + +var _utils = __webpack_require__(0); + +var Utils = _interopRequireWildcard(_utils); + +var _api = __webpack_require__(1); + +var API = _interopRequireWildcard(_api); + +var _button = __webpack_require__(2); + +var _push = __webpack_require__(3); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Noty = function () { + /** + * @param {object} options + * @return {Noty} + */ + function Noty() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + _classCallCheck(this, Noty); + + this.options = Utils.deepExtend({}, API.Defaults, options); + + if (API.Store[this.options.id]) { + return API.Store[this.options.id]; + } + + this.id = this.options.id || Utils.generateID('bar'); + this.closeTimer = -1; + this.barDom = null; + this.layoutDom = null; + this.progressDom = null; + this.showing = false; + this.shown = false; + this.closed = false; + this.closing = false; + this.killable = this.options.timeout || this.options.closeWith.length > 0; + this.hasSound = this.options.sounds.sources.length > 0; + this.soundPlayed = false; + this.listeners = { + beforeShow: [], + onShow: [], + afterShow: [], + onClose: [], + afterClose: [], + onClick: [], + onHover: [], + onTemplate: [] + }; + this.promises = { + show: null, + close: null + }; + this.on('beforeShow', this.options.callbacks.beforeShow); + this.on('onShow', this.options.callbacks.onShow); + this.on('afterShow', this.options.callbacks.afterShow); + this.on('onClose', this.options.callbacks.onClose); + this.on('afterClose', this.options.callbacks.afterClose); + this.on('onClick', this.options.callbacks.onClick); + this.on('onHover', this.options.callbacks.onHover); + this.on('onTemplate', this.options.callbacks.onTemplate); + + return this; + } + + /** + * @param {string} eventName + * @param {function} cb + * @return {Noty} + */ + + + _createClass(Noty, [{ + key: 'on', + value: function on(eventName) { + var cb = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {}; + + if (typeof cb === 'function' && this.listeners.hasOwnProperty(eventName)) { + this.listeners[eventName].push(cb); + } + + return this; + } + + /** + * @return {Noty} + */ + + }, { + key: 'show', + value: function show() { + var _this = this; + + if (this.showing || this.shown) { + return this; // preventing multiple show + } + + if (this.options.killer === true) { + Noty.closeAll(); + } else if (typeof this.options.killer === 'string') { + Noty.closeAll(this.options.killer); + } + + var queueCounts = API.getQueueCounts(this.options.queue); + + if (queueCounts.current >= queueCounts.maxVisible || API.PageHidden && this.options.visibilityControl) { + API.addToQueue(this); + + if (API.PageHidden && this.hasSound && Utils.inArray('docHidden', this.options.sounds.conditions)) { + Utils.createAudioElements(this); + } + + if (API.PageHidden && Utils.inArray('docHidden', this.options.titleCount.conditions)) { + API.docTitle.increment(); + } + + return this; + } + + API.Store[this.id] = this; + + API.fire(this, 'beforeShow'); + + this.showing = true; + + if (this.closing) { + this.showing = false; + return this; + } + + API.build(this); + API.handleModal(this); + + if (this.options.force) { + this.layoutDom.insertBefore(this.barDom, this.layoutDom.firstChild); + } else { + this.layoutDom.appendChild(this.barDom); + } + + if (this.hasSound && !this.soundPlayed && Utils.inArray('docVisible', this.options.sounds.conditions)) { + Utils.createAudioElements(this); + } + + if (Utils.inArray('docVisible', this.options.titleCount.conditions)) { + API.docTitle.increment(); + } + + this.shown = true; + this.closed = false; + + // bind button events if any + if (API.hasButtons(this)) { + Object.keys(this.options.buttons).forEach(function (key) { + var btn = _this.barDom.querySelector('#' + _this.options.buttons[key].id); + Utils.addListener(btn, 'click', function (e) { + Utils.stopPropagation(e); + _this.options.buttons[key].cb(_this); + }); + }); + } + + this.progressDom = this.barDom.querySelector('.noty_progressbar'); + + if (Utils.inArray('click', this.options.closeWith)) { + Utils.addClass(this.barDom, 'noty_close_with_click'); + Utils.addListener(this.barDom, 'click', function (e) { + Utils.stopPropagation(e); + API.fire(_this, 'onClick'); + _this.close(); + }, false); + } + + Utils.addListener(this.barDom, 'mouseenter', function () { + API.fire(_this, 'onHover'); + }, false); + + if (this.options.timeout) Utils.addClass(this.barDom, 'noty_has_timeout'); + if (this.options.progressBar) { + Utils.addClass(this.barDom, 'noty_has_progressbar'); + } + + if (Utils.inArray('button', this.options.closeWith)) { + Utils.addClass(this.barDom, 'noty_close_with_button'); + + var closeButton = document.createElement('div'); + Utils.addClass(closeButton, 'noty_close_button'); + closeButton.innerHTML = '×'; + this.barDom.appendChild(closeButton); + + Utils.addListener(closeButton, 'click', function (e) { + Utils.stopPropagation(e); + _this.close(); + }, false); + } + + API.fire(this, 'onShow'); + + if (this.options.animation.open === null) { + this.promises.show = new _es6Promise2.default(function (resolve) { + resolve(); + }); + } else if (typeof this.options.animation.open === 'function') { + this.promises.show = new _es6Promise2.default(this.options.animation.open.bind(this)); + } else { + Utils.addClass(this.barDom, this.options.animation.open); + this.promises.show = new _es6Promise2.default(function (resolve) { + Utils.addListener(_this.barDom, Utils.animationEndEvents, function () { + Utils.removeClass(_this.barDom, _this.options.animation.open); + resolve(); + }); + }); + } + + this.promises.show.then(function () { + var _t = _this; + setTimeout(function () { + API.openFlow(_t); + }, 100); + }); + + return this; + } + + /** + * @return {Noty} + */ + + }, { + key: 'stop', + value: function stop() { + API.dequeueClose(this); + return this; + } + + /** + * @return {Noty} + */ + + }, { + key: 'resume', + value: function resume() { + API.queueClose(this); + return this; + } + + /** + * @param {int|boolean} ms + * @return {Noty} + */ + + }, { + key: 'setTimeout', + value: function (_setTimeout) { + function setTimeout(_x) { + return _setTimeout.apply(this, arguments); + } + + setTimeout.toString = function () { + return _setTimeout.toString(); + }; + + return setTimeout; + }(function (ms) { + this.stop(); + this.options.timeout = ms; + + if (this.barDom) { + if (this.options.timeout) { + Utils.addClass(this.barDom, 'noty_has_timeout'); + } else { + Utils.removeClass(this.barDom, 'noty_has_timeout'); + } + + var _t = this; + setTimeout(function () { + // ugly fix for progressbar display bug + _t.resume(); + }, 100); + } + + return this; + }) + + /** + * @param {string} html + * @param {boolean} optionsOverride + * @return {Noty} + */ + + }, { + key: 'setText', + value: function setText(html) { + var optionsOverride = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (this.barDom) { + this.barDom.querySelector('.noty_body').innerHTML = html; + } + + if (optionsOverride) this.options.text = html; + + return this; + } + + /** + * @param {string} type + * @param {boolean} optionsOverride + * @return {Noty} + */ + + }, { + key: 'setType', + value: function setType(type) { + var _this2 = this; + + var optionsOverride = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (this.barDom) { + var classList = Utils.classList(this.barDom).split(' '); + + classList.forEach(function (c) { + if (c.substring(0, 11) === 'noty_type__') { + Utils.removeClass(_this2.barDom, c); + } + }); + + Utils.addClass(this.barDom, 'noty_type__' + type); + } + + if (optionsOverride) this.options.type = type; + + return this; + } + + /** + * @param {string} theme + * @param {boolean} optionsOverride + * @return {Noty} + */ + + }, { + key: 'setTheme', + value: function setTheme(theme) { + var _this3 = this; + + var optionsOverride = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (this.barDom) { + var classList = Utils.classList(this.barDom).split(' '); + + classList.forEach(function (c) { + if (c.substring(0, 12) === 'noty_theme__') { + Utils.removeClass(_this3.barDom, c); + } + }); + + Utils.addClass(this.barDom, 'noty_theme__' + theme); + } + + if (optionsOverride) this.options.theme = theme; + + return this; + } + + /** + * @return {Noty} + */ + + }, { + key: 'close', + value: function close() { + var _this4 = this; + + if (this.closed) return this; + + if (!this.shown) { + // it's in the queue + API.removeFromQueue(this); + return this; + } + + API.fire(this, 'onClose'); + + this.closing = true; + + if (this.options.animation.close === null || this.options.animation.close === false) { + this.promises.close = new _es6Promise2.default(function (resolve) { + resolve(); + }); + } else if (typeof this.options.animation.close === 'function') { + this.promises.close = new _es6Promise2.default(this.options.animation.close.bind(this)); + } else { + Utils.addClass(this.barDom, this.options.animation.close); + this.promises.close = new _es6Promise2.default(function (resolve) { + Utils.addListener(_this4.barDom, Utils.animationEndEvents, function () { + if (_this4.options.force) { + Utils.remove(_this4.barDom); + } else { + API.ghostFix(_this4); + } + resolve(); + }); + }); + } + + this.promises.close.then(function () { + API.closeFlow(_this4); + API.handleModalClose(_this4); + }); + + this.closed = true; + + return this; + } + + // API functions + + /** + * @param {boolean|string} queueName + * @return {Noty} + */ + + }], [{ + key: 'closeAll', + value: function closeAll() { + var queueName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + Object.keys(API.Store).forEach(function (id) { + if (queueName) { + if (API.Store[id].options.queue === queueName && API.Store[id].killable) { + API.Store[id].close(); + } + } else if (API.Store[id].killable) { + API.Store[id].close(); + } + }); + return this; + } + + /** + * @param {string} queueName + * @return {Noty} + */ + + }, { + key: 'clearQueue', + value: function clearQueue() { + var queueName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'global'; + + if (API.Queues.hasOwnProperty(queueName)) { + API.Queues[queueName].queue = []; + } + return this; + } + + /** + * @return {API.Queues} + */ + + }, { + key: 'overrideDefaults', + + + /** + * @param {Object} obj + * @return {Noty} + */ + value: function overrideDefaults(obj) { + API.Defaults = Utils.deepExtend({}, API.Defaults, obj); + return this; + } + + /** + * @param {int} amount + * @param {string} queueName + * @return {Noty} + */ + + }, { + key: 'setMaxVisible', + value: function setMaxVisible() { + var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : API.DefaultMaxVisible; + var queueName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'global'; + + if (!API.Queues.hasOwnProperty(queueName)) { + API.Queues[queueName] = { maxVisible: amount, queue: [] }; + } + + API.Queues[queueName].maxVisible = amount; + return this; + } + + /** + * @param {string} innerHtml + * @param {String} classes + * @param {Function} cb + * @param {Object} attributes + * @return {NotyButton} + */ + + }, { + key: 'button', + value: function button(innerHtml) { + var classes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var cb = arguments[2]; + var attributes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {}; + + return new _button.NotyButton(innerHtml, classes, cb, attributes); + } + + /** + * @return {string} + */ + + }, { + key: 'version', + value: function version() { + return "3.2.0-beta"; + } + + /** + * @param {String} workerPath + * @return {Push} + */ + + }, { + key: 'Push', + value: function Push(workerPath) { + return new _push.Push(workerPath); + } + }, { + key: 'Queues', + get: function get() { + return API.Queues; + } + + /** + * @return {API.PageHidden} + */ + + }, { + key: 'PageHidden', + get: function get() { + return API.PageHidden; + } + }]); + + return Noty; +}(); + +// Document visibility change controller + + +exports.default = Noty; +if (typeof window !== 'undefined') { + Utils.visibilityChangeFlow(); +} +module.exports = exports['default']; + +/***/ }), +/* 7 */ +/***/ (function(module, exports) { + +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + + +/***/ }), +/* 8 */ +/***/ (function(module, exports) { + +var g; + +// This works in non-strict mode +g = (function() { + return this; +})(); + +try { + // This works if eval is allowed (see CSP) + g = g || Function("return this")() || (1,eval)("this"); +} catch(e) { + // This works if the window reference is available + if(typeof window === "object") + g = window; +} + +// g can still be undefined, but nothing to do about it... +// We return undefined, instead of nothing here, so it's +// easier to handle this case. if(!global) { ...} + +module.exports = g; + + +/***/ }), +/* 9 */ +/***/ (function(module, exports) { + +/* (ignored) */ + +/***/ }) +/******/ ]); +}); +//# sourceMappingURL=noty.js.map \ No newline at end of file diff --git a/xmrbackers/templates/auth/login.html b/xmrbackers/templates/auth/login.html new file mode 100644 index 0000000..6543ed5 --- /dev/null +++ b/xmrbackers/templates/auth/login.html @@ -0,0 +1,47 @@ + + + + {% include 'includes/head.html' %} + + +
+ + {% include 'includes/header.html' %} + + + + {% include 'includes/footer.html' %} + +
+ + {% include 'includes/scripts.html' %} + + + diff --git a/xmrbackers/templates/auth/register.html b/xmrbackers/templates/auth/register.html index 7a4495d..fa0af08 100644 --- a/xmrbackers/templates/auth/register.html +++ b/xmrbackers/templates/auth/register.html @@ -6,16 +6,31 @@
+ {% include 'includes/header.html' %} +