734 lines
22 KiB
JavaScript
734 lines
22 KiB
JavaScript
/**
|
|
* jGrowl 1.4.5
|
|
*
|
|
* Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
|
|
* and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
|
|
*
|
|
* Written by Stan Lemon <stosh1985@gmail.com>
|
|
* Last updated: 2015.02.01
|
|
*/
|
|
(function($) {
|
|
/** jGrowl Wrapper - Establish a base jGrowl Container for compatibility with older releases. **/
|
|
$.jGrowl = function( m , o ) {
|
|
// To maintain compatibility with older version that only supported one instance we'll create the base container.
|
|
if ( $('#jGrowl').length === 0 )
|
|
$('<div id="jGrowl"></div>').addClass( (o && o.position) ? o.position : $.jGrowl.defaults.position ).appendTo( (o && o.appendTo) ? o.appendTo : $.jGrowl.defaults.appendTo );
|
|
|
|
// Create a notification on the container.
|
|
$('#jGrowl').jGrowl(m,o);
|
|
};
|
|
|
|
|
|
/** Raise jGrowl Notification on a jGrowl Container **/
|
|
$.fn.jGrowl = function( m , o ) {
|
|
// Short hand for passing in just an object to this method
|
|
if ( o === undefined && $.isPlainObject(m) ) {
|
|
o = m;
|
|
m = o.message;
|
|
}
|
|
|
|
if ( $.isFunction(this.each) ) {
|
|
var args = arguments;
|
|
|
|
return this.each(function() {
|
|
/** Create a jGrowl Instance on the Container if it does not exist **/
|
|
if ( $(this).data('jGrowl.instance') === undefined ) {
|
|
$(this).data('jGrowl.instance', $.extend( new $.fn.jGrowl(), { notifications: [], element: null, interval: null } ));
|
|
$(this).data('jGrowl.instance').startup( this );
|
|
}
|
|
|
|
/** Optionally call jGrowl instance methods, or just raise a normal notification **/
|
|
if ( $.isFunction($(this).data('jGrowl.instance')[m]) ) {
|
|
$(this).data('jGrowl.instance')[m].apply( $(this).data('jGrowl.instance') , $.makeArray(args).slice(1) );
|
|
} else {
|
|
$(this).data('jGrowl.instance').create( m , o );
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
$.extend( $.fn.jGrowl.prototype , {
|
|
|
|
/** Default JGrowl Settings **/
|
|
defaults: {
|
|
pool: 0,
|
|
header: '',
|
|
group: '',
|
|
sticky: false,
|
|
position: 'top-right',
|
|
appendTo: 'body',
|
|
glue: 'after',
|
|
theme: 'default',
|
|
themeState: 'highlight',
|
|
corners: '10px',
|
|
check: 250,
|
|
life: 3000,
|
|
closeDuration: 'normal',
|
|
openDuration: 'normal',
|
|
easing: 'swing',
|
|
closer: true,
|
|
closeTemplate: '×',
|
|
closerTemplate: '<div>[ close all ]</div>',
|
|
log: function() {},
|
|
beforeOpen: function() {},
|
|
afterOpen: function() {},
|
|
open: function() {},
|
|
beforeClose: function() {},
|
|
close: function() {},
|
|
click: function() {},
|
|
animateOpen: {
|
|
opacity: 'show'
|
|
},
|
|
animateClose: {
|
|
opacity: 'hide'
|
|
}
|
|
},
|
|
|
|
notifications: [],
|
|
|
|
/** jGrowl Container Node **/
|
|
element: null,
|
|
|
|
/** Interval Function **/
|
|
interval: null,
|
|
|
|
/** Create a Notification **/
|
|
create: function( message , options ) {
|
|
var o = $.extend({}, this.defaults, options);
|
|
|
|
/* To keep backward compatibility with 1.24 and earlier, honor 'speed' if the user has set it */
|
|
if (typeof o.speed !== 'undefined') {
|
|
o.openDuration = o.speed;
|
|
o.closeDuration = o.speed;
|
|
}
|
|
|
|
this.notifications.push({ message: message , options: o });
|
|
|
|
o.log.apply( this.element , [this.element,message,o] );
|
|
},
|
|
|
|
render: function( n ) {
|
|
var self = this;
|
|
var message = n.message;
|
|
var o = n.options;
|
|
|
|
// Support for jQuery theme-states, if this is not used it displays a widget header
|
|
o.themeState = (o.themeState === '') ? '' : 'ui-state-' + o.themeState;
|
|
|
|
var notification = $('<div/>')
|
|
.addClass('jGrowl-notification alert ' + o.themeState + ' ui-corner-all' + ((o.group !== undefined && o.group !== '') ? ' ' + o.group : ''))
|
|
.append($('<button/>').addClass('jGrowl-close').html(o.closeTemplate))
|
|
.append($('<div/>').addClass('jGrowl-header').html(o.header))
|
|
.append($('<div/>').addClass('jGrowl-message').html(message))
|
|
.data("jGrowl", o).addClass(o.theme).children('.jGrowl-close').bind("click.jGrowl", function() {
|
|
$(this).parent().trigger('jGrowl.beforeClose');
|
|
return false;
|
|
})
|
|
.parent();
|
|
|
|
|
|
/** Notification Actions **/
|
|
$(notification).bind("mouseover.jGrowl", function() {
|
|
$('.jGrowl-notification', self.element).data("jGrowl.pause", true);
|
|
}).bind("mouseout.jGrowl", function() {
|
|
$('.jGrowl-notification', self.element).data("jGrowl.pause", false);
|
|
}).bind('jGrowl.beforeOpen', function() {
|
|
if ( o.beforeOpen.apply( notification , [notification,message,o,self.element] ) !== false ) {
|
|
$(this).trigger('jGrowl.open');
|
|
}
|
|
}).bind('jGrowl.open', function() {
|
|
if ( o.open.apply( notification , [notification,message,o,self.element] ) !== false ) {
|
|
if ( o.glue == 'after' ) {
|
|
$('.jGrowl-notification:last', self.element).after(notification);
|
|
} else {
|
|
$('.jGrowl-notification:first', self.element).before(notification);
|
|
}
|
|
|
|
$(this).animate(o.animateOpen, o.openDuration, o.easing, function() {
|
|
// Fixes some anti-aliasing issues with IE filters.
|
|
if ($.support.opacity === false)
|
|
this.style.removeAttribute('filter');
|
|
|
|
if ( $(this).data("jGrowl") !== null && typeof $(this).data("jGrowl") !== 'undefined') // Happens when a notification is closing before it's open.
|
|
$(this).data("jGrowl").created = new Date();
|
|
|
|
$(this).trigger('jGrowl.afterOpen');
|
|
});
|
|
}
|
|
}).bind('jGrowl.afterOpen', function() {
|
|
o.afterOpen.apply( notification , [notification,message,o,self.element] );
|
|
}).bind('click', function() {
|
|
o.click.apply( notification, [notification,message,o,self.element] );
|
|
}).bind('jGrowl.beforeClose', function() {
|
|
if ( o.beforeClose.apply( notification , [notification,message,o,self.element] ) !== false )
|
|
$(this).trigger('jGrowl.close');
|
|
}).bind('jGrowl.close', function() {
|
|
// Pause the notification, lest during the course of animation another close event gets called.
|
|
$(this).data('jGrowl.pause', true);
|
|
$(this).animate(o.animateClose, o.closeDuration, o.easing, function() {
|
|
if ( $.isFunction(o.close) ) {
|
|
if ( o.close.apply( notification , [notification,message,o,self.element] ) !== false )
|
|
$(this).remove();
|
|
} else {
|
|
$(this).remove();
|
|
}
|
|
});
|
|
}).trigger('jGrowl.beforeOpen');
|
|
|
|
/** Optional Corners Plugin **/
|
|
if ( o.corners !== '' && $.fn.corner !== undefined ) $(notification).corner( o.corners );
|
|
|
|
/** Add a Global Closer if more than one notification exists **/
|
|
if ($('.jGrowl-notification:parent', self.element).length > 1 &&
|
|
$('.jGrowl-closer', self.element).length === 0 && this.defaults.closer !== false ) {
|
|
$(this.defaults.closerTemplate).addClass('jGrowl-closer ' + this.defaults.themeState + ' ui-corner-all').addClass(this.defaults.theme)
|
|
.appendTo(self.element).animate(this.defaults.animateOpen, this.defaults.speed, this.defaults.easing)
|
|
.bind("click.jGrowl", function() {
|
|
$(this).siblings().trigger("jGrowl.beforeClose");
|
|
|
|
if ( $.isFunction( self.defaults.closer ) ) {
|
|
self.defaults.closer.apply( $(this).parent()[0] , [$(this).parent()[0]] );
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
/** Update the jGrowl Container, removing old jGrowl notifications **/
|
|
update: function() {
|
|
$(this.element).find('.jGrowl-notification:parent').each( function() {
|
|
if ($(this).data("jGrowl") !== undefined && $(this).data("jGrowl").created !== undefined &&
|
|
($(this).data("jGrowl").created.getTime() + parseInt($(this).data("jGrowl").life, 10)) < (new Date()).getTime() &&
|
|
$(this).data("jGrowl").sticky !== true &&
|
|
($(this).data("jGrowl.pause") === undefined || $(this).data("jGrowl.pause") !== true) ) {
|
|
|
|
// Pause the notification, lest during the course of animation another close event gets called.
|
|
$(this).trigger('jGrowl.beforeClose');
|
|
}
|
|
});
|
|
|
|
if (this.notifications.length > 0 &&
|
|
(this.defaults.pool === 0 || $(this.element).find('.jGrowl-notification:parent').length < this.defaults.pool) )
|
|
this.render( this.notifications.shift() );
|
|
|
|
if ($(this.element).find('.jGrowl-notification:parent').length < 2 ) {
|
|
$(this.element).find('.jGrowl-closer').animate(this.defaults.animateClose, this.defaults.speed, this.defaults.easing, function() {
|
|
$(this).remove();
|
|
});
|
|
}
|
|
},
|
|
|
|
/** Setup the jGrowl Notification Container **/
|
|
startup: function(e) {
|
|
this.element = $(e).addClass('jGrowl').append('<div class="jGrowl-notification"></div>');
|
|
this.interval = setInterval( function() {
|
|
// some error in chage ^^
|
|
var instance = $(e).data('jGrowl.instance');
|
|
if (undefined !== instance) {
|
|
instance.update();
|
|
}
|
|
}, parseInt(this.defaults.check, 10));
|
|
},
|
|
|
|
/** Shutdown jGrowl, removing it and clearing the interval **/
|
|
shutdown: function() {
|
|
$(this.element).removeClass('jGrowl')
|
|
.find('.jGrowl-notification').trigger('jGrowl.close')
|
|
.parent().empty()
|
|
;
|
|
|
|
clearInterval(this.interval);
|
|
},
|
|
|
|
close: function() {
|
|
$(this.element).find('.jGrowl-notification').each(function(){
|
|
$(this).trigger('jGrowl.beforeClose');
|
|
});
|
|
}
|
|
});
|
|
|
|
/** Reference the Defaults Object for compatibility with older versions of jGrowl **/
|
|
$.jGrowl.defaults = $.fn.jGrowl.prototype.defaults;
|
|
|
|
})(jQuery);
|
|
|
|
/*
|
|
A simple jQuery modal (http://github.com/kylefox/jquery-modal)
|
|
Version 0.8.0
|
|
*/
|
|
|
|
(function (factory) {
|
|
// Making your jQuery plugin work better with npm tools
|
|
// http://blog.npmjs.org/post/112712169830/making-your-jquery-plugin-work-better-with-npm
|
|
if(typeof module === "object" && typeof module.exports === "object") {
|
|
factory(require("jquery"), window, document);
|
|
}
|
|
else {
|
|
factory(jQuery, window, document);
|
|
}
|
|
}(function($, window, document, undefined) {
|
|
|
|
var modals = [],
|
|
getCurrent = function() {
|
|
return modals.length ? modals[modals.length - 1] : null;
|
|
},
|
|
selectCurrent = function() {
|
|
var i,
|
|
selected = false;
|
|
for (i=modals.length-1; i>=0; i--) {
|
|
if (modals[i].$blocker) {
|
|
modals[i].$blocker.toggleClass('current',!selected).toggleClass('behind',selected);
|
|
selected = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
$.modal = function(el, options) {
|
|
var remove, target;
|
|
this.$body = $('body');
|
|
this.options = $.extend({}, $.modal.defaults, options);
|
|
this.options.doFade = !isNaN(parseInt(this.options.fadeDuration, 10));
|
|
this.$blocker = null;
|
|
if (this.options.closeExisting)
|
|
while ($.modal.isActive())
|
|
$.modal.close(); // Close any open modals.
|
|
modals.push(this);
|
|
if (el.is('a')) {
|
|
target = el.attr('href');
|
|
//Select element by id from href
|
|
if (/^#/.test(target)) {
|
|
this.$elm = $(target);
|
|
if (this.$elm.length !== 1) return null;
|
|
this.$body.append(this.$elm);
|
|
this.open();
|
|
//AJAX
|
|
} else {
|
|
this.$elm = $('<div>');
|
|
this.$body.append(this.$elm);
|
|
remove = function(event, modal) { modal.elm.remove(); };
|
|
this.showSpinner();
|
|
el.trigger($.modal.AJAX_SEND);
|
|
$.get(target).done(function(html) {
|
|
if (!$.modal.isActive()) return;
|
|
el.trigger($.modal.AJAX_SUCCESS);
|
|
var current = getCurrent();
|
|
current.$elm.empty().append(html).on($.modal.CLOSE, remove);
|
|
current.hideSpinner();
|
|
current.open();
|
|
el.trigger($.modal.AJAX_COMPLETE);
|
|
}).fail(function() {
|
|
el.trigger($.modal.AJAX_FAIL);
|
|
var current = getCurrent();
|
|
current.hideSpinner();
|
|
modals.pop(); // remove expected modal from the list
|
|
el.trigger($.modal.AJAX_COMPLETE);
|
|
});
|
|
}
|
|
} else {
|
|
this.$elm = el;
|
|
this.$body.append(this.$elm);
|
|
this.open();
|
|
}
|
|
};
|
|
|
|
$.modal.prototype = {
|
|
constructor: $.modal,
|
|
|
|
open: function() {
|
|
var m = this;
|
|
this.block();
|
|
if(this.options.doFade) {
|
|
setTimeout(function() {
|
|
m.show();
|
|
}, this.options.fadeDuration * this.options.fadeDelay);
|
|
} else {
|
|
this.show();
|
|
}
|
|
$(document).off('keydown.modal').on('keydown.modal', function(event) {
|
|
var current = getCurrent();
|
|
if (event.which == 27 && current.options.escapeClose) current.close();
|
|
});
|
|
if (this.options.clickClose)
|
|
this.$blocker.on('click',function(e) {
|
|
if (e.target==this)
|
|
$.modal.close();
|
|
});
|
|
},
|
|
|
|
close: function() {
|
|
modals.pop();
|
|
this.unblock();
|
|
this.hide();
|
|
if (!$.modal.isActive())
|
|
$(document).off('keydown.modal');
|
|
},
|
|
|
|
block: function() {
|
|
this.$elm.trigger($.modal.BEFORE_BLOCK, [this._ctx()]);
|
|
this.$body.css('overflow','hidden');
|
|
this.$blocker = $('<div class="jquery-modal blocker current"></div>').appendTo(this.$body);
|
|
selectCurrent();
|
|
if(this.options.doFade) {
|
|
this.$blocker.css('opacity',0).animate({opacity: 1}, this.options.fadeDuration);
|
|
}
|
|
this.$elm.trigger($.modal.BLOCK, [this._ctx()]);
|
|
},
|
|
|
|
unblock: function(now) {
|
|
if (!now && this.options.doFade)
|
|
this.$blocker.fadeOut(this.options.fadeDuration, this.unblock.bind(this,true));
|
|
else {
|
|
this.$blocker.children().appendTo(this.$body);
|
|
this.$blocker.remove();
|
|
this.$blocker = null;
|
|
selectCurrent();
|
|
if (!$.modal.isActive())
|
|
this.$body.css('overflow','');
|
|
}
|
|
},
|
|
|
|
show: function() {
|
|
this.$elm.trigger($.modal.BEFORE_OPEN, [this._ctx()]);
|
|
if (this.options.showClose) {
|
|
this.closeButton = $('<a href="#close-modal" rel="modal:close" class="close-modal ' + this.options.closeClass + '">' + this.options.closeText + '</a>');
|
|
this.$elm.append(this.closeButton);
|
|
}
|
|
this.$elm.addClass(this.options.modalClass).appendTo(this.$blocker);
|
|
if(this.options.doFade) {
|
|
this.$elm.css('opacity',0).show().animate({opacity: 1}, this.options.fadeDuration);
|
|
} else {
|
|
this.$elm.show();
|
|
}
|
|
this.$elm.trigger($.modal.OPEN, [this._ctx()]);
|
|
},
|
|
|
|
hide: function() {
|
|
this.$elm.trigger($.modal.BEFORE_CLOSE, [this._ctx()]);
|
|
if (this.closeButton) this.closeButton.remove();
|
|
var _this = this;
|
|
if(this.options.doFade) {
|
|
this.$elm.fadeOut(this.options.fadeDuration, function () {
|
|
_this.$elm.trigger($.modal.AFTER_CLOSE, [_this._ctx()]);
|
|
});
|
|
} else {
|
|
this.$elm.hide(0, function () {
|
|
_this.$elm.trigger($.modal.AFTER_CLOSE, [_this._ctx()]);
|
|
});
|
|
}
|
|
this.$elm.trigger($.modal.CLOSE, [this._ctx()]);
|
|
},
|
|
|
|
showSpinner: function() {
|
|
if (!this.options.showSpinner) return;
|
|
this.spinner = this.spinner || $('<div class="' + this.options.modalClass + '-spinner"></div>')
|
|
.append(this.options.spinnerHtml);
|
|
this.$body.append(this.spinner);
|
|
this.spinner.show();
|
|
},
|
|
|
|
hideSpinner: function() {
|
|
if (this.spinner) this.spinner.remove();
|
|
},
|
|
|
|
//Return context for custom events
|
|
_ctx: function() {
|
|
return { elm: this.$elm, $blocker: this.$blocker, options: this.options };
|
|
}
|
|
};
|
|
|
|
$.modal.close = function(event) {
|
|
if (!$.modal.isActive()) return;
|
|
if (event) event.preventDefault();
|
|
var current = getCurrent();
|
|
current.close();
|
|
return current.$elm;
|
|
};
|
|
|
|
// Returns if there currently is an active modal
|
|
$.modal.isActive = function () {
|
|
return modals.length > 0;
|
|
}
|
|
|
|
$.modal.getCurrent = getCurrent;
|
|
|
|
$.modal.defaults = {
|
|
closeExisting: true,
|
|
escapeClose: true,
|
|
clickClose: true,
|
|
closeText: 'Close',
|
|
closeClass: '',
|
|
modalClass: "modal",
|
|
spinnerHtml: null,
|
|
showSpinner: true,
|
|
showClose: true,
|
|
fadeDuration: null, // Number of milliseconds the fade animation takes.
|
|
fadeDelay: 1.0 // Point during the overlay's fade-in that the modal begins to fade in (.5 = 50%, 1.5 = 150%, etc.)
|
|
};
|
|
|
|
// Event constants
|
|
$.modal.BEFORE_BLOCK = 'modal:before-block';
|
|
$.modal.BLOCK = 'modal:block';
|
|
$.modal.BEFORE_OPEN = 'modal:before-open';
|
|
$.modal.OPEN = 'modal:open';
|
|
$.modal.BEFORE_CLOSE = 'modal:before-close';
|
|
$.modal.CLOSE = 'modal:close';
|
|
$.modal.AFTER_CLOSE = 'modal:after-close';
|
|
$.modal.AJAX_SEND = 'modal:ajax:send';
|
|
$.modal.AJAX_SUCCESS = 'modal:ajax:success';
|
|
$.modal.AJAX_FAIL = 'modal:ajax:fail';
|
|
$.modal.AJAX_COMPLETE = 'modal:ajax:complete';
|
|
|
|
$.fn.modal = function(options){
|
|
if (this.length === 1) {
|
|
new $.modal(this, options);
|
|
}
|
|
return this;
|
|
};
|
|
|
|
// Automatically bind links with rel="modal:close" to, well, close the modal.
|
|
$(document).on('click.modal', 'a[rel="modal:close"]', $.modal.close);
|
|
$(document).on('click.modal', 'a[rel="modal:open"]', function(event) {
|
|
event.preventDefault();
|
|
$(this).modal();
|
|
});
|
|
}));
|
|
|
|
/*
|
|
Conversion of 1.6.x popup_menu.js
|
|
*/
|
|
(function($){
|
|
var current_popup = '';
|
|
var PopupMenu = function(el, close_in_popupmenu)
|
|
{
|
|
var el = $(el);
|
|
var popup = this;
|
|
var popup_menu = $("#" + el.attr('id') + "_popup");
|
|
if(typeof close_in_popupmenu == 'undefined')
|
|
{
|
|
var close_in_popupmenu = true;
|
|
}
|
|
// Opening Popup
|
|
this.open = function(e)
|
|
{
|
|
e.preventDefault();
|
|
|
|
if(popup_menu.is(':visible'))
|
|
{
|
|
popup.close();
|
|
return;
|
|
}
|
|
|
|
// Setup popup menu
|
|
var offset = el.offset();
|
|
offset.top += el.outerHeight();
|
|
|
|
// We only adjust if it goes out of the page (?)
|
|
if((el.offset().left + popup_menu.outerWidth()) > $(window).width())
|
|
var adjust = popup_menu.outerWidth() - el.outerWidth();
|
|
else
|
|
var adjust = 0;
|
|
|
|
popup_menu.css({
|
|
position: 'absolute',
|
|
top: offset.top,
|
|
left: offset.left-adjust
|
|
});
|
|
|
|
popup_menu.show();
|
|
|
|
// Closes the popup if we click outside the button (this doesn't seem to work properly - couldn't find any solutions that actually did - if we click the first item on the menu)
|
|
// Credits: http://stackoverflow.com/questions/1160880/detect-click-outside-element
|
|
$('body, .popup_item').bind('click.close_popup', function(e) {
|
|
if(close_in_popupmenu)
|
|
{
|
|
if($(e.target).closest("#" + el.attr('id')).length == 0) {
|
|
popup.close();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if($(e.target).closest("#" + el.attr('id')).length == 0 && $(e.target).closest("#" + el.attr('id') + '_popup').length == 0) {
|
|
popup.close();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
this.close = function(e)
|
|
{
|
|
popup_menu.hide();
|
|
}
|
|
}
|
|
$.fn.popupMenu = function(close_in_popupmenu)
|
|
{
|
|
return this.each(function()
|
|
{
|
|
var popup = new PopupMenu(this, close_in_popupmenu);
|
|
$(this).on('click',popup.open);
|
|
});
|
|
}
|
|
})(jQuery);
|
|
|
|
/*!
|
|
* JavaScript Cookie v2.1.4
|
|
* https://github.com/js-cookie/js-cookie
|
|
*
|
|
* Copyright 2006, 2015 Klaus Hartl & Fagner Brack
|
|
* Released under the MIT license
|
|
*/
|
|
;(function (factory) {
|
|
var registeredInModuleLoader = false;
|
|
if (typeof define === 'function' && define.amd) {
|
|
define(factory);
|
|
registeredInModuleLoader = true;
|
|
}
|
|
if (typeof exports === 'object') {
|
|
module.exports = factory();
|
|
registeredInModuleLoader = true;
|
|
}
|
|
if (!registeredInModuleLoader) {
|
|
var OldCookies = window.Cookies;
|
|
var api = window.Cookies = factory();
|
|
api.noConflict = function () {
|
|
window.Cookies = OldCookies;
|
|
return api;
|
|
};
|
|
}
|
|
}(function () {
|
|
function extend () {
|
|
var i = 0;
|
|
var result = {};
|
|
for (; i < arguments.length; i++) {
|
|
var attributes = arguments[ i ];
|
|
for (var key in attributes) {
|
|
result[key] = attributes[key];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function init (converter) {
|
|
function api (key, value, attributes) {
|
|
var result;
|
|
if (typeof document === 'undefined') {
|
|
return;
|
|
}
|
|
|
|
// Write
|
|
|
|
if (arguments.length > 1) {
|
|
attributes = extend({
|
|
path: '/'
|
|
}, api.defaults, attributes);
|
|
|
|
if (typeof attributes.expires === 'number') {
|
|
var expires = new Date();
|
|
expires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);
|
|
attributes.expires = expires;
|
|
}
|
|
|
|
// We're using "expires" because "max-age" is not supported by IE
|
|
attributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';
|
|
|
|
try {
|
|
result = JSON.stringify(value);
|
|
if (/^[\{\[]/.test(result)) {
|
|
value = result;
|
|
}
|
|
} catch (e) {}
|
|
|
|
if (!converter.write) {
|
|
value = encodeURIComponent(String(value))
|
|
.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);
|
|
} else {
|
|
value = converter.write(value, key);
|
|
}
|
|
|
|
key = encodeURIComponent(String(key));
|
|
key = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);
|
|
key = key.replace(/[\(\)]/g, escape);
|
|
|
|
var stringifiedAttributes = '';
|
|
|
|
for (var attributeName in attributes) {
|
|
if (!attributes[attributeName]) {
|
|
continue;
|
|
}
|
|
stringifiedAttributes += '; ' + attributeName;
|
|
if (attributes[attributeName] === true) {
|
|
continue;
|
|
}
|
|
stringifiedAttributes += '=' + attributes[attributeName];
|
|
}
|
|
return (document.cookie = key + '=' + value + stringifiedAttributes);
|
|
}
|
|
|
|
// Read
|
|
|
|
if (!key) {
|
|
result = {};
|
|
}
|
|
|
|
// To prevent the for loop in the first place assign an empty array
|
|
// in case there are no cookies at all. Also prevents odd result when
|
|
// calling "get()"
|
|
var cookies = document.cookie ? document.cookie.split('; ') : [];
|
|
var rdecode = /(%[0-9A-Z]{2})+/g;
|
|
var i = 0;
|
|
|
|
for (; i < cookies.length; i++) {
|
|
var parts = cookies[i].split('=');
|
|
var cookie = parts.slice(1).join('=');
|
|
|
|
if (cookie.charAt(0) === '"') {
|
|
cookie = cookie.slice(1, -1);
|
|
}
|
|
|
|
try {
|
|
var name = parts[0].replace(rdecode, decodeURIComponent);
|
|
cookie = converter.read ?
|
|
converter.read(cookie, name) : converter(cookie, name) ||
|
|
cookie.replace(rdecode, decodeURIComponent);
|
|
|
|
if (this.json) {
|
|
try {
|
|
cookie = JSON.parse(cookie);
|
|
} catch (e) {}
|
|
}
|
|
|
|
if (key === name) {
|
|
result = cookie;
|
|
break;
|
|
}
|
|
|
|
if (!key) {
|
|
result[name] = cookie;
|
|
}
|
|
} catch (e) {}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
api.set = api;
|
|
api.get = function (key) {
|
|
return api.call(api, key);
|
|
};
|
|
api.getJSON = function () {
|
|
return api.apply({
|
|
json: true
|
|
}, [].slice.call(arguments));
|
|
};
|
|
api.defaults = {};
|
|
|
|
api.remove = function (key, attributes) {
|
|
api(key, '', extend(attributes, {
|
|
expires: -1
|
|
}));
|
|
};
|
|
|
|
api.withConverter = init;
|
|
|
|
return api;
|
|
}
|
|
|
|
return init(function () {});
|
|
})); |