JAVASCRIPT   56

alertify.js

Guest on 3rd August 2021 01:40:28 AM

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

Raw Paste


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