JAVASCRIPT   25

alertify.js

Guest on 19th July 2021 04:38:39 PM

  1. /**
  2.  * alertify
  3.  * An unobtrusive customizable JavaScript notification system
  4.  *
  5.  * @author Fabien Doiron <fabien.doiron@gmail.com>
  6.  * @copyright Fabien Doiron 2013
  7.  * @license MIT <http://opensource.org/licenses/mit-license.php>
  8.  * @link http://fabien-d.github.com/alertify.js/
  9.  * @module alertify
  10.  * @version 0.3.9
  11.  */
  12. (function (global, undefined) {
  13.         "use strict";
  14.  
  15.         var document = global.document,
  16.             Alertify;
  17.  
  18.         Alertify = function () {
  19.  
  20.                 var _alertify = {},
  21.                     dialogs   = {},
  22.                     isopen    = false,
  23.                     keys      = { ENTER: 13, ESC: 27, SPACE: 32 },
  24.                     queue     = [],
  25.                     $, btnCancel, btnOK, btnReset, btnFocus, elCallee, elCover, elDialog, elLog, form, input, getTransitionEvent;
  26.  
  27.                 /**
  28.                  * Markup pieces
  29.                  * @type {Object}
  30.                  */
  31.                 dialogs = {
  32.                         buttons : {
  33.                                 holder : "<nav class=\"alertify-buttons\">{{buttons}}</nav>",
  34.                                 submit : "<button type=\"submit\" class=\"alertify-button alertify-button-ok\" id=\"alertify-ok\">{{ok}}</button>",
  35.                                 ok     : "<a href=\"#\" class=\"alertify-button alertify-button-ok\" id=\"alertify-ok\">{{ok}}</a>",
  36.                                 cancel : "<a href=\"#\" class=\"alertify-button alertify-button-cancel\" id=\"alertify-cancel\">{{cancel}}</a>"
  37.                         },
  38.                         input   : "<div class=\"alertify-text-wrapper\"><input type=\"text\" class=\"alertify-text\" id=\"alertify-text\"></div>",
  39.                         message : "<p class=\"alertify-message\">{{message}}</p>",
  40.                         log     : "<article class=\"alertify-log{{class}}\">{{message}}</article>"
  41.                 };
  42.  
  43.                 /**
  44.                  * Return the proper transitionend event
  45.                  * @return {String}    Transition type string
  46.                  */
  47.                 getTransitionEvent = function () {
  48.                         var t,
  49.                             type,
  50.                             supported   = false,
  51.                             el          = document.createElement("fakeelement"),
  52.                             transitions = {
  53.                                     "WebkitTransition" : "webkitTransitionEnd",
  54.                                     "MozTransition"    : "transitionend",
  55.                                     "OTransition"      : "otransitionend",
  56.                                     "transition"       : "transitionend"
  57.                             };
  58.  
  59.                         for (t in transitions) {
  60.                                 if (el.style[t] !== undefined) {
  61.                                         type      = transitions[t];
  62.                                         supported = true;
  63.                                         break;
  64.                                 }
  65.                         }
  66.  
  67.                         return {
  68.                                 type      : type,
  69.                                 supported : supported
  70.                         };
  71.                 };
  72.  
  73.                 /**
  74.                  * Shorthand for document.getElementById()
  75.                  *
  76.                  * @param  {String} id    A specific element ID
  77.                  * @return {Object}       HTML element
  78.                  */
  79.                 $ = function (id) {
  80.                         return document.getElementById(id);
  81.                 };
  82.  
  83.                 /**
  84.                  * Alertify private object
  85.                  * @type {Object}
  86.                  */
  87.                 _alertify = {
  88.  
  89.                         /**
  90.                          * Labels object
  91.                          * @type {Object}
  92.                          */
  93.                         labels : {
  94.                                 ok     : "OK",
  95.                                 cancel : "Cancel"
  96.                         },
  97.  
  98.                         /**
  99.                          * Delay number
  100.                          * @type {Number}
  101.                          */
  102.                         delay : 5000,
  103.  
  104.                         /**
  105.                          * Whether buttons are reversed (default is secondary/primary)
  106.                          * @type {Boolean}
  107.                          */
  108.                         buttonReverse : false,
  109.  
  110.                         /**
  111.                          * Which button should be focused by default
  112.                          * @type {String}       "ok" (default), "cancel", or "none"
  113.                          */
  114.                         buttonFocus : "ok",
  115.  
  116.                         /**
  117.                          * Set the transition event on load
  118.                          * @type {[type]}
  119.                          */
  120.                         transition : undefined,
  121.  
  122.                         /**
  123.                          * Set the proper button click events
  124.                          *
  125.                          * @param {Function} fn    [Optional] Callback function
  126.                          *
  127.                          * @return {undefined}
  128.                          */
  129.                         addListeners : function (fn) {
  130.                                 var hasOK     = (typeof btnOK !== "undefined"),
  131.                                     hasCancel = (typeof btnCancel !== "undefined"),
  132.                                     hasInput  = (typeof input !== "undefined"),
  133.                                     val       = "",
  134.                                     self      = this,
  135.                                     ok, cancel, common, key, reset;
  136.  
  137.                                 // ok event handler
  138.                                 ok = function (event) {
  139.                                         if (typeof event.preventDefault !== "undefined") event.preventDefault();
  140.                                         common(event);
  141.                                         if (typeof input !== "undefined") val = input.value;
  142.                                         if (typeof fn === "function") {
  143.                                                 if (typeof input !== "undefined") {
  144.                                                         fn(true, val);
  145.                                                 }
  146.                                                 else fn(true);
  147.                                         }
  148.                                         return false;
  149.                                 };
  150.  
  151.                                 // cancel event handler
  152.                                 cancel = function (event) {
  153.                                         if (typeof event.preventDefault !== "undefined") event.preventDefault();
  154.                                         common(event);
  155.                                         if (typeof fn === "function") fn(false);
  156.                                         return false;
  157.                                 };
  158.  
  159.                                 // common event handler (keyup, ok and cancel)
  160.                                 common = function (event) {
  161.                                         self.hide();
  162.                                         self.unbind(document.body, "keyup", key);
  163.                                         self.unbind(btnReset, "focus", reset);
  164.                                         if (hasInput) self.unbind(form, "submit", ok);
  165.                                         if (hasOK) self.unbind(btnOK, "click", ok);
  166.                                         if (hasCancel) self.unbind(btnCancel, "click", cancel);
  167.                                 };
  168.  
  169.                                 // keyup handler
  170.                                 key = function (event) {
  171.                                         var keyCode = event.keyCode;
  172.                                         if (keyCode === keys.SPACE && !hasInput) ok(event);
  173.                                         if (keyCode === keys.ESC && hasCancel) cancel(event);
  174.                                 };
  175.  
  176.                                 // reset focus to first item in the dialog
  177.                                 reset = function (event) {
  178.                                         if (hasInput) input.focus();
  179.                                         else if (!hasCancel || self.buttonReverse) btnOK.focus();
  180.                                         else btnCancel.focus();
  181.                                 };
  182.  
  183.                                 // handle reset focus link
  184.                                 // this ensures that the keyboard focus does not
  185.                                 // ever leave the dialog box until an action has
  186.                                 // been taken
  187.                                 this.bind(btnReset, "focus", reset);
  188.                                 // handle OK click
  189.                                 if (hasOK) this.bind(btnOK, "click", ok);
  190.                                 // handle Cancel click
  191.                                 if (hasCancel) this.bind(btnCancel, "click", cancel);
  192.                                 // listen for keys, Cancel => ESC
  193.                                 this.bind(document.body, "keyup", key);
  194.                                 // bind form submit
  195.                                 if (hasInput) this.bind(form, "submit", ok);
  196.                                 if (!this.transition.supported) {
  197.                                         this.setFocus();
  198.                                 }
  199.                         },
  200.  
  201.                         /**
  202.                          * Bind events to elements
  203.                          *
  204.                          * @param  {Object}   el       HTML Object
  205.                          * @param  {Event}    event    Event to attach to element
  206.                          * @param  {Function} fn       Callback function
  207.                          *
  208.                          * @return {undefined}
  209.                          */
  210.                         bind : function (el, event, fn) {
  211.                                 if (typeof el.addEventListener === "function") {
  212.                                         el.addEventListener(event, fn, false);
  213.                                 } else if (el.attachEvent) {
  214.                                         el.attachEvent("on" + event, fn);
  215.                                 }
  216.                         },
  217.  
  218.                         /**
  219.                          * Use alertify as the global error handler (using window.onerror)
  220.                          *
  221.                          * @return {boolean} success
  222.                          */
  223.                         handleErrors : function () {
  224.                                 if (typeof global.onerror !== "undefined") {
  225.                                         var self = this;
  226.                                         global.onerror = function (msg, url, line) {
  227.                                                 self.error("[" + msg + " on line " + line + " of " + url + "]", 0);
  228.                                         };
  229.                                         return true;
  230.                                 } else {
  231.                                         return false;
  232.                                 }
  233.                         },
  234.  
  235.                         /**
  236.                          * Append button HTML strings
  237.                          *
  238.                          * @param {String} secondary    The secondary button HTML string
  239.                          * @param {String} primary      The primary button HTML string
  240.                          *
  241.                          * @return {String}             The appended button HTML strings
  242.                          */
  243.                         appendButtons : function (secondary, primary) {
  244.                                 return this.buttonReverse ? primary + secondary : secondary + primary;
  245.                         },
  246.  
  247.                         /**
  248.                          * Build the proper message box
  249.                          *
  250.                          * @param  {Object} item    Current object in the queue
  251.                          *
  252.                          * @return {String}         An HTML string of the message box
  253.                          */
  254.                         build : function (item) {
  255.                                 var html    = "",
  256.                                     type    = item.type,
  257.                                     message = item.message,
  258.                                     css     = item.cssClass || "";
  259.  
  260.                                 html += "<div class=\"alertify-dialog\">";
  261.  
  262.                                 if (_alertify.buttonFocus === "none") html += "<a href=\"#\" id=\"alertify-noneFocus\" class=\"alertify-hidden\"></a>";
  263.  
  264.                                 if (type === "prompt") html += "<form id=\"alertify-form\">";
  265.  
  266.                                 html += "<article class=\"alertify-inner\">";
  267.                                 html += dialogs.message.replace("{{message}}", message);
  268.  
  269.                                 if (type === "prompt") html += dialogs.input;
  270.  
  271.                                 html += dialogs.buttons.holder;
  272.                                 html += "</article>";
  273.  
  274.                                 if (type === "prompt") html += "</form>";
  275.  
  276.                                 html += "<a id=\"alertify-resetFocus\" class=\"alertify-resetFocus\" href=\"#\">Reset Focus</a>";
  277.                                 html += "</div>";
  278.  
  279.                                 switch (type) {
  280.                                 case "confirm":
  281.                                         html = html.replace("{{buttons}}", this.appendButtons(dialogs.buttons.cancel, dialogs.buttons.ok));
  282.                                         html = html.replace("{{ok}}", this.labels.ok).replace("{{cancel}}", this.labels.cancel);
  283.                                         break;
  284.                                 case "prompt":
  285.                                         html = html.replace("{{buttons}}", this.appendButtons(dialogs.buttons.cancel, dialogs.buttons.submit));
  286.                                         html = html.replace("{{ok}}", this.labels.ok).replace("{{cancel}}", this.labels.cancel);
  287.                                         break;
  288.                                 case "alert":
  289.                                         html = html.replace("{{buttons}}", dialogs.buttons.ok);
  290.                                         html = html.replace("{{ok}}", this.labels.ok);
  291.                                         break;
  292.                                 default:
  293.                                         break;
  294.                                 }
  295.  
  296.                                 elDialog.className = "alertify alertify-" + type + " " + css;
  297.                                 elCover.className  = "alertify-cover";
  298.                                 return html;
  299.                         },
  300.  
  301.                         /**
  302.                          * Close the log messages
  303.                          *
  304.                          * @param  {Object} elem    HTML Element of log message to close
  305.                          * @param  {Number} wait    [optional] Time (in ms) to wait before automatically hiding the message, if 0 never hide
  306.                          *
  307.                          * @return {undefined}
  308.                          */
  309.                         close : function (elem, wait) {
  310.                                 // Unary Plus: +"2" === 2
  311.                                 var timer = (wait && !isNaN(wait)) ? +wait : this.delay,
  312.                                     self  = this,
  313.                                     hideElement, transitionDone;
  314.  
  315.                                 // set click event on log messages
  316.                                 this.bind(elem, "click", function () {
  317.                                         hideElement(elem);
  318.                                 });
  319.                                 // Hide the dialog box after transition
  320.                                 // This ensure it doens't block any element from being clicked
  321.                                 transitionDone = function (event) {
  322.                                         event.stopPropagation();
  323.                                         // unbind event so function only gets called once
  324.                                         self.unbind(this, self.transition.type, transitionDone);
  325.                                         // remove log message
  326.                                         elLog.removeChild(this);
  327.                                         if (!elLog.hasChildNodes()) elLog.className += " alertify-logs-hidden";
  328.                                 };
  329.                                 // this sets the hide class to transition out
  330.                                 // or removes the child if css transitions aren't supported
  331.                                 hideElement = function (el) {
  332.                                         // ensure element exists
  333.                                         if (typeof el !== "undefined" && el.parentNode === elLog) {
  334.                                                 // whether CSS transition exists
  335.                                                 if (self.transition.supported) {
  336.                                                         self.bind(el, self.transition.type, transitionDone);
  337.                                                         el.className += " alertify-log-hide";
  338.                                                 } else {
  339.                                                         elLog.removeChild(el);
  340.                                                         if (!elLog.hasChildNodes()) elLog.className += " alertify-logs-hidden";
  341.                                                 }
  342.                                         }
  343.                                 };
  344.                                 // never close (until click) if wait is set to 0
  345.                                 if (wait === 0) return;
  346.                                 // set timeout to auto close the log message
  347.                                 setTimeout(function () { hideElement(elem); }, timer);
  348.                         },
  349.  
  350.                         /**
  351.                          * Create a dialog box
  352.                          *
  353.                          * @param  {String}   message        The message passed from the callee
  354.                          * @param  {String}   type           Type of dialog to create
  355.                          * @param  {Function} fn             [Optional] Callback function
  356.                          * @param  {String}   placeholder    [Optional] Default value for prompt input field
  357.                          * @param  {String}   cssClass       [Optional] Class(es) to append to dialog box
  358.                          *
  359.                          * @return {Object}
  360.                          */
  361.                         dialog : function (message, type, fn, placeholder, cssClass) {
  362.                                 // set the current active element
  363.                                 // this allows the keyboard focus to be resetted
  364.                                 // after the dialog box is closed
  365.                                 elCallee = document.activeElement;
  366.                                 // check to ensure the alertify dialog element
  367.                                 // has been successfully created
  368.                                 var check = function () {
  369.                                         if ((elLog && elLog.scrollTop !== null) && (elCover && elCover.scrollTop !== null)) return;
  370.                                         else check();
  371.                                 };
  372.                                 // error catching
  373.                                 if (typeof message !== "string") throw new Error("message must be a string");
  374.                                 if (typeof type !== "string") throw new Error("type must be a string");
  375.                                 if (typeof fn !== "undefined" && typeof fn !== "function") throw new Error("fn must be a function");
  376.                                 // initialize alertify if it hasn't already been done
  377.                                 if (typeof this.init === "function") {
  378.                                         this.init();
  379.                                         check();
  380.                                 }
  381.  
  382.                                 queue.push({ type: type, message: message, callback: fn, placeholder: placeholder, cssClass: cssClass });
  383.                                 if (!isopen) this.setup();
  384.  
  385.                                 return this;
  386.                         },
  387.  
  388.                         /**
  389.                          * Extend the log method to create custom methods
  390.                          *
  391.                          * @param  {String} type    Custom method name
  392.                          *
  393.                          * @return {Function}
  394.                          */
  395.                         extend : function (type) {
  396.                                 if (typeof type !== "string") throw new Error("extend method must have exactly one paramter");
  397.                                 return function (message, wait) {
  398.                                         this.log(message, type, wait);
  399.                                         return this;
  400.                                 };
  401.                         },
  402.  
  403.                         /**
  404.                          * Hide the dialog and rest to defaults
  405.                          *
  406.                          * @return {undefined}
  407.                          */
  408.                         hide : function () {
  409.                                 var transitionDone,
  410.                                     self = this;
  411.                                 // remove reference from queue
  412.                                 queue.splice(0,1);
  413.                                 // if items remaining in the queue
  414.                                 if (queue.length > 0) this.setup(true);
  415.                                 else {
  416.                                         isopen = false;
  417.                                         // Hide the dialog box after transition
  418.                                         // This ensure it doens't block any element from being clicked
  419.                                         transitionDone = function (event) {
  420.                                                 event.stopPropagation();
  421.                                                 elDialog.className += " alertify-isHidden";
  422.                                                 // unbind event so function only gets called once
  423.                                                 self.unbind(elDialog, self.transition.type, transitionDone);
  424.                                         };
  425.                                         // whether CSS transition exists
  426.                                         if (this.transition.supported) {
  427.                                                 this.bind(elDialog, this.transition.type, transitionDone);
  428.                                                 elDialog.className = "alertify alertify-hide alertify-hidden";
  429.                                         } else {
  430.                                                 elDialog.className = "alertify alertify-hide alertify-hidden alertify-isHidden";
  431.                                         }
  432.                                         elCover.className  = "alertify-cover alertify-cover-hidden";
  433.                                         // set focus to the last element or body
  434.                                         // after the dialog is closed
  435.                                         elCallee.focus();
  436.                                 }
  437.                         },
  438.  
  439.                         /**
  440.                          * Initialize Alertify
  441.                          * Create the 2 main elements
  442.                          *
  443.                          * @return {undefined}
  444.                          */
  445.                         init : function () {
  446.                                 // ensure legacy browsers support html5 tags
  447.                                 document.createElement("nav");
  448.                                 document.createElement("article");
  449.                                 document.createElement("section");
  450.                                 // cover
  451.                                 elCover = document.createElement("div");
  452.                                 elCover.setAttribute("id", "alertify-cover");
  453.                                 elCover.className = "alertify-cover alertify-cover-hidden";
  454.                                 document.body.appendChild(elCover);
  455.                                 // main element
  456.                                 elDialog = document.createElement("section");
  457.                                 elDialog.setAttribute("id", "alertify");
  458.                                 elDialog.className = "alertify alertify-hidden";
  459.                                 document.body.appendChild(elDialog);
  460.                                 // log element
  461.                                 elLog = document.createElement("section");
  462.                                 elLog.setAttribute("id", "alertify-logs");
  463.                                 elLog.className = "alertify-logs alertify-logs-hidden";
  464.                                 document.body.appendChild(elLog);
  465.                                 // set tabindex attribute on body element
  466.                                 // this allows script to give it focus
  467.                                 // after the dialog is closed
  468.                                 document.body.setAttribute("tabindex", "0");
  469.                                 // set transition type
  470.                                 this.transition = getTransitionEvent();
  471.                                 // clean up init method
  472.                                 delete this.init;
  473.                         },
  474.  
  475.                         /**
  476.                          * Show a new log message box
  477.                          *
  478.                          * @param  {String} message    The message passed from the callee
  479.                          * @param  {String} type       [Optional] Optional type of log message
  480.                          * @param  {Number} wait       [Optional] Time (in ms) to wait before auto-hiding the log
  481.                          *
  482.                          * @return {Object}
  483.                          */
  484.                         log : function (message, type, wait) {
  485.                                 // check to ensure the alertify dialog element
  486.                                 // has been successfully created
  487.                                 var check = function () {
  488.                                         if (elLog && elLog.scrollTop !== null) return;
  489.                                         else check();
  490.                                 };
  491.                                 // initialize alertify if it hasn't already been done
  492.                                 if (typeof this.init === "function") {
  493.                                         this.init();
  494.                                         check();
  495.                                 }
  496.                                 elLog.className = "alertify-logs";
  497.                                 this.notify(message, type, wait);
  498.                                 return this;
  499.                         },
  500.  
  501.                         /**
  502.                          * Add new log message
  503.                          * If a type is passed, a class name "alertify-log-{type}" will get added.
  504.                          * This allows for custom look and feel for various types of notifications.
  505.                          *
  506.                          * @param  {String} message    The message passed from the callee
  507.                          * @param  {String} type       [Optional] Type of log message
  508.                          * @param  {Number} wait       [Optional] Time (in ms) to wait before auto-hiding
  509.                          *
  510.                          * @return {undefined}
  511.                          */
  512.                         notify : function (message, type, wait) {
  513.                                 var log = document.createElement("article");
  514.                                 log.className = "alertify-log" + ((typeof type === "string" && type !== "") ? " alertify-log-" + type : "");
  515.                                 log.innerHTML = message;
  516.                                 // append child
  517.                                 elLog.appendChild(log);
  518.                                 // triggers the CSS animation
  519.                                 setTimeout(function() { log.className = log.className + " alertify-log-show"; }, 50);
  520.                                 this.close(log, wait);
  521.                         },
  522.  
  523.                         /**
  524.                          * Set properties
  525.                          *
  526.                          * @param {Object} args     Passing parameters
  527.                          *
  528.                          * @return {undefined}
  529.                          */
  530.                         set : function (args) {
  531.                                 var k;
  532.                                 // error catching
  533.                                 if (typeof args !== "object" && args instanceof Array) throw new Error("args must be an object");
  534.                                 // set parameters
  535.                                 for (k in args) {
  536.                                         if (args.hasOwnProperty(k)) {
  537.                                                 this[k] = args[k];
  538.                                         }
  539.                                 }
  540.                         },
  541.  
  542.                         /**
  543.                          * Common place to set focus to proper element
  544.                          *
  545.                          * @return {undefined}
  546.                          */
  547.                         setFocus : function () {
  548.                                 if (input) {
  549.                                         input.focus();
  550.                                         input.select();
  551.                                 }
  552.                                 else btnFocus.focus();
  553.                         },
  554.  
  555.                         /**
  556.                          * Initiate all the required pieces for the dialog box
  557.                          *
  558.                          * @return {undefined}
  559.                          */
  560.                         setup : function (fromQueue) {
  561.                                 var item = queue[0],
  562.                                     self = this,
  563.                                     transitionDone;
  564.  
  565.                                 // dialog is open
  566.                                 isopen = true;
  567.                                 // Set button focus after transition
  568.                                 transitionDone = function (event) {
  569.                                         event.stopPropagation();
  570.                                         self.setFocus();
  571.                                         // unbind event so function only gets called once
  572.                                         self.unbind(elDialog, self.transition.type, transitionDone);
  573.                                 };
  574.                                 // whether CSS transition exists
  575.                                 if (this.transition.supported && !fromQueue) {
  576.                                         this.bind(elDialog, this.transition.type, transitionDone);
  577.                                 }
  578.                                 // build the proper dialog HTML
  579.                                 elDialog.innerHTML = this.build(item);
  580.                                 // assign all the common elements
  581.                                 btnReset  = $("alertify-resetFocus");
  582.                                 btnOK     = $("alertify-ok")     || undefined;
  583.                                 btnCancel = $("alertify-cancel") || undefined;
  584.                                 btnFocus  = (_alertify.buttonFocus === "cancel") ? btnCancel : ((_alertify.buttonFocus === "none") ? $("alertify-noneFocus") : btnOK),
  585.                                 input     = $("alertify-text")   || undefined;
  586.                                 form      = $("alertify-form")   || undefined;
  587.                                 // add placeholder value to the input field
  588.                                 if (typeof item.placeholder === "string" && item.placeholder !== "") input.value = item.placeholder;
  589.                                 if (fromQueue) this.setFocus();
  590.                                 this.addListeners(item.callback);
  591.                         },
  592.  
  593.                         /**
  594.                          * Unbind events to elements
  595.                          *
  596.                          * @param  {Object}   el       HTML Object
  597.                          * @param  {Event}    event    Event to detach to element
  598.                          * @param  {Function} fn       Callback function
  599.                          *
  600.                          * @return {undefined}
  601.                          */
  602.                         unbind : function (el, event, fn) {
  603.                                 if (typeof el.removeEventListener === "function") {
  604.                                         el.removeEventListener(event, fn, false);
  605.                                 } else if (el.detachEvent) {
  606.                                         el.detachEvent("on" + event, fn);
  607.                                 }
  608.                         }
  609.                 };
  610.  
  611.                 return {
  612.                         alert   : function (message, fn, cssClass) { _alertify.dialog(message, "alert", fn, "", cssClass); return this; },
  613.                         confirm : function (message, fn, cssClass) { _alertify.dialog(message, "confirm", fn, "", cssClass); return this; },
  614.                         extend  : _alertify.extend,
  615.                         init    : _alertify.init,
  616.                         log     : function (message, type, wait) { _alertify.log(message, type, wait); return this; },
  617.                         prompt  : function (message, fn, placeholder, cssClass) { _alertify.dialog(message, "prompt", fn, placeholder, cssClass); return this; },
  618.                         success : function (message, wait) { _alertify.log(message, "success", wait); return this; },
  619.                         error   : function (message, wait) { _alertify.log(message, "error", wait); return this; },
  620.                         set     : function (args) { _alertify.set(args); },
  621.                         labels  : _alertify.labels,
  622.                         debug   : _alertify.handleErrors
  623.                 };
  624.         };
  625.  
  626.         // AMD and window support
  627.         if (typeof define === "function") {
  628.                 define([], function () { return new Alertify(); });
  629.         } else if (typeof global.alertify === "undefined") {
  630.                 global.alertify = new Alertify();
  631.         }
  632.  
  633. }(this));

Raw Paste


Login or Register to edit or fork this paste. It's free.