bba967ba21
The star event will allow us to relay any custom events as well as the ones used internally by Select2. This also makes it much easier to start triggering events in general, as we don't need to relay it in the core anymore. A module has been created for the jQuery-facing events, and the release announcement has been updated to mention the event name changes. This also adds some documentation about the public events.
4446 lines
102 KiB
JavaScript
4446 lines
102 KiB
JavaScript
window.$ = window.$ || {};(function() { if ($ && $.fn && $.fn.select2 && $.fn.select2.amd) { define = $.fn.select2.amd.define; require = $.fn.select2.amd.require; }define('select2/utils',[], function () {
|
|
var Utils = {};
|
|
|
|
Utils.Extend = function (ChildClass, SuperClass) {
|
|
var __hasProp = {}.hasOwnProperty;
|
|
|
|
function BaseConstructor () {
|
|
this.constructor = ChildClass;
|
|
}
|
|
|
|
for (var key in SuperClass) {
|
|
if (__hasProp.call(SuperClass, key)) {
|
|
ChildClass[key] = SuperClass[key];
|
|
}
|
|
}
|
|
|
|
BaseConstructor.prototype = SuperClass.prototype;
|
|
ChildClass.prototype = new BaseConstructor();
|
|
ChildClass.__super__ = SuperClass.prototype;
|
|
|
|
return ChildClass;
|
|
};
|
|
|
|
function getMethods (theClass) {
|
|
var proto = theClass.prototype;
|
|
|
|
var methods = [];
|
|
|
|
for (var methodName in proto) {
|
|
var m = proto[methodName];
|
|
|
|
if (typeof m !== 'function') {
|
|
continue;
|
|
}
|
|
|
|
if (methodName === 'constructor') {
|
|
continue;
|
|
}
|
|
|
|
methods.push(methodName);
|
|
}
|
|
|
|
return methods;
|
|
}
|
|
|
|
Utils.Decorate = function (SuperClass, DecoratorClass) {
|
|
var decoratedMethods = getMethods(DecoratorClass);
|
|
var superMethods = getMethods(SuperClass);
|
|
|
|
function DecoratedClass () {
|
|
var unshift = Array.prototype.unshift;
|
|
|
|
var argCount = DecoratorClass.prototype.constructor.length;
|
|
|
|
var calledConstructor = SuperClass.prototype.constructor;
|
|
|
|
if (argCount > 0) {
|
|
unshift.call(arguments, SuperClass.prototype.constructor);
|
|
|
|
calledConstructor = DecoratorClass.prototype.constructor;
|
|
}
|
|
|
|
calledConstructor.apply(this, arguments);
|
|
}
|
|
|
|
DecoratorClass.displayName = SuperClass.displayName;
|
|
|
|
function ctr () {
|
|
this.constructor = DecoratedClass;
|
|
}
|
|
|
|
DecoratedClass.prototype = new ctr();
|
|
|
|
for (var m = 0; m < superMethods.length; m++) {
|
|
var superMethod = superMethods[m];
|
|
|
|
DecoratedClass.prototype[superMethod] =
|
|
SuperClass.prototype[superMethod];
|
|
}
|
|
|
|
var calledMethod = function (methodName) {
|
|
// Stub out the original method if it's not decorating an actual method
|
|
var originalMethod = function () {};
|
|
|
|
if (methodName in DecoratedClass.prototype) {
|
|
originalMethod = DecoratedClass.prototype[methodName];
|
|
}
|
|
|
|
var decoratedMethod = DecoratorClass.prototype[methodName];
|
|
|
|
return function () {
|
|
var unshift = Array.prototype.unshift;
|
|
|
|
unshift.call(arguments, originalMethod);
|
|
|
|
return decoratedMethod.apply(this, arguments);
|
|
};
|
|
};
|
|
|
|
for (var d = 0; d < decoratedMethods.length; d++) {
|
|
var decoratedMethod = decoratedMethods[d];
|
|
|
|
DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod);
|
|
}
|
|
|
|
return DecoratedClass;
|
|
};
|
|
|
|
var Observable = function () {
|
|
this.listeners = {};
|
|
};
|
|
|
|
Observable.prototype.on = function (event, callback) {
|
|
this.listeners = this.listeners || {};
|
|
|
|
if (event in this.listeners) {
|
|
this.listeners[event].push(callback);
|
|
} else {
|
|
this.listeners[event] = [callback];
|
|
}
|
|
};
|
|
|
|
Observable.prototype.trigger = function (event) {
|
|
var slice = Array.prototype.slice;
|
|
|
|
this.listeners = this.listeners || {};
|
|
|
|
if (event in this.listeners) {
|
|
this.invoke(this.listeners[event], slice.call(arguments, 1));
|
|
}
|
|
|
|
if ('*' in this.listeners) {
|
|
this.invoke(this.listeners['*'], arguments);
|
|
}
|
|
};
|
|
|
|
Observable.prototype.invoke = function (listeners, params) {
|
|
for (var i = 0, len = listeners.length; i < len; i++) {
|
|
listeners[i].apply(this, params);
|
|
}
|
|
};
|
|
|
|
Utils.Observable = Observable;
|
|
|
|
Utils.generateChars = function (length) {
|
|
var chars = '';
|
|
|
|
for (var i = 0; i < length; i++) {
|
|
var randomChar = Math.floor(Math.random() * 36);
|
|
chars += randomChar.toString(36);
|
|
}
|
|
|
|
return chars;
|
|
};
|
|
|
|
Utils.bind = function (func, context) {
|
|
return function () {
|
|
func.apply(context, arguments);
|
|
};
|
|
};
|
|
|
|
return Utils;
|
|
});
|
|
|
|
define('select2/results',[
|
|
'jquery',
|
|
'./utils'
|
|
], function ($, Utils) {
|
|
function Results ($element, options, dataAdapter) {
|
|
this.$element = $element;
|
|
this.data = dataAdapter;
|
|
this.options = options;
|
|
|
|
Results.__super__.constructor.call(this);
|
|
}
|
|
|
|
Utils.Extend(Results, Utils.Observable);
|
|
|
|
Results.prototype.render = function () {
|
|
var $results = $(
|
|
'<ul class="select2-results__options" role="tree"></ul>'
|
|
);
|
|
|
|
if (this.options.get('multiple')) {
|
|
$results.attr('aria-multiselectable', 'true');
|
|
}
|
|
|
|
this.$results = $results;
|
|
|
|
return $results;
|
|
};
|
|
|
|
Results.prototype.clear = function () {
|
|
this.$results.empty();
|
|
};
|
|
|
|
Results.prototype.displayMessage = function (params) {
|
|
this.clear();
|
|
this.hideLoading();
|
|
|
|
var $message = $(
|
|
'<li role="treeitem" class="select2-results__option"></li>'
|
|
);
|
|
|
|
var message = this.options.get('translations').get(params.message);
|
|
|
|
$message.text(message(params.args));
|
|
|
|
this.$results.append($message);
|
|
};
|
|
|
|
Results.prototype.append = function (data) {
|
|
this.hideLoading();
|
|
|
|
var $options = [];
|
|
|
|
if (data.results == null || data.results.length === 0) {
|
|
if (this.$results.children().length === 0) {
|
|
this.trigger('results:message', {
|
|
message: 'noResults'
|
|
});
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
data.results = this.sort(data.results);
|
|
|
|
for (var d = 0; d < data.results.length; d++) {
|
|
var item = data.results[d];
|
|
|
|
var $option = this.option(item);
|
|
|
|
$options.push($option);
|
|
}
|
|
|
|
this.$results.append($options);
|
|
};
|
|
|
|
Results.prototype.position = function ($results, $dropdown) {
|
|
var $resultsContainer = $dropdown.find('.select2-results');
|
|
$resultsContainer.append($results);
|
|
};
|
|
|
|
Results.prototype.sort = function (data) {
|
|
var sorter = this.options.get('sorter');
|
|
|
|
return sorter(data);
|
|
};
|
|
|
|
Results.prototype.setClasses = function () {
|
|
var self = this;
|
|
|
|
this.data.current(function (selected) {
|
|
var selectedIds = $.map(selected, function (s) {
|
|
return s.id.toString();
|
|
});
|
|
|
|
var $options = self.$results
|
|
.find('.select2-results__option[aria-selected]');
|
|
|
|
$options.each(function () {
|
|
var $option = $(this);
|
|
|
|
var item = $.data(this, 'data');
|
|
|
|
if (item.id != null && selectedIds.indexOf(item.id.toString()) > -1) {
|
|
$option.attr('aria-selected', 'true');
|
|
} else {
|
|
$option.attr('aria-selected', 'false');
|
|
}
|
|
});
|
|
|
|
var $selected = $options.filter('[aria-selected=true]');
|
|
|
|
// Check if there are any selected options
|
|
if ($selected.length > 0) {
|
|
// If there are selected options, highlight the first
|
|
$selected.first().trigger('mouseenter');
|
|
} else {
|
|
// If there are no selected options, highlight the first option
|
|
// in the dropdown
|
|
$options.first().trigger('mouseenter');
|
|
}
|
|
});
|
|
};
|
|
|
|
Results.prototype.showLoading = function (params) {
|
|
this.hideLoading();
|
|
|
|
var loadingMore = this.options.get('translations').get('searching');
|
|
|
|
var loading = {
|
|
disabled: true,
|
|
loading: true,
|
|
text: loadingMore(params)
|
|
};
|
|
var $loading = this.option(loading);
|
|
$loading.className += ' loading-results';
|
|
|
|
this.$results.prepend($loading);
|
|
};
|
|
|
|
Results.prototype.hideLoading = function () {
|
|
this.$results.find('.loading-results').remove();
|
|
};
|
|
|
|
Results.prototype.option = function (data) {
|
|
var option = document.createElement('li');
|
|
option.className = 'select2-results__option';
|
|
|
|
var attrs = {
|
|
'role': 'treeitem',
|
|
'aria-selected': 'false'
|
|
};
|
|
|
|
if (data.disabled) {
|
|
delete attrs['aria-selected'];
|
|
attrs['aria-disabled'] = 'true';
|
|
}
|
|
|
|
if (data.id == null) {
|
|
delete attrs['aria-selected'];
|
|
}
|
|
|
|
if (data._resultId != null) {
|
|
option.id = data._resultId;
|
|
}
|
|
|
|
if (data.children) {
|
|
attrs.role = 'group';
|
|
attrs['aria-label'] = data.text;
|
|
delete attrs['aria-selected'];
|
|
}
|
|
|
|
for (var attr in attrs) {
|
|
var val = attrs[attr];
|
|
|
|
option.setAttribute(attr, val);
|
|
}
|
|
|
|
if (data.children) {
|
|
var $option = $(option);
|
|
|
|
var label = document.createElement('strong');
|
|
label.className = 'select2-results__group';
|
|
|
|
var $label = $(label);
|
|
this.template(data, label);
|
|
|
|
var $children = [];
|
|
|
|
for (var c = 0; c < data.children.length; c++) {
|
|
var child = data.children[c];
|
|
|
|
var $child = this.option(child);
|
|
|
|
$children.push($child);
|
|
}
|
|
|
|
var $childrenContainer = $('<ul></ul>', {
|
|
'class': 'select2-results__options select2-results__options--nested'
|
|
});
|
|
|
|
$childrenContainer.append($children);
|
|
|
|
$option.append(label);
|
|
$option.append($childrenContainer);
|
|
} else {
|
|
this.template(data, option);
|
|
}
|
|
|
|
$.data(option, 'data', data);
|
|
|
|
return option;
|
|
};
|
|
|
|
Results.prototype.bind = function (container, $container) {
|
|
var self = this;
|
|
|
|
var id = container.id + '-results';
|
|
|
|
this.$results.attr('id', id);
|
|
|
|
container.on('results:all', function (params) {
|
|
self.clear();
|
|
self.append(params.data);
|
|
|
|
if (container.isOpen()) {
|
|
self.setClasses();
|
|
}
|
|
});
|
|
|
|
container.on('results:append', function (params) {
|
|
self.append(params.data);
|
|
|
|
if (container.isOpen()) {
|
|
self.setClasses();
|
|
}
|
|
});
|
|
|
|
container.on('query', function (params) {
|
|
self.showLoading(params);
|
|
});
|
|
|
|
container.on('select', function () {
|
|
if (!container.isOpen()) {
|
|
return;
|
|
}
|
|
|
|
self.setClasses();
|
|
});
|
|
|
|
container.on('unselect', function () {
|
|
if (!container.isOpen()) {
|
|
return;
|
|
}
|
|
|
|
self.setClasses();
|
|
});
|
|
|
|
container.on('open', function () {
|
|
// When the dropdown is open, aria-expended="true"
|
|
self.$results.attr('aria-expanded', 'true');
|
|
self.$results.attr('aria-hidden', 'false');
|
|
|
|
self.setClasses();
|
|
self.ensureHighlightVisible();
|
|
});
|
|
|
|
container.on('close', function () {
|
|
// When the dropdown is closed, aria-expended="false"
|
|
self.$results.attr('aria-expanded', 'false');
|
|
self.$results.attr('aria-hidden', 'true');
|
|
self.$results.removeAttr('aria-activedescendant');
|
|
});
|
|
|
|
container.on('results:select', function () {
|
|
var $highlighted = self.getHighlightedResults();
|
|
|
|
if ($highlighted.length === 0) {
|
|
return;
|
|
}
|
|
|
|
var data = $highlighted.data('data');
|
|
|
|
if ($highlighted.attr('aria-selected') == 'true') {
|
|
self.trigger('unselected', {
|
|
data: data
|
|
});
|
|
} else {
|
|
self.trigger('selected', {
|
|
data: data
|
|
});
|
|
}
|
|
});
|
|
|
|
container.on('results:previous', function () {
|
|
var $highlighted = self.getHighlightedResults();
|
|
|
|
var $options = self.$results.find('[aria-selected]');
|
|
|
|
var currentIndex = $options.index($highlighted);
|
|
|
|
// If we are already at te top, don't move further
|
|
if (currentIndex === 0) {
|
|
return;
|
|
}
|
|
|
|
var nextIndex = currentIndex - 1;
|
|
|
|
// If none are highlighted, highlight the first
|
|
if ($highlighted.length === 0) {
|
|
nextIndex = 0;
|
|
}
|
|
|
|
var $next = $options.eq(nextIndex);
|
|
|
|
$next.trigger('mouseenter');
|
|
|
|
var currentOffset = self.$results.offset().top;
|
|
var nextTop = $next.offset().top;
|
|
var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset);
|
|
|
|
if (nextIndex === 0) {
|
|
self.$results.scrollTop(0);
|
|
} else if (nextTop - currentOffset < 0) {
|
|
self.$results.scrollTop(nextOffset);
|
|
}
|
|
});
|
|
|
|
container.on('results:next', function () {
|
|
var $highlighted = self.getHighlightedResults();
|
|
|
|
var $options = self.$results.find('[aria-selected]');
|
|
|
|
var currentIndex = $options.index($highlighted);
|
|
|
|
var nextIndex = currentIndex + 1;
|
|
|
|
// If we are at the last option, stay there
|
|
if (nextIndex >= $options.length) {
|
|
return;
|
|
}
|
|
|
|
var $next = $options.eq(nextIndex);
|
|
|
|
$next.trigger('mouseenter');
|
|
|
|
var currentOffset = self.$results.offset().top +
|
|
self.$results.outerHeight(false);
|
|
var nextBottom = $next.offset().top + $next.outerHeight(false);
|
|
var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset;
|
|
|
|
if (nextIndex === 0) {
|
|
self.$results.scrollTop(0);
|
|
} else if (nextBottom > currentOffset) {
|
|
self.$results.scrollTop(nextOffset);
|
|
}
|
|
});
|
|
|
|
container.on('results:focus', function (params) {
|
|
params.element.addClass('select2-results__option--highlighted');
|
|
});
|
|
|
|
container.on('results:message', function (params) {
|
|
self.trigger('results:message', params);
|
|
});
|
|
|
|
this.on('results:message', function (params) {
|
|
self.displayMessage(params);
|
|
});
|
|
|
|
if ($.fn.mousewheel) {
|
|
this.$results.on('mousewheel', function (e) {
|
|
var top = self.$results.scrollTop();
|
|
|
|
var bottom = (
|
|
self.$results.get(0).scrollHeight -
|
|
self.$results.scrollTop() +
|
|
e.deltaY
|
|
);
|
|
|
|
var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0;
|
|
var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height();
|
|
|
|
if (isAtTop) {
|
|
self.$results.scrollTop(0);
|
|
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
} else if (isAtBottom) {
|
|
self.$results.scrollTop(
|
|
self.$results.get(0).scrollHeight - self.$results.height()
|
|
);
|
|
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
}
|
|
});
|
|
}
|
|
|
|
this.$results.on('mouseup', '.select2-results__option[aria-selected]',
|
|
function (evt) {
|
|
var $this = $(this);
|
|
|
|
var data = $this.data('data');
|
|
|
|
if ($this.attr('aria-selected') === 'true') {
|
|
self.trigger('unselected', {
|
|
originalEvent: evt,
|
|
data: data
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
self.trigger('selected', {
|
|
originalEvent: evt,
|
|
data: data
|
|
});
|
|
});
|
|
|
|
this.$results.on('mouseenter', '.select2-results__option[aria-selected]',
|
|
function (evt) {
|
|
var data = $(this).data('data');
|
|
|
|
self.getHighlightedResults()
|
|
.removeClass('select2-results__option--highlighted');
|
|
|
|
self.trigger('results:focus', {
|
|
data: data,
|
|
element: $(this)
|
|
});
|
|
});
|
|
};
|
|
|
|
Results.prototype.getHighlightedResults = function () {
|
|
var $highlighted = this.$results
|
|
.find('.select2-results__option--highlighted');
|
|
|
|
return $highlighted;
|
|
};
|
|
|
|
Results.prototype.destroy = function () {
|
|
this.$results.remove();
|
|
};
|
|
|
|
Results.prototype.ensureHighlightVisible = function () {
|
|
var $highlighted = this.getHighlightedResults();
|
|
|
|
if ($highlighted.length === 0) {
|
|
return;
|
|
}
|
|
|
|
var $options = this.$results.find('[aria-selected]');
|
|
|
|
var currentIndex = $options.index($highlighted);
|
|
|
|
var currentOffset = this.$results.offset().top;
|
|
var nextTop = $highlighted.offset().top;
|
|
var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset);
|
|
|
|
var offsetDelta = nextTop - currentOffset;
|
|
nextOffset -= $highlighted.outerHeight(false) * 2;
|
|
|
|
if (currentIndex <= 2) {
|
|
this.$results.scrollTop(0);
|
|
} else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) {
|
|
this.$results.scrollTop(nextOffset);
|
|
}
|
|
};
|
|
|
|
Results.prototype.template = function (result, container) {
|
|
var template = this.options.get('templateResult');
|
|
|
|
container.innerHTML = template(result);
|
|
};
|
|
|
|
return Results;
|
|
});
|
|
|
|
define('select2/keys',[
|
|
|
|
], function () {
|
|
var KEYS = {
|
|
BACKSPACE: 8,
|
|
TAB: 9,
|
|
ENTER: 13,
|
|
SHIFT: 16,
|
|
CTRL: 17,
|
|
ALT: 18,
|
|
ESC: 27,
|
|
SPACE: 32,
|
|
PAGE_UP: 33,
|
|
PAGE_DOWN: 34,
|
|
END: 35,
|
|
HOME: 36,
|
|
LEFT: 37,
|
|
UP: 38,
|
|
RIGHT: 39,
|
|
DOWN: 40,
|
|
DELETE: 46,
|
|
|
|
isArrow: function (k) {
|
|
k = k.which ? k.which : k;
|
|
|
|
switch (k) {
|
|
case KEY.LEFT:
|
|
case KEY.RIGHT:
|
|
case KEY.UP:
|
|
case KEY.DOWN:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
return KEYS;
|
|
});
|
|
|
|
define('select2/selection/base',[
|
|
'../utils',
|
|
'../keys'
|
|
], function (Utils, KEYS) {
|
|
function BaseSelection ($element, options) {
|
|
this.$element = $element;
|
|
this.options = options;
|
|
|
|
BaseSelection.__super__.constructor.call(this);
|
|
}
|
|
|
|
Utils.Extend(BaseSelection, Utils.Observable);
|
|
|
|
BaseSelection.prototype.render = function () {
|
|
throw new Error('The `render` method must be defined in child classes.');
|
|
};
|
|
|
|
BaseSelection.prototype.bind = function (container, $container) {
|
|
var self = this;
|
|
|
|
var id = container.id + '-container';
|
|
var resultsId = container.id + '-results';
|
|
|
|
this.container = container;
|
|
|
|
this.$selection.attr('aria-owns', resultsId);
|
|
|
|
this.$selection.on('keydown', function (evt) {
|
|
self.trigger('keypress', evt);
|
|
|
|
if (evt.which === KEYS.SPACE) {
|
|
evt.preventDefault();
|
|
}
|
|
});
|
|
|
|
container.on('results:focus', function (params) {
|
|
self.$selection.attr('aria-activedescendant', params.data._resultId);
|
|
});
|
|
|
|
container.on('selection:update', function (params) {
|
|
self.update(params.data);
|
|
});
|
|
|
|
container.on('open', function () {
|
|
// When the dropdown is open, aria-expanded="true"
|
|
self.$selection.attr('aria-expanded', 'true');
|
|
|
|
self._attachCloseHandler(container);
|
|
});
|
|
|
|
container.on('close', function () {
|
|
// When the dropdown is closed, aria-expanded="false"
|
|
self.$selection.attr('aria-expanded', 'false');
|
|
self.$selection.removeAttr('aria-activedescendant');
|
|
|
|
self.$selection.focus();
|
|
|
|
self._detachCloseHandler(container);
|
|
});
|
|
};
|
|
|
|
BaseSelection.prototype._attachCloseHandler = function (container) {
|
|
var self = this;
|
|
|
|
$(document.body).on('mousedown.select2.' + container.id, function (e) {
|
|
var $target = $(e.target);
|
|
|
|
var $select = $target.closest('.select2');
|
|
|
|
var $all = $('.select2.select2-container--open');
|
|
|
|
$all.each(function () {
|
|
var $this = $(this);
|
|
|
|
if (this == $select[0]) {
|
|
return;
|
|
}
|
|
|
|
var $element = $this.data('element');
|
|
|
|
$element.select2('close');
|
|
});
|
|
});
|
|
|
|
$(window).on('scroll.select2.' + container.id, function (e) {
|
|
self.trigger('close');
|
|
});
|
|
};
|
|
|
|
BaseSelection.prototype._detachCloseHandler = function (container) {
|
|
$(document.body).off('mousedown.select2.' + container.id);
|
|
$(window).off('scroll.select2.' + container.id);
|
|
};
|
|
|
|
BaseSelection.prototype.position = function ($selection, $container) {
|
|
var $selectionContainer = $container.find('.selection');
|
|
$selectionContainer.append($selection);
|
|
};
|
|
|
|
BaseSelection.prototype.destroy = function () {
|
|
this._detachCloseHandler(this.container);
|
|
};
|
|
|
|
BaseSelection.prototype.update = function (data) {
|
|
throw new Error('The `update` method must be defined in child classes.');
|
|
};
|
|
|
|
return BaseSelection;
|
|
});
|
|
|
|
define('select2/selection/single',[
|
|
'./base',
|
|
'../utils',
|
|
'../keys'
|
|
], function (BaseSelection, Utils, KEYS) {
|
|
function SingleSelection () {
|
|
SingleSelection.__super__.constructor.apply(this, arguments);
|
|
}
|
|
|
|
Utils.Extend(SingleSelection, BaseSelection);
|
|
|
|
SingleSelection.prototype.render = function () {
|
|
var $selection = $(
|
|
'<span class="select2-selection select2-selection--single" tabindex="0"' +
|
|
' role="combobox" aria-autocomplete="list" aria-haspopup="true"' +
|
|
' aria-expanded="false">' +
|
|
'<span class="select2-selection__rendered"></span>' +
|
|
'<span class="select2-selection__arrow" role="presentation">' +
|
|
'<b role="presentation"></b>' +
|
|
'</span>' +
|
|
'</span>'
|
|
);
|
|
|
|
$selection.attr('title', this.$element.attr('title'));
|
|
|
|
this.$selection = $selection;
|
|
|
|
return $selection;
|
|
};
|
|
|
|
SingleSelection.prototype.bind = function (container, $container) {
|
|
var self = this;
|
|
|
|
SingleSelection.__super__.bind.apply(this, arguments);
|
|
|
|
var id = container.id + '-container';
|
|
|
|
this.$selection.find('.select2-selection__rendered').attr('id', id);
|
|
this.$selection.attr('aria-labelledby', id);
|
|
|
|
this.$selection.on('mousedown', function (evt) {
|
|
// Only respond to left clicks
|
|
if (evt.which !== 1) {
|
|
return;
|
|
}
|
|
|
|
self.trigger('toggle', {
|
|
originalEvent: evt
|
|
});
|
|
});
|
|
|
|
this.$selection.on('focus', function (evt) {
|
|
// User focuses on the container
|
|
});
|
|
|
|
this.$selection.on('blur', function (evt) {
|
|
// User exits the container
|
|
});
|
|
|
|
container.on('enable', function () {
|
|
self.$selection.attr('tabindex', '0');
|
|
});
|
|
|
|
container.on('disable', function () {
|
|
self.$selection.attr('tabindex', '-1');
|
|
});
|
|
|
|
container.on('selection:update', function (params) {
|
|
self.update(params.data);
|
|
});
|
|
};
|
|
|
|
SingleSelection.prototype.clear = function () {
|
|
this.$selection.find('.select2-selection__rendered').empty();
|
|
};
|
|
|
|
SingleSelection.prototype.display = function (data) {
|
|
var template = this.options.get('templateSelection');
|
|
|
|
return template(data);
|
|
};
|
|
|
|
SingleSelection.prototype.selectionContainer = function () {
|
|
return $('<span></span>');
|
|
};
|
|
|
|
SingleSelection.prototype.update = function (data) {
|
|
if (data.length === 0) {
|
|
this.clear();
|
|
return;
|
|
}
|
|
|
|
var selection = data[0];
|
|
|
|
var formatted = this.display(selection);
|
|
|
|
this.$selection.find('.select2-selection__rendered').html(formatted);
|
|
};
|
|
|
|
return SingleSelection;
|
|
});
|
|
|
|
define('select2/selection/multiple',[
|
|
'./base',
|
|
'../utils'
|
|
], function (BaseSelection, Utils) {
|
|
function MultipleSelection ($element, options) {
|
|
MultipleSelection.__super__.constructor.apply(this, arguments);
|
|
}
|
|
|
|
Utils.Extend(MultipleSelection, BaseSelection);
|
|
|
|
MultipleSelection.prototype.render = function () {
|
|
var $selection = $(
|
|
'<span class="select2-selection select2-selection--multiple"' +
|
|
' tabindex="0" role="combobox" aria-autocomplete="list"' +
|
|
' aria-haspopup="true" aria-expanded="false">' +
|
|
'<ul class="select2-selection__rendered"></ul>' +
|
|
'</span>'
|
|
);
|
|
|
|
$selection.attr('title', this.$element.attr('title'));
|
|
|
|
this.$selection = $selection;
|
|
|
|
return $selection;
|
|
};
|
|
|
|
MultipleSelection.prototype.bind = function (container, $container) {
|
|
var self = this;
|
|
|
|
MultipleSelection.__super__.bind.apply(this, arguments);
|
|
|
|
this.$selection.on('click', function (evt) {
|
|
self.trigger('toggle', {
|
|
originalEvent: evt
|
|
});
|
|
});
|
|
|
|
this.$selection.on('click', '.select2-selection__choice__remove',
|
|
function (evt) {
|
|
var $remove = $(this);
|
|
var $selection = $remove.parent();
|
|
|
|
var data = $selection.data('data');
|
|
|
|
self.trigger('unselected', {
|
|
originalEvent: evt,
|
|
data: data
|
|
});
|
|
});
|
|
|
|
container.on('enable', function () {
|
|
self.$selection.attr('tabindex', '0');
|
|
});
|
|
|
|
container.on('disable', function () {
|
|
self.$selection.attr('tabindex', '-1');
|
|
});
|
|
};
|
|
|
|
MultipleSelection.prototype.clear = function () {
|
|
this.$selection.find('.select2-selection__rendered').empty();
|
|
};
|
|
|
|
MultipleSelection.prototype.display = function (data) {
|
|
var template = this.options.get('templateSelection');
|
|
|
|
return template(data);
|
|
};
|
|
|
|
MultipleSelection.prototype.selectionContainer = function () {
|
|
var $container = $(
|
|
'<li class="select2-selection__choice">' +
|
|
'<span class="select2-selection__choice__remove" role="presentation">' +
|
|
'×' +
|
|
'</span>' +
|
|
'</li>'
|
|
);
|
|
|
|
return $container;
|
|
};
|
|
|
|
MultipleSelection.prototype.update = function (data) {
|
|
this.clear();
|
|
|
|
if (data.length === 0) {
|
|
return;
|
|
}
|
|
|
|
var $selections = [];
|
|
|
|
for (var d = 0; d < data.length; d++) {
|
|
var selection = data[d];
|
|
|
|
var formatted = this.display(selection);
|
|
var $selection = this.selectionContainer();
|
|
|
|
$selection.append(formatted);
|
|
$selection.data('data', selection);
|
|
|
|
$selections.push($selection);
|
|
}
|
|
|
|
this.$selection.find('.select2-selection__rendered').append($selections);
|
|
};
|
|
|
|
return MultipleSelection;
|
|
});
|
|
|
|
define('select2/selection/placeholder',[
|
|
'../utils'
|
|
], function (Utils) {
|
|
function Placeholder (decorated, $element, options) {
|
|
this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
|
|
|
|
decorated.call(this, $element, options);
|
|
}
|
|
|
|
Placeholder.prototype.normalizePlaceholder = function (_, placeholder) {
|
|
if (typeof placeholder === 'string') {
|
|
placeholder = {
|
|
id: '',
|
|
text: placeholder
|
|
};
|
|
}
|
|
|
|
return placeholder;
|
|
};
|
|
|
|
Placeholder.prototype.createPlaceholder = function (decorated, placeholder) {
|
|
var $placeholder = this.selectionContainer();
|
|
|
|
$placeholder.html(this.display(placeholder));
|
|
$placeholder.addClass('select2-selection__placeholder')
|
|
.removeClass('select2-selection__choice');
|
|
|
|
return $placeholder;
|
|
};
|
|
|
|
Placeholder.prototype.update = function (decorated, data) {
|
|
var singlePlaceholder = (
|
|
data.length == 1 && data[0].id != this.placeholder.id
|
|
);
|
|
var multipleSelections = data.length > 1;
|
|
|
|
if (multipleSelections || singlePlaceholder) {
|
|
return decorated.call(this, data);
|
|
}
|
|
|
|
this.clear();
|
|
|
|
var $placeholder = this.createPlaceholder(this.placeholder);
|
|
|
|
this.$selection.find('.select2-selection__rendered').append($placeholder);
|
|
};
|
|
|
|
return Placeholder;
|
|
});
|
|
|
|
define('select2/selection/allowClear',[
|
|
|
|
], function () {
|
|
function AllowClear () { }
|
|
|
|
AllowClear.prototype.bind = function (decorated, container, $container) {
|
|
var self = this;
|
|
|
|
decorated.call(this, container, $container);
|
|
|
|
this.$selection.on('mousedown', '.select2-selection__clear',
|
|
function (evt) {
|
|
evt.stopPropagation();
|
|
|
|
self.$element.val(self.placeholder.id).trigger('change');
|
|
|
|
self.trigger('toggle');
|
|
});
|
|
};
|
|
|
|
AllowClear.prototype.update = function (decorated, data) {
|
|
decorated.call(this, data);
|
|
|
|
if (this.$selection.find('.select2-selection__placeholder').length > 0) {
|
|
return;
|
|
}
|
|
|
|
var $remove = $(
|
|
'<span class="select2-selection__clear">' +
|
|
'×' +
|
|
'</span>'
|
|
);
|
|
|
|
this.$selection.find('.select2-selection__rendered').append($remove);
|
|
};
|
|
|
|
return AllowClear;
|
|
});
|
|
|
|
define('select2/selection/search',[
|
|
'../utils',
|
|
'../keys'
|
|
], function (Utils, KEYS) {
|
|
function Search (decorated, $element, options) {
|
|
decorated.call(this, $element, options);
|
|
}
|
|
|
|
Search.prototype.render = function (decorated) {
|
|
var $search = $(
|
|
'<li class="select2-search select2-search--inline">' +
|
|
'<input class="select2-search__field" type="search" tabindex="-1"' +
|
|
' role="textbox" />' +
|
|
'</li>'
|
|
);
|
|
|
|
this.$searchContainer = $search;
|
|
this.$search = $search.find('input');
|
|
|
|
var $rendered = decorated.call(this);
|
|
|
|
return $rendered;
|
|
};
|
|
|
|
Search.prototype.bind = function (decorated, container, $container) {
|
|
var self = this;
|
|
|
|
decorated.call(this, container, $container);
|
|
|
|
container.on('open', function () {
|
|
self.$search.attr('tabindex', 0);
|
|
|
|
self.$search.focus();
|
|
});
|
|
|
|
container.on('close', function () {
|
|
self.$search.attr('tabindex', -1);
|
|
|
|
self.$search.val('');
|
|
});
|
|
|
|
container.on('enable', function () {
|
|
self.$search.prop('disabled', false);
|
|
});
|
|
|
|
container.on('disable', function () {
|
|
self.$search.prop('disabled', true);
|
|
});
|
|
|
|
this.$selection.on('keydown', '.select2-search--inline', function (evt) {
|
|
evt.stopPropagation();
|
|
|
|
self.trigger('keypress', evt);
|
|
|
|
self._keyUpPrevented = evt.isDefaultPrevented();
|
|
|
|
var key = evt.which;
|
|
|
|
if (key === KEYS.BACKSPACE && self.$search.val() === '') {
|
|
var $previousChoice = self.$searchContainer
|
|
.prev('.select2-selection__choice');
|
|
|
|
if ($previousChoice.length > 0) {
|
|
var item = $previousChoice.data('data');
|
|
|
|
self.searchRemoveChoice(item);
|
|
}
|
|
}
|
|
});
|
|
|
|
this.$selection.on('keyup', '.select2-search--inline', function (evt) {
|
|
self.handleSearch(evt);
|
|
});
|
|
};
|
|
|
|
Search.prototype.createPlaceholder = function (decorated, placeholder) {
|
|
this.$search.attr('placeholder', placeholder.text);
|
|
};
|
|
|
|
Search.prototype.update = function (decorated, data) {
|
|
this.$search.attr('placeholder', '');
|
|
|
|
decorated.call(this, data);
|
|
|
|
this.$selection.find('.select2-selection__rendered')
|
|
.append(this.$searchContainer);
|
|
|
|
this.resizeSearch();
|
|
};
|
|
|
|
Search.prototype.handleSearch = function () {
|
|
this.resizeSearch();
|
|
|
|
if (!this._keyUpPrevented) {
|
|
var input = this.$search.val();
|
|
|
|
this.trigger('query', {
|
|
term: input
|
|
});
|
|
}
|
|
|
|
this._keyUpPrevented = false;
|
|
};
|
|
|
|
Search.prototype.searchRemoveChoice = function (decorated, item) {
|
|
this.trigger('unselected', {
|
|
data: item
|
|
});
|
|
|
|
this.trigger('open');
|
|
|
|
this.$search.val(item.text + ' ');
|
|
};
|
|
|
|
Search.prototype.resizeSearch = function () {
|
|
this.$search.css('width', '25px');
|
|
|
|
var width = '';
|
|
|
|
if (this.$search.attr('placeholder') !== '') {
|
|
width = this.$selection.innerWidth();
|
|
width -= this.$selection.find('.select2-selection__rendered')
|
|
.innerWidth();
|
|
|
|
width = width + 'px';
|
|
} else {
|
|
var minimumWidth = this.$search.val().length + 1;
|
|
|
|
width = (minimumWidth * 0.75) + 'em';
|
|
}
|
|
|
|
this.$search.css('width', width);
|
|
};
|
|
|
|
return Search;
|
|
});
|
|
|
|
define('select2/translation',[
|
|
|
|
], function () {
|
|
function Translation (dict) {
|
|
this.dict = dict || {};
|
|
}
|
|
|
|
Translation.prototype.all = function () {
|
|
return this.dict;
|
|
};
|
|
|
|
Translation.prototype.get = function (key) {
|
|
return this.dict[key];
|
|
};
|
|
|
|
Translation.prototype.extend = function (translation) {
|
|
this.dict = $.extend({}, translation.all(), this.dict);
|
|
};
|
|
|
|
// Static functions
|
|
|
|
Translation._cache = {};
|
|
|
|
Translation.loadPath = function (path) {
|
|
if (!(path in Translation._cache)) {
|
|
var translations = require(path);
|
|
|
|
Translation._cache[path] = translations;
|
|
}
|
|
|
|
return new Translation(Translation._cache[path]);
|
|
};
|
|
|
|
return Translation;
|
|
});
|
|
|
|
define('select2/diacritics',[
|
|
|
|
], function () {
|
|
var diacritics = {
|
|
'\u24B6': 'A',
|
|
'\uFF21': 'A',
|
|
'\u00C0': 'A',
|
|
'\u00C1': 'A',
|
|
'\u00C2': 'A',
|
|
'\u1EA6': 'A',
|
|
'\u1EA4': 'A',
|
|
'\u1EAA': 'A',
|
|
'\u1EA8': 'A',
|
|
'\u00C3': 'A',
|
|
'\u0100': 'A',
|
|
'\u0102': 'A',
|
|
'\u1EB0': 'A',
|
|
'\u1EAE': 'A',
|
|
'\u1EB4': 'A',
|
|
'\u1EB2': 'A',
|
|
'\u0226': 'A',
|
|
'\u01E0': 'A',
|
|
'\u00C4': 'A',
|
|
'\u01DE': 'A',
|
|
'\u1EA2': 'A',
|
|
'\u00C5': 'A',
|
|
'\u01FA': 'A',
|
|
'\u01CD': 'A',
|
|
'\u0200': 'A',
|
|
'\u0202': 'A',
|
|
'\u1EA0': 'A',
|
|
'\u1EAC': 'A',
|
|
'\u1EB6': 'A',
|
|
'\u1E00': 'A',
|
|
'\u0104': 'A',
|
|
'\u023A': 'A',
|
|
'\u2C6F': 'A',
|
|
'\uA732': 'AA',
|
|
'\u00C6': 'AE',
|
|
'\u01FC': 'AE',
|
|
'\u01E2': 'AE',
|
|
'\uA734': 'AO',
|
|
'\uA736': 'AU',
|
|
'\uA738': 'AV',
|
|
'\uA73A': 'AV',
|
|
'\uA73C': 'AY',
|
|
'\u24B7': 'B',
|
|
'\uFF22': 'B',
|
|
'\u1E02': 'B',
|
|
'\u1E04': 'B',
|
|
'\u1E06': 'B',
|
|
'\u0243': 'B',
|
|
'\u0182': 'B',
|
|
'\u0181': 'B',
|
|
'\u24B8': 'C',
|
|
'\uFF23': 'C',
|
|
'\u0106': 'C',
|
|
'\u0108': 'C',
|
|
'\u010A': 'C',
|
|
'\u010C': 'C',
|
|
'\u00C7': 'C',
|
|
'\u1E08': 'C',
|
|
'\u0187': 'C',
|
|
'\u023B': 'C',
|
|
'\uA73E': 'C',
|
|
'\u24B9': 'D',
|
|
'\uFF24': 'D',
|
|
'\u1E0A': 'D',
|
|
'\u010E': 'D',
|
|
'\u1E0C': 'D',
|
|
'\u1E10': 'D',
|
|
'\u1E12': 'D',
|
|
'\u1E0E': 'D',
|
|
'\u0110': 'D',
|
|
'\u018B': 'D',
|
|
'\u018A': 'D',
|
|
'\u0189': 'D',
|
|
'\uA779': 'D',
|
|
'\u01F1': 'DZ',
|
|
'\u01C4': 'DZ',
|
|
'\u01F2': 'Dz',
|
|
'\u01C5': 'Dz',
|
|
'\u24BA': 'E',
|
|
'\uFF25': 'E',
|
|
'\u00C8': 'E',
|
|
'\u00C9': 'E',
|
|
'\u00CA': 'E',
|
|
'\u1EC0': 'E',
|
|
'\u1EBE': 'E',
|
|
'\u1EC4': 'E',
|
|
'\u1EC2': 'E',
|
|
'\u1EBC': 'E',
|
|
'\u0112': 'E',
|
|
'\u1E14': 'E',
|
|
'\u1E16': 'E',
|
|
'\u0114': 'E',
|
|
'\u0116': 'E',
|
|
'\u00CB': 'E',
|
|
'\u1EBA': 'E',
|
|
'\u011A': 'E',
|
|
'\u0204': 'E',
|
|
'\u0206': 'E',
|
|
'\u1EB8': 'E',
|
|
'\u1EC6': 'E',
|
|
'\u0228': 'E',
|
|
'\u1E1C': 'E',
|
|
'\u0118': 'E',
|
|
'\u1E18': 'E',
|
|
'\u1E1A': 'E',
|
|
'\u0190': 'E',
|
|
'\u018E': 'E',
|
|
'\u24BB': 'F',
|
|
'\uFF26': 'F',
|
|
'\u1E1E': 'F',
|
|
'\u0191': 'F',
|
|
'\uA77B': 'F',
|
|
'\u24BC': 'G',
|
|
'\uFF27': 'G',
|
|
'\u01F4': 'G',
|
|
'\u011C': 'G',
|
|
'\u1E20': 'G',
|
|
'\u011E': 'G',
|
|
'\u0120': 'G',
|
|
'\u01E6': 'G',
|
|
'\u0122': 'G',
|
|
'\u01E4': 'G',
|
|
'\u0193': 'G',
|
|
'\uA7A0': 'G',
|
|
'\uA77D': 'G',
|
|
'\uA77E': 'G',
|
|
'\u24BD': 'H',
|
|
'\uFF28': 'H',
|
|
'\u0124': 'H',
|
|
'\u1E22': 'H',
|
|
'\u1E26': 'H',
|
|
'\u021E': 'H',
|
|
'\u1E24': 'H',
|
|
'\u1E28': 'H',
|
|
'\u1E2A': 'H',
|
|
'\u0126': 'H',
|
|
'\u2C67': 'H',
|
|
'\u2C75': 'H',
|
|
'\uA78D': 'H',
|
|
'\u24BE': 'I',
|
|
'\uFF29': 'I',
|
|
'\u00CC': 'I',
|
|
'\u00CD': 'I',
|
|
'\u00CE': 'I',
|
|
'\u0128': 'I',
|
|
'\u012A': 'I',
|
|
'\u012C': 'I',
|
|
'\u0130': 'I',
|
|
'\u00CF': 'I',
|
|
'\u1E2E': 'I',
|
|
'\u1EC8': 'I',
|
|
'\u01CF': 'I',
|
|
'\u0208': 'I',
|
|
'\u020A': 'I',
|
|
'\u1ECA': 'I',
|
|
'\u012E': 'I',
|
|
'\u1E2C': 'I',
|
|
'\u0197': 'I',
|
|
'\u24BF': 'J',
|
|
'\uFF2A': 'J',
|
|
'\u0134': 'J',
|
|
'\u0248': 'J',
|
|
'\u24C0': 'K',
|
|
'\uFF2B': 'K',
|
|
'\u1E30': 'K',
|
|
'\u01E8': 'K',
|
|
'\u1E32': 'K',
|
|
'\u0136': 'K',
|
|
'\u1E34': 'K',
|
|
'\u0198': 'K',
|
|
'\u2C69': 'K',
|
|
'\uA740': 'K',
|
|
'\uA742': 'K',
|
|
'\uA744': 'K',
|
|
'\uA7A2': 'K',
|
|
'\u24C1': 'L',
|
|
'\uFF2C': 'L',
|
|
'\u013F': 'L',
|
|
'\u0139': 'L',
|
|
'\u013D': 'L',
|
|
'\u1E36': 'L',
|
|
'\u1E38': 'L',
|
|
'\u013B': 'L',
|
|
'\u1E3C': 'L',
|
|
'\u1E3A': 'L',
|
|
'\u0141': 'L',
|
|
'\u023D': 'L',
|
|
'\u2C62': 'L',
|
|
'\u2C60': 'L',
|
|
'\uA748': 'L',
|
|
'\uA746': 'L',
|
|
'\uA780': 'L',
|
|
'\u01C7': 'LJ',
|
|
'\u01C8': 'Lj',
|
|
'\u24C2': 'M',
|
|
'\uFF2D': 'M',
|
|
'\u1E3E': 'M',
|
|
'\u1E40': 'M',
|
|
'\u1E42': 'M',
|
|
'\u2C6E': 'M',
|
|
'\u019C': 'M',
|
|
'\u24C3': 'N',
|
|
'\uFF2E': 'N',
|
|
'\u01F8': 'N',
|
|
'\u0143': 'N',
|
|
'\u00D1': 'N',
|
|
'\u1E44': 'N',
|
|
'\u0147': 'N',
|
|
'\u1E46': 'N',
|
|
'\u0145': 'N',
|
|
'\u1E4A': 'N',
|
|
'\u1E48': 'N',
|
|
'\u0220': 'N',
|
|
'\u019D': 'N',
|
|
'\uA790': 'N',
|
|
'\uA7A4': 'N',
|
|
'\u01CA': 'NJ',
|
|
'\u01CB': 'Nj',
|
|
'\u24C4': 'O',
|
|
'\uFF2F': 'O',
|
|
'\u00D2': 'O',
|
|
'\u00D3': 'O',
|
|
'\u00D4': 'O',
|
|
'\u1ED2': 'O',
|
|
'\u1ED0': 'O',
|
|
'\u1ED6': 'O',
|
|
'\u1ED4': 'O',
|
|
'\u00D5': 'O',
|
|
'\u1E4C': 'O',
|
|
'\u022C': 'O',
|
|
'\u1E4E': 'O',
|
|
'\u014C': 'O',
|
|
'\u1E50': 'O',
|
|
'\u1E52': 'O',
|
|
'\u014E': 'O',
|
|
'\u022E': 'O',
|
|
'\u0230': 'O',
|
|
'\u00D6': 'O',
|
|
'\u022A': 'O',
|
|
'\u1ECE': 'O',
|
|
'\u0150': 'O',
|
|
'\u01D1': 'O',
|
|
'\u020C': 'O',
|
|
'\u020E': 'O',
|
|
'\u01A0': 'O',
|
|
'\u1EDC': 'O',
|
|
'\u1EDA': 'O',
|
|
'\u1EE0': 'O',
|
|
'\u1EDE': 'O',
|
|
'\u1EE2': 'O',
|
|
'\u1ECC': 'O',
|
|
'\u1ED8': 'O',
|
|
'\u01EA': 'O',
|
|
'\u01EC': 'O',
|
|
'\u00D8': 'O',
|
|
'\u01FE': 'O',
|
|
'\u0186': 'O',
|
|
'\u019F': 'O',
|
|
'\uA74A': 'O',
|
|
'\uA74C': 'O',
|
|
'\u01A2': 'OI',
|
|
'\uA74E': 'OO',
|
|
'\u0222': 'OU',
|
|
'\u24C5': 'P',
|
|
'\uFF30': 'P',
|
|
'\u1E54': 'P',
|
|
'\u1E56': 'P',
|
|
'\u01A4': 'P',
|
|
'\u2C63': 'P',
|
|
'\uA750': 'P',
|
|
'\uA752': 'P',
|
|
'\uA754': 'P',
|
|
'\u24C6': 'Q',
|
|
'\uFF31': 'Q',
|
|
'\uA756': 'Q',
|
|
'\uA758': 'Q',
|
|
'\u024A': 'Q',
|
|
'\u24C7': 'R',
|
|
'\uFF32': 'R',
|
|
'\u0154': 'R',
|
|
'\u1E58': 'R',
|
|
'\u0158': 'R',
|
|
'\u0210': 'R',
|
|
'\u0212': 'R',
|
|
'\u1E5A': 'R',
|
|
'\u1E5C': 'R',
|
|
'\u0156': 'R',
|
|
'\u1E5E': 'R',
|
|
'\u024C': 'R',
|
|
'\u2C64': 'R',
|
|
'\uA75A': 'R',
|
|
'\uA7A6': 'R',
|
|
'\uA782': 'R',
|
|
'\u24C8': 'S',
|
|
'\uFF33': 'S',
|
|
'\u1E9E': 'S',
|
|
'\u015A': 'S',
|
|
'\u1E64': 'S',
|
|
'\u015C': 'S',
|
|
'\u1E60': 'S',
|
|
'\u0160': 'S',
|
|
'\u1E66': 'S',
|
|
'\u1E62': 'S',
|
|
'\u1E68': 'S',
|
|
'\u0218': 'S',
|
|
'\u015E': 'S',
|
|
'\u2C7E': 'S',
|
|
'\uA7A8': 'S',
|
|
'\uA784': 'S',
|
|
'\u24C9': 'T',
|
|
'\uFF34': 'T',
|
|
'\u1E6A': 'T',
|
|
'\u0164': 'T',
|
|
'\u1E6C': 'T',
|
|
'\u021A': 'T',
|
|
'\u0162': 'T',
|
|
'\u1E70': 'T',
|
|
'\u1E6E': 'T',
|
|
'\u0166': 'T',
|
|
'\u01AC': 'T',
|
|
'\u01AE': 'T',
|
|
'\u023E': 'T',
|
|
'\uA786': 'T',
|
|
'\uA728': 'TZ',
|
|
'\u24CA': 'U',
|
|
'\uFF35': 'U',
|
|
'\u00D9': 'U',
|
|
'\u00DA': 'U',
|
|
'\u00DB': 'U',
|
|
'\u0168': 'U',
|
|
'\u1E78': 'U',
|
|
'\u016A': 'U',
|
|
'\u1E7A': 'U',
|
|
'\u016C': 'U',
|
|
'\u00DC': 'U',
|
|
'\u01DB': 'U',
|
|
'\u01D7': 'U',
|
|
'\u01D5': 'U',
|
|
'\u01D9': 'U',
|
|
'\u1EE6': 'U',
|
|
'\u016E': 'U',
|
|
'\u0170': 'U',
|
|
'\u01D3': 'U',
|
|
'\u0214': 'U',
|
|
'\u0216': 'U',
|
|
'\u01AF': 'U',
|
|
'\u1EEA': 'U',
|
|
'\u1EE8': 'U',
|
|
'\u1EEE': 'U',
|
|
'\u1EEC': 'U',
|
|
'\u1EF0': 'U',
|
|
'\u1EE4': 'U',
|
|
'\u1E72': 'U',
|
|
'\u0172': 'U',
|
|
'\u1E76': 'U',
|
|
'\u1E74': 'U',
|
|
'\u0244': 'U',
|
|
'\u24CB': 'V',
|
|
'\uFF36': 'V',
|
|
'\u1E7C': 'V',
|
|
'\u1E7E': 'V',
|
|
'\u01B2': 'V',
|
|
'\uA75E': 'V',
|
|
'\u0245': 'V',
|
|
'\uA760': 'VY',
|
|
'\u24CC': 'W',
|
|
'\uFF37': 'W',
|
|
'\u1E80': 'W',
|
|
'\u1E82': 'W',
|
|
'\u0174': 'W',
|
|
'\u1E86': 'W',
|
|
'\u1E84': 'W',
|
|
'\u1E88': 'W',
|
|
'\u2C72': 'W',
|
|
'\u24CD': 'X',
|
|
'\uFF38': 'X',
|
|
'\u1E8A': 'X',
|
|
'\u1E8C': 'X',
|
|
'\u24CE': 'Y',
|
|
'\uFF39': 'Y',
|
|
'\u1EF2': 'Y',
|
|
'\u00DD': 'Y',
|
|
'\u0176': 'Y',
|
|
'\u1EF8': 'Y',
|
|
'\u0232': 'Y',
|
|
'\u1E8E': 'Y',
|
|
'\u0178': 'Y',
|
|
'\u1EF6': 'Y',
|
|
'\u1EF4': 'Y',
|
|
'\u01B3': 'Y',
|
|
'\u024E': 'Y',
|
|
'\u1EFE': 'Y',
|
|
'\u24CF': 'Z',
|
|
'\uFF3A': 'Z',
|
|
'\u0179': 'Z',
|
|
'\u1E90': 'Z',
|
|
'\u017B': 'Z',
|
|
'\u017D': 'Z',
|
|
'\u1E92': 'Z',
|
|
'\u1E94': 'Z',
|
|
'\u01B5': 'Z',
|
|
'\u0224': 'Z',
|
|
'\u2C7F': 'Z',
|
|
'\u2C6B': 'Z',
|
|
'\uA762': 'Z',
|
|
'\u24D0': 'a',
|
|
'\uFF41': 'a',
|
|
'\u1E9A': 'a',
|
|
'\u00E0': 'a',
|
|
'\u00E1': 'a',
|
|
'\u00E2': 'a',
|
|
'\u1EA7': 'a',
|
|
'\u1EA5': 'a',
|
|
'\u1EAB': 'a',
|
|
'\u1EA9': 'a',
|
|
'\u00E3': 'a',
|
|
'\u0101': 'a',
|
|
'\u0103': 'a',
|
|
'\u1EB1': 'a',
|
|
'\u1EAF': 'a',
|
|
'\u1EB5': 'a',
|
|
'\u1EB3': 'a',
|
|
'\u0227': 'a',
|
|
'\u01E1': 'a',
|
|
'\u00E4': 'a',
|
|
'\u01DF': 'a',
|
|
'\u1EA3': 'a',
|
|
'\u00E5': 'a',
|
|
'\u01FB': 'a',
|
|
'\u01CE': 'a',
|
|
'\u0201': 'a',
|
|
'\u0203': 'a',
|
|
'\u1EA1': 'a',
|
|
'\u1EAD': 'a',
|
|
'\u1EB7': 'a',
|
|
'\u1E01': 'a',
|
|
'\u0105': 'a',
|
|
'\u2C65': 'a',
|
|
'\u0250': 'a',
|
|
'\uA733': 'aa',
|
|
'\u00E6': 'ae',
|
|
'\u01FD': 'ae',
|
|
'\u01E3': 'ae',
|
|
'\uA735': 'ao',
|
|
'\uA737': 'au',
|
|
'\uA739': 'av',
|
|
'\uA73B': 'av',
|
|
'\uA73D': 'ay',
|
|
'\u24D1': 'b',
|
|
'\uFF42': 'b',
|
|
'\u1E03': 'b',
|
|
'\u1E05': 'b',
|
|
'\u1E07': 'b',
|
|
'\u0180': 'b',
|
|
'\u0183': 'b',
|
|
'\u0253': 'b',
|
|
'\u24D2': 'c',
|
|
'\uFF43': 'c',
|
|
'\u0107': 'c',
|
|
'\u0109': 'c',
|
|
'\u010B': 'c',
|
|
'\u010D': 'c',
|
|
'\u00E7': 'c',
|
|
'\u1E09': 'c',
|
|
'\u0188': 'c',
|
|
'\u023C': 'c',
|
|
'\uA73F': 'c',
|
|
'\u2184': 'c',
|
|
'\u24D3': 'd',
|
|
'\uFF44': 'd',
|
|
'\u1E0B': 'd',
|
|
'\u010F': 'd',
|
|
'\u1E0D': 'd',
|
|
'\u1E11': 'd',
|
|
'\u1E13': 'd',
|
|
'\u1E0F': 'd',
|
|
'\u0111': 'd',
|
|
'\u018C': 'd',
|
|
'\u0256': 'd',
|
|
'\u0257': 'd',
|
|
'\uA77A': 'd',
|
|
'\u01F3': 'dz',
|
|
'\u01C6': 'dz',
|
|
'\u24D4': 'e',
|
|
'\uFF45': 'e',
|
|
'\u00E8': 'e',
|
|
'\u00E9': 'e',
|
|
'\u00EA': 'e',
|
|
'\u1EC1': 'e',
|
|
'\u1EBF': 'e',
|
|
'\u1EC5': 'e',
|
|
'\u1EC3': 'e',
|
|
'\u1EBD': 'e',
|
|
'\u0113': 'e',
|
|
'\u1E15': 'e',
|
|
'\u1E17': 'e',
|
|
'\u0115': 'e',
|
|
'\u0117': 'e',
|
|
'\u00EB': 'e',
|
|
'\u1EBB': 'e',
|
|
'\u011B': 'e',
|
|
'\u0205': 'e',
|
|
'\u0207': 'e',
|
|
'\u1EB9': 'e',
|
|
'\u1EC7': 'e',
|
|
'\u0229': 'e',
|
|
'\u1E1D': 'e',
|
|
'\u0119': 'e',
|
|
'\u1E19': 'e',
|
|
'\u1E1B': 'e',
|
|
'\u0247': 'e',
|
|
'\u025B': 'e',
|
|
'\u01DD': 'e',
|
|
'\u24D5': 'f',
|
|
'\uFF46': 'f',
|
|
'\u1E1F': 'f',
|
|
'\u0192': 'f',
|
|
'\uA77C': 'f',
|
|
'\u24D6': 'g',
|
|
'\uFF47': 'g',
|
|
'\u01F5': 'g',
|
|
'\u011D': 'g',
|
|
'\u1E21': 'g',
|
|
'\u011F': 'g',
|
|
'\u0121': 'g',
|
|
'\u01E7': 'g',
|
|
'\u0123': 'g',
|
|
'\u01E5': 'g',
|
|
'\u0260': 'g',
|
|
'\uA7A1': 'g',
|
|
'\u1D79': 'g',
|
|
'\uA77F': 'g',
|
|
'\u24D7': 'h',
|
|
'\uFF48': 'h',
|
|
'\u0125': 'h',
|
|
'\u1E23': 'h',
|
|
'\u1E27': 'h',
|
|
'\u021F': 'h',
|
|
'\u1E25': 'h',
|
|
'\u1E29': 'h',
|
|
'\u1E2B': 'h',
|
|
'\u1E96': 'h',
|
|
'\u0127': 'h',
|
|
'\u2C68': 'h',
|
|
'\u2C76': 'h',
|
|
'\u0265': 'h',
|
|
'\u0195': 'hv',
|
|
'\u24D8': 'i',
|
|
'\uFF49': 'i',
|
|
'\u00EC': 'i',
|
|
'\u00ED': 'i',
|
|
'\u00EE': 'i',
|
|
'\u0129': 'i',
|
|
'\u012B': 'i',
|
|
'\u012D': 'i',
|
|
'\u00EF': 'i',
|
|
'\u1E2F': 'i',
|
|
'\u1EC9': 'i',
|
|
'\u01D0': 'i',
|
|
'\u0209': 'i',
|
|
'\u020B': 'i',
|
|
'\u1ECB': 'i',
|
|
'\u012F': 'i',
|
|
'\u1E2D': 'i',
|
|
'\u0268': 'i',
|
|
'\u0131': 'i',
|
|
'\u24D9': 'j',
|
|
'\uFF4A': 'j',
|
|
'\u0135': 'j',
|
|
'\u01F0': 'j',
|
|
'\u0249': 'j',
|
|
'\u24DA': 'k',
|
|
'\uFF4B': 'k',
|
|
'\u1E31': 'k',
|
|
'\u01E9': 'k',
|
|
'\u1E33': 'k',
|
|
'\u0137': 'k',
|
|
'\u1E35': 'k',
|
|
'\u0199': 'k',
|
|
'\u2C6A': 'k',
|
|
'\uA741': 'k',
|
|
'\uA743': 'k',
|
|
'\uA745': 'k',
|
|
'\uA7A3': 'k',
|
|
'\u24DB': 'l',
|
|
'\uFF4C': 'l',
|
|
'\u0140': 'l',
|
|
'\u013A': 'l',
|
|
'\u013E': 'l',
|
|
'\u1E37': 'l',
|
|
'\u1E39': 'l',
|
|
'\u013C': 'l',
|
|
'\u1E3D': 'l',
|
|
'\u1E3B': 'l',
|
|
'\u017F': 'l',
|
|
'\u0142': 'l',
|
|
'\u019A': 'l',
|
|
'\u026B': 'l',
|
|
'\u2C61': 'l',
|
|
'\uA749': 'l',
|
|
'\uA781': 'l',
|
|
'\uA747': 'l',
|
|
'\u01C9': 'lj',
|
|
'\u24DC': 'm',
|
|
'\uFF4D': 'm',
|
|
'\u1E3F': 'm',
|
|
'\u1E41': 'm',
|
|
'\u1E43': 'm',
|
|
'\u0271': 'm',
|
|
'\u026F': 'm',
|
|
'\u24DD': 'n',
|
|
'\uFF4E': 'n',
|
|
'\u01F9': 'n',
|
|
'\u0144': 'n',
|
|
'\u00F1': 'n',
|
|
'\u1E45': 'n',
|
|
'\u0148': 'n',
|
|
'\u1E47': 'n',
|
|
'\u0146': 'n',
|
|
'\u1E4B': 'n',
|
|
'\u1E49': 'n',
|
|
'\u019E': 'n',
|
|
'\u0272': 'n',
|
|
'\u0149': 'n',
|
|
'\uA791': 'n',
|
|
'\uA7A5': 'n',
|
|
'\u01CC': 'nj',
|
|
'\u24DE': 'o',
|
|
'\uFF4F': 'o',
|
|
'\u00F2': 'o',
|
|
'\u00F3': 'o',
|
|
'\u00F4': 'o',
|
|
'\u1ED3': 'o',
|
|
'\u1ED1': 'o',
|
|
'\u1ED7': 'o',
|
|
'\u1ED5': 'o',
|
|
'\u00F5': 'o',
|
|
'\u1E4D': 'o',
|
|
'\u022D': 'o',
|
|
'\u1E4F': 'o',
|
|
'\u014D': 'o',
|
|
'\u1E51': 'o',
|
|
'\u1E53': 'o',
|
|
'\u014F': 'o',
|
|
'\u022F': 'o',
|
|
'\u0231': 'o',
|
|
'\u00F6': 'o',
|
|
'\u022B': 'o',
|
|
'\u1ECF': 'o',
|
|
'\u0151': 'o',
|
|
'\u01D2': 'o',
|
|
'\u020D': 'o',
|
|
'\u020F': 'o',
|
|
'\u01A1': 'o',
|
|
'\u1EDD': 'o',
|
|
'\u1EDB': 'o',
|
|
'\u1EE1': 'o',
|
|
'\u1EDF': 'o',
|
|
'\u1EE3': 'o',
|
|
'\u1ECD': 'o',
|
|
'\u1ED9': 'o',
|
|
'\u01EB': 'o',
|
|
'\u01ED': 'o',
|
|
'\u00F8': 'o',
|
|
'\u01FF': 'o',
|
|
'\u0254': 'o',
|
|
'\uA74B': 'o',
|
|
'\uA74D': 'o',
|
|
'\u0275': 'o',
|
|
'\u01A3': 'oi',
|
|
'\u0223': 'ou',
|
|
'\uA74F': 'oo',
|
|
'\u24DF': 'p',
|
|
'\uFF50': 'p',
|
|
'\u1E55': 'p',
|
|
'\u1E57': 'p',
|
|
'\u01A5': 'p',
|
|
'\u1D7D': 'p',
|
|
'\uA751': 'p',
|
|
'\uA753': 'p',
|
|
'\uA755': 'p',
|
|
'\u24E0': 'q',
|
|
'\uFF51': 'q',
|
|
'\u024B': 'q',
|
|
'\uA757': 'q',
|
|
'\uA759': 'q',
|
|
'\u24E1': 'r',
|
|
'\uFF52': 'r',
|
|
'\u0155': 'r',
|
|
'\u1E59': 'r',
|
|
'\u0159': 'r',
|
|
'\u0211': 'r',
|
|
'\u0213': 'r',
|
|
'\u1E5B': 'r',
|
|
'\u1E5D': 'r',
|
|
'\u0157': 'r',
|
|
'\u1E5F': 'r',
|
|
'\u024D': 'r',
|
|
'\u027D': 'r',
|
|
'\uA75B': 'r',
|
|
'\uA7A7': 'r',
|
|
'\uA783': 'r',
|
|
'\u24E2': 's',
|
|
'\uFF53': 's',
|
|
'\u00DF': 's',
|
|
'\u015B': 's',
|
|
'\u1E65': 's',
|
|
'\u015D': 's',
|
|
'\u1E61': 's',
|
|
'\u0161': 's',
|
|
'\u1E67': 's',
|
|
'\u1E63': 's',
|
|
'\u1E69': 's',
|
|
'\u0219': 's',
|
|
'\u015F': 's',
|
|
'\u023F': 's',
|
|
'\uA7A9': 's',
|
|
'\uA785': 's',
|
|
'\u1E9B': 's',
|
|
'\u24E3': 't',
|
|
'\uFF54': 't',
|
|
'\u1E6B': 't',
|
|
'\u1E97': 't',
|
|
'\u0165': 't',
|
|
'\u1E6D': 't',
|
|
'\u021B': 't',
|
|
'\u0163': 't',
|
|
'\u1E71': 't',
|
|
'\u1E6F': 't',
|
|
'\u0167': 't',
|
|
'\u01AD': 't',
|
|
'\u0288': 't',
|
|
'\u2C66': 't',
|
|
'\uA787': 't',
|
|
'\uA729': 'tz',
|
|
'\u24E4': 'u',
|
|
'\uFF55': 'u',
|
|
'\u00F9': 'u',
|
|
'\u00FA': 'u',
|
|
'\u00FB': 'u',
|
|
'\u0169': 'u',
|
|
'\u1E79': 'u',
|
|
'\u016B': 'u',
|
|
'\u1E7B': 'u',
|
|
'\u016D': 'u',
|
|
'\u00FC': 'u',
|
|
'\u01DC': 'u',
|
|
'\u01D8': 'u',
|
|
'\u01D6': 'u',
|
|
'\u01DA': 'u',
|
|
'\u1EE7': 'u',
|
|
'\u016F': 'u',
|
|
'\u0171': 'u',
|
|
'\u01D4': 'u',
|
|
'\u0215': 'u',
|
|
'\u0217': 'u',
|
|
'\u01B0': 'u',
|
|
'\u1EEB': 'u',
|
|
'\u1EE9': 'u',
|
|
'\u1EEF': 'u',
|
|
'\u1EED': 'u',
|
|
'\u1EF1': 'u',
|
|
'\u1EE5': 'u',
|
|
'\u1E73': 'u',
|
|
'\u0173': 'u',
|
|
'\u1E77': 'u',
|
|
'\u1E75': 'u',
|
|
'\u0289': 'u',
|
|
'\u24E5': 'v',
|
|
'\uFF56': 'v',
|
|
'\u1E7D': 'v',
|
|
'\u1E7F': 'v',
|
|
'\u028B': 'v',
|
|
'\uA75F': 'v',
|
|
'\u028C': 'v',
|
|
'\uA761': 'vy',
|
|
'\u24E6': 'w',
|
|
'\uFF57': 'w',
|
|
'\u1E81': 'w',
|
|
'\u1E83': 'w',
|
|
'\u0175': 'w',
|
|
'\u1E87': 'w',
|
|
'\u1E85': 'w',
|
|
'\u1E98': 'w',
|
|
'\u1E89': 'w',
|
|
'\u2C73': 'w',
|
|
'\u24E7': 'x',
|
|
'\uFF58': 'x',
|
|
'\u1E8B': 'x',
|
|
'\u1E8D': 'x',
|
|
'\u24E8': 'y',
|
|
'\uFF59': 'y',
|
|
'\u1EF3': 'y',
|
|
'\u00FD': 'y',
|
|
'\u0177': 'y',
|
|
'\u1EF9': 'y',
|
|
'\u0233': 'y',
|
|
'\u1E8F': 'y',
|
|
'\u00FF': 'y',
|
|
'\u1EF7': 'y',
|
|
'\u1E99': 'y',
|
|
'\u1EF5': 'y',
|
|
'\u01B4': 'y',
|
|
'\u024F': 'y',
|
|
'\u1EFF': 'y',
|
|
'\u24E9': 'z',
|
|
'\uFF5A': 'z',
|
|
'\u017A': 'z',
|
|
'\u1E91': 'z',
|
|
'\u017C': 'z',
|
|
'\u017E': 'z',
|
|
'\u1E93': 'z',
|
|
'\u1E95': 'z',
|
|
'\u01B6': 'z',
|
|
'\u0225': 'z',
|
|
'\u0240': 'z',
|
|
'\u2C6C': 'z',
|
|
'\uA763': 'z',
|
|
'\u0386': '\u0391',
|
|
'\u0388': '\u0395',
|
|
'\u0389': '\u0397',
|
|
'\u038A': '\u0399',
|
|
'\u03AA': '\u0399',
|
|
'\u038C': '\u039F',
|
|
'\u038E': '\u03A5',
|
|
'\u03AB': '\u03A5',
|
|
'\u038F': '\u03A9',
|
|
'\u03AC': '\u03B1',
|
|
'\u03AD': '\u03B5',
|
|
'\u03AE': '\u03B7',
|
|
'\u03AF': '\u03B9',
|
|
'\u03CA': '\u03B9',
|
|
'\u0390': '\u03B9',
|
|
'\u03CC': '\u03BF',
|
|
'\u03CD': '\u03C5',
|
|
'\u03CB': '\u03C5',
|
|
'\u03B0': '\u03C5',
|
|
'\u03C9': '\u03C9',
|
|
'\u03C2': '\u03C3'
|
|
};
|
|
|
|
return diacritics;
|
|
});
|
|
|
|
define('select2/data/base',[
|
|
'../utils'
|
|
], function (Utils) {
|
|
function BaseAdapter ($element, options) {
|
|
BaseAdapter.__super__.constructor.call(this);
|
|
}
|
|
|
|
Utils.Extend(BaseAdapter, Utils.Observable);
|
|
|
|
BaseAdapter.prototype.current = function (callback) {
|
|
throw new Error('The `current` method must be defined in child classes.');
|
|
};
|
|
|
|
BaseAdapter.prototype.query = function (params, callback) {
|
|
throw new Error('The `query` method must be defined in child classes.');
|
|
};
|
|
|
|
BaseAdapter.prototype.bind = function (container, $container) {
|
|
// Can be implemented in subclasses
|
|
};
|
|
|
|
BaseAdapter.prototype.destroy = function () {
|
|
// Can be implemented in subclasses
|
|
};
|
|
|
|
BaseAdapter.prototype.generateResultId = function (container, data) {
|
|
var id = container.id + '-result-';
|
|
|
|
id += Utils.generateChars(4);
|
|
|
|
if (data.id != null) {
|
|
id += '-' + data.id.toString();
|
|
} else {
|
|
id += '-' + Utils.generateChars(4);
|
|
}
|
|
return id;
|
|
};
|
|
|
|
return BaseAdapter;
|
|
});
|
|
|
|
define('select2/data/select',[
|
|
'./base',
|
|
'../utils',
|
|
'jquery'
|
|
], function (BaseAdapter, Utils, $) {
|
|
function SelectAdapter ($element, options) {
|
|
this.$element = $element;
|
|
this.options = options;
|
|
|
|
SelectAdapter.__super__.constructor.call(this);
|
|
}
|
|
|
|
Utils.Extend(SelectAdapter, BaseAdapter);
|
|
|
|
SelectAdapter.prototype.current = function (callback) {
|
|
var data = [];
|
|
var self = this;
|
|
|
|
this.$element.find(':selected').each(function () {
|
|
var $option = $(this);
|
|
|
|
var option = self.item($option);
|
|
|
|
data.push(option);
|
|
});
|
|
|
|
callback(data);
|
|
};
|
|
|
|
SelectAdapter.prototype.select = function (data) {
|
|
var self = this;
|
|
|
|
// If data.element is a DOM nose, use it instead
|
|
if ($(data.element).is('option')) {
|
|
data.element.selected = true;
|
|
|
|
this.$element.trigger('change');
|
|
|
|
return;
|
|
}
|
|
|
|
if (this.$element.prop('multiple')) {
|
|
this.current(function (currentData) {
|
|
var val = [];
|
|
|
|
data = [data];
|
|
data.push.apply(data, currentData);
|
|
|
|
for (var d = 0; d < data.length; d++) {
|
|
id = data[d].id;
|
|
|
|
if (val.indexOf(id) === -1) {
|
|
val.push(id);
|
|
}
|
|
}
|
|
|
|
self.$element.val(val);
|
|
self.$element.trigger('change');
|
|
});
|
|
} else {
|
|
var val = data.id;
|
|
|
|
this.$element.val(val);
|
|
|
|
this.$element.trigger('change');
|
|
}
|
|
};
|
|
|
|
SelectAdapter.prototype.unselect = function (data) {
|
|
var self = this;
|
|
|
|
if (!this.$element.prop('multiple')) {
|
|
return;
|
|
}
|
|
|
|
if ($(data.element).is('option')) {
|
|
data.element.selected = false;
|
|
|
|
this.$element.trigger('change');
|
|
|
|
return;
|
|
}
|
|
|
|
this.current(function (currentData) {
|
|
var val = [];
|
|
|
|
for (var d = 0; d < currentData.length; d++) {
|
|
id = currentData[d].id;
|
|
|
|
if (id !== data.id && val.indexOf(id) === -1) {
|
|
val.push(id);
|
|
}
|
|
}
|
|
|
|
self.$element.val(val);
|
|
|
|
self.$element.trigger('change');
|
|
});
|
|
};
|
|
|
|
SelectAdapter.prototype.bind = function (container, $container) {
|
|
var self = this;
|
|
|
|
this.container = container;
|
|
|
|
container.on('select', function (params) {
|
|
self.select(params.data);
|
|
});
|
|
|
|
container.on('unselect', function (params) {
|
|
self.unselect(params.data);
|
|
});
|
|
};
|
|
|
|
SelectAdapter.prototype.destroy = function () {
|
|
// Remove anything added to child elements
|
|
this.$element.find('*').each(function () {
|
|
// Remove any custom data set by Select2
|
|
$.removeData(this, 'data');
|
|
});
|
|
};
|
|
|
|
SelectAdapter.prototype.query = function (params, callback) {
|
|
var data = [];
|
|
var self = this;
|
|
|
|
var $options = this.$element.children();
|
|
|
|
$options.each(function () {
|
|
var $option = $(this);
|
|
|
|
if (!$option.is('option') && !$option.is('optgroup')) {
|
|
return;
|
|
}
|
|
|
|
var option = self.item($option);
|
|
|
|
var matches = self.matches(params, option);
|
|
|
|
if (matches !== null) {
|
|
data.push(matches);
|
|
}
|
|
});
|
|
|
|
callback({
|
|
results: data
|
|
});
|
|
};
|
|
|
|
SelectAdapter.prototype.option = function (data) {
|
|
var option = document.createElement('option');
|
|
|
|
option.value = data.id;
|
|
|
|
if (data.disabled) {
|
|
option.disabled = true;
|
|
}
|
|
|
|
if (data.selected) {
|
|
option.selected = true;
|
|
}
|
|
|
|
option.innerText = data.text;
|
|
|
|
var $option = $(option);
|
|
|
|
var normalizedData = this._normalizeItem(data);
|
|
normalizedData.element = option;
|
|
|
|
// Override the option's data with the combined data
|
|
$.data(option, 'data', normalizedData);
|
|
|
|
return $option;
|
|
};
|
|
|
|
SelectAdapter.prototype.item = function ($option) {
|
|
var data = {};
|
|
|
|
data = $.data($option[0], 'data');
|
|
|
|
if (data != null) {
|
|
return data;
|
|
}
|
|
|
|
if ($option.is('option')) {
|
|
data = {
|
|
id: $option.val(),
|
|
text: $option.html(),
|
|
disabled: $option.prop('disabled'),
|
|
selected: $option.prop('selected')
|
|
};
|
|
} else if ($option.is('optgroup')) {
|
|
data = {
|
|
text: $option.attr('label'),
|
|
children: []
|
|
};
|
|
|
|
var $children = $option.children('option');
|
|
var children = [];
|
|
|
|
for (var c = 0; c < $children.length; c++) {
|
|
var $child = $($children[c]);
|
|
|
|
var child = this.item($child);
|
|
|
|
children.push(child);
|
|
}
|
|
|
|
data.children = children;
|
|
}
|
|
|
|
data = this._normalizeItem(data);
|
|
data.element = $option[0];
|
|
|
|
$.data($option[0], 'data', data);
|
|
|
|
return data;
|
|
};
|
|
|
|
SelectAdapter.prototype._normalizeItem = function (item) {
|
|
if (!$.isPlainObject(item)) {
|
|
item = {
|
|
id: item,
|
|
text: item
|
|
};
|
|
}
|
|
|
|
item = $.extend({}, {
|
|
text: ''
|
|
}, item);
|
|
|
|
var defaults = {
|
|
selected: false,
|
|
disabled: false
|
|
};
|
|
|
|
if (item.id != null) {
|
|
item.id = item.id.toString();
|
|
}
|
|
|
|
if (item.text != null) {
|
|
item.text = item.text.toString();
|
|
}
|
|
|
|
if (item._resultId == null && item.id && this.container != null) {
|
|
item._resultId = this.generateResultId(this.container, item);
|
|
}
|
|
|
|
return $.extend({}, defaults, item);
|
|
};
|
|
|
|
SelectAdapter.prototype.matches = function (params, data) {
|
|
var matcher = this.options.get('matcher');
|
|
|
|
return matcher(params, data);
|
|
};
|
|
|
|
return SelectAdapter;
|
|
});
|
|
|
|
define('select2/data/array',[
|
|
'./select',
|
|
'../utils',
|
|
'jquery'
|
|
], function (SelectAdapter, Utils, $) {
|
|
function ArrayAdapter ($element, options) {
|
|
var data = options.get('data');
|
|
|
|
ArrayAdapter.__super__.constructor.call(this, $element, options);
|
|
|
|
this.convertToOptions(data);
|
|
}
|
|
|
|
Utils.Extend(ArrayAdapter, SelectAdapter);
|
|
|
|
ArrayAdapter.prototype.select = function (data) {
|
|
var $option = this.$element.find('option[value="' + data.id + '"]');
|
|
|
|
if ($option.length === 0) {
|
|
$option = this.option(data);
|
|
|
|
this.$element.append($option);
|
|
}
|
|
|
|
ArrayAdapter.__super__.select.call(this, data);
|
|
};
|
|
|
|
ArrayAdapter.prototype.convertToOptions = function (data) {
|
|
var self = this;
|
|
|
|
var $existing = this.$element.find('option');
|
|
var existingIds = $existing.map(function () {
|
|
return self.item($(this)).id;
|
|
}).get();
|
|
|
|
// Filter out all items except for the one passed in the argument
|
|
function onlyItem (item) {
|
|
return function () {
|
|
return $(this).val() == item.id;
|
|
};
|
|
}
|
|
|
|
for (var d = 0; d < data.length; d++) {
|
|
var item = data[d];
|
|
item.id = item.id.toString();
|
|
|
|
// Skip items which were pre-loaded, only merge the data
|
|
if (existingIds.indexOf(item.id) >= 0) {
|
|
var $existingOption = $existing.filter(onlyItem(item));
|
|
|
|
var existingData = this.item($existingOption);
|
|
var newData = $.extend(true, {}, existingData, item);
|
|
|
|
var $newOption = this.option(existingData);
|
|
|
|
$existingOption.replaceWith($newOption);
|
|
|
|
continue;
|
|
}
|
|
|
|
var $option = this.option(item);
|
|
|
|
this.$element.append($option);
|
|
}
|
|
};
|
|
|
|
return ArrayAdapter;
|
|
});
|
|
|
|
define('select2/data/ajax',[
|
|
'./array',
|
|
'../utils',
|
|
'jquery'
|
|
], function (ArrayAdapter, Utils, $) {
|
|
function AjaxAdapter ($element, options) {
|
|
this.ajaxOptions = options.get('ajax');
|
|
|
|
if (this.ajaxOptions.processResults != null) {
|
|
this.processResults = this.ajaxOptions.processResults;
|
|
}
|
|
|
|
ArrayAdapter.__super__.constructor.call(this, $element, options);
|
|
}
|
|
|
|
Utils.Extend(AjaxAdapter, ArrayAdapter);
|
|
|
|
AjaxAdapter.prototype.processResults = function (results) {
|
|
return results;
|
|
};
|
|
|
|
AjaxAdapter.prototype.query = function (params, callback) {
|
|
var matches = [];
|
|
var self = this;
|
|
|
|
if (this._request) {
|
|
this._request.abort();
|
|
this._request = null;
|
|
}
|
|
|
|
var options = $.extend({
|
|
type: 'GET'
|
|
}, this.ajaxOptions);
|
|
|
|
if (typeof options.url === 'function') {
|
|
options.url = options.url(params);
|
|
}
|
|
|
|
if (typeof options.data === 'function') {
|
|
options.data = options.data(params);
|
|
}
|
|
|
|
function request () {
|
|
var $request = $.ajax(options);
|
|
|
|
$request.success(function (data) {
|
|
var results = self.processResults(data, params);
|
|
|
|
callback(results);
|
|
});
|
|
|
|
self._request = $request;
|
|
}
|
|
|
|
if (this.ajaxOptions.delay && params.term !== '') {
|
|
if (this._queryTimeout) {
|
|
window.clearTimeout(this._queryTimeout);
|
|
}
|
|
|
|
this._queryTimeout = window.setTimeout(request, this.ajaxOptions.delay);
|
|
} else {
|
|
request();
|
|
}
|
|
};
|
|
|
|
return AjaxAdapter;
|
|
});
|
|
|
|
define('select2/data/tags',[
|
|
|
|
], function () {
|
|
function Tags (decorated, $element, options) {
|
|
var tags = options.get('tags');
|
|
|
|
decorated.call(this, $element, options);
|
|
|
|
if ($.isArray(tags)) {
|
|
for (var t = 0; t < tags.length; t++) {
|
|
var tag = tags[t];
|
|
var item = this._normalizeItem(tag);
|
|
|
|
var $option = this.option(item);
|
|
|
|
this.$element.append($option);
|
|
}
|
|
}
|
|
}
|
|
|
|
Tags.prototype.query = function (decorated, params, callback) {
|
|
var self = this;
|
|
|
|
this._removeOldTags();
|
|
|
|
if (params.term == null || params.term === '' || params.page != null) {
|
|
decorated.call(this, params, callback);
|
|
return;
|
|
}
|
|
|
|
function wrapper (obj, child) {
|
|
var data = obj.results;
|
|
|
|
for (var i = 0; i < data.length; i++) {
|
|
var option = data[i];
|
|
|
|
var checkChildren = (
|
|
option.children != null &&
|
|
!wrapper({
|
|
results: option.children
|
|
}, true)
|
|
);
|
|
|
|
var checkText = option.text === params.term;
|
|
|
|
if (checkText || checkChildren) {
|
|
if (child) {
|
|
return false;
|
|
}
|
|
|
|
obj.data = data;
|
|
callback(obj);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (child) {
|
|
return true;
|
|
}
|
|
|
|
var tag = self.createTag(params);
|
|
|
|
if (tag != null) {
|
|
var $option = self.option(tag);
|
|
$option.attr('data-select2-tag', true);
|
|
|
|
self.$element.append($option);
|
|
|
|
self.insertTag(data, tag);
|
|
}
|
|
|
|
obj.results = data;
|
|
|
|
callback(obj);
|
|
}
|
|
|
|
decorated.call(this, params, wrapper);
|
|
};
|
|
|
|
Tags.prototype.createTag = function (decorated, params) {
|
|
return {
|
|
id: params.term,
|
|
text: params.term
|
|
};
|
|
};
|
|
|
|
Tags.prototype.insertTag = function (_, data, tag) {
|
|
data.unshift(tag);
|
|
};
|
|
|
|
Tags.prototype._removeOldTags = function (_) {
|
|
var tag = this._lastTag;
|
|
|
|
var $options = this.$element.find('option[data-select2-tag]');
|
|
|
|
$options.each(function () {
|
|
if (this.selected) {
|
|
return;
|
|
}
|
|
|
|
$(this).remove();
|
|
});
|
|
};
|
|
|
|
return Tags;
|
|
});
|
|
|
|
define('select2/data/tokenizer',[
|
|
|
|
], function () {
|
|
function Tokenizer (decorated, $element, options) {
|
|
var tokenizer = options.get('tokenizer');
|
|
|
|
if (tokenizer !== undefined) {
|
|
this.tokenizer = tokenizer;
|
|
}
|
|
|
|
decorated.call(this, $element, options);
|
|
}
|
|
|
|
Tokenizer.prototype.bind = function (decorated, container, $container) {
|
|
decorated.call(this, container, $container);
|
|
|
|
this.$search = container.dropdown.$search || container.selection.$search ||
|
|
$container.find('.select2-search__field');
|
|
};
|
|
|
|
Tokenizer.prototype.query = function (decorated, params, callback) {
|
|
var self = this;
|
|
|
|
function select (data) {
|
|
self.select(data);
|
|
}
|
|
|
|
params.term = params.term || '';
|
|
|
|
var tokenData = this.tokenizer(params, this.options, select);
|
|
|
|
if (tokenData.term !== params.term) {
|
|
// Replace the search term if we have the search box
|
|
if (this.$search.length) {
|
|
this.$search.val(tokenData.term);
|
|
this.$search.focus();
|
|
}
|
|
|
|
params.term = tokenData.term;
|
|
}
|
|
|
|
decorated.call(this, params, callback);
|
|
};
|
|
|
|
Tokenizer.prototype.tokenizer = function (_, params, options, callback) {
|
|
var separators = options.get('tokenSeparators') || [];
|
|
var term = params.term;
|
|
var i = 0;
|
|
|
|
var createTag = this.createTag || function (params) {
|
|
return {
|
|
id: params.term,
|
|
text: params.term
|
|
};
|
|
};
|
|
|
|
while (i < term.length) {
|
|
var termChar = term[i];
|
|
|
|
if (separators.indexOf(termChar) === -1) {
|
|
i++;
|
|
|
|
continue;
|
|
}
|
|
|
|
var part = term.substr(0, i);
|
|
var partParams = $.extend({}, params, {
|
|
term: part
|
|
});
|
|
|
|
var data = createTag(partParams);
|
|
|
|
callback(data);
|
|
|
|
// Reset the term to not include the tokenized portion
|
|
term = term.substr(i + 1) || '';
|
|
i = 0;
|
|
}
|
|
|
|
return {
|
|
term: term
|
|
};
|
|
};
|
|
|
|
return Tokenizer;
|
|
});
|
|
|
|
define('select2/data/minimumInputLength',[
|
|
|
|
], function () {
|
|
function MinimumInputLength (decorated, $e, options) {
|
|
this.minimumInputLength = options.get('minimumInputLength');
|
|
|
|
decorated.call(this, $e, options);
|
|
}
|
|
|
|
MinimumInputLength.prototype.query = function (decorated, params, callback) {
|
|
params.term = params.term || '';
|
|
|
|
if (params.term.length < this.minimumInputLength) {
|
|
this.trigger('results:message', {
|
|
message: 'inputTooShort',
|
|
args: {
|
|
minimum: this.minimumInputLength,
|
|
input: params.term,
|
|
params: params
|
|
}
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
decorated.call(this, params, callback);
|
|
};
|
|
|
|
return MinimumInputLength;
|
|
});
|
|
|
|
define('select2/data/maximumInputLength',[
|
|
|
|
], function () {
|
|
function MaximumInputLength (decorated, $e, options) {
|
|
this.maximumInputLength = options.get('maximumInputLength');
|
|
|
|
decorated.call(this, $e, options);
|
|
}
|
|
|
|
MaximumInputLength.prototype.query = function (decorated, params, callback) {
|
|
params.term = params.term || '';
|
|
|
|
if (this.maximumInputLength > 0 &&
|
|
params.term.length > this.maximumInputLength) {
|
|
this.trigger('results:message', {
|
|
message: 'inputTooLong',
|
|
args: {
|
|
minimum: this.maximumInputLength,
|
|
input: params.term,
|
|
params: params
|
|
}
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
decorated.call(this, params, callback);
|
|
};
|
|
|
|
return MaximumInputLength;
|
|
});
|
|
|
|
define('select2/dropdown',[
|
|
'./utils'
|
|
], function (Utils) {
|
|
function Dropdown ($element, options) {
|
|
this.$element = $element;
|
|
this.options = options;
|
|
|
|
Dropdown.__super__.constructor.call(this);
|
|
}
|
|
|
|
Utils.Extend(Dropdown, Utils.Observable);
|
|
|
|
Dropdown.prototype.render = function () {
|
|
var $dropdown = $(
|
|
'<span class="select2-dropdown">' +
|
|
'<span class="select2-results"></span>' +
|
|
'</span>'
|
|
);
|
|
|
|
$dropdown.attr('dir', this.options.get('dir'));
|
|
|
|
this.$dropdown = $dropdown;
|
|
|
|
return $dropdown;
|
|
};
|
|
|
|
Dropdown.prototype.position = function ($dropdown, $container) {
|
|
// Should be implmented in subclasses
|
|
};
|
|
|
|
Dropdown.prototype.destroy = function () {
|
|
// Remove the dropdown from the DOM
|
|
this.$dropdown.remove();
|
|
};
|
|
|
|
Dropdown.prototype.bind = function (container, $container) {
|
|
// Can be implemented in subclasses
|
|
};
|
|
|
|
return Dropdown;
|
|
});
|
|
|
|
define('select2/dropdown/search',[
|
|
'../utils'
|
|
], function (Utils) {
|
|
function Search () { }
|
|
|
|
Search.prototype.render = function (decorated) {
|
|
var $rendered = decorated.call(this);
|
|
|
|
var $search = $(
|
|
'<span class="select2-search select2-search--dropdown">' +
|
|
'<input class="select2-search__field" type="search" tabindex="-1"' +
|
|
' role="textbox" />' +
|
|
'</span>'
|
|
);
|
|
|
|
this.$searchContainer = $search;
|
|
this.$search = $search.find('input');
|
|
|
|
$rendered.prepend($search);
|
|
|
|
return $rendered;
|
|
};
|
|
|
|
Search.prototype.bind = function (decorated, container, $container) {
|
|
var self = this;
|
|
|
|
decorated.call(this, container, $container);
|
|
|
|
this.$search.on('keydown', function (evt) {
|
|
self.trigger('keypress', evt);
|
|
|
|
self._keyUpPrevented = evt.isDefaultPrevented();
|
|
});
|
|
|
|
this.$search.on('keyup', function (evt) {
|
|
self.handleSearch(evt);
|
|
});
|
|
|
|
container.on('open', function () {
|
|
self.$search.attr('tabindex', 0);
|
|
|
|
self.$search.focus();
|
|
|
|
window.setTimeout(function () {
|
|
self.$search.focus();
|
|
}, 0);
|
|
});
|
|
|
|
container.on('close', function () {
|
|
self.$search.attr('tabindex', -1);
|
|
|
|
self.$search.val('');
|
|
});
|
|
|
|
container.on('results:all', function (params) {
|
|
if (params.query.term == null || params.query.term === '') {
|
|
var showSearch = self.showSearch(params);
|
|
|
|
if (showSearch) {
|
|
self.$searchContainer.removeClass('select2-search--hide');
|
|
} else {
|
|
self.$searchContainer.addClass('select2-search--hide');
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
Search.prototype.handleSearch = function (evt) {
|
|
if (!this._keyUpPrevented) {
|
|
var input = this.$search.val();
|
|
|
|
this.trigger('query', {
|
|
term: input
|
|
});
|
|
}
|
|
|
|
this._keyUpPrevented = false;
|
|
};
|
|
|
|
Search.prototype.showSearch = function (_, params) {
|
|
return true;
|
|
};
|
|
|
|
return Search;
|
|
});
|
|
|
|
define('select2/dropdown/hidePlaceholder',[
|
|
|
|
], function () {
|
|
function HidePlaceholder (decorated, $element, options, dataAdapter) {
|
|
this.placeholder = this.normalizePlaceholder(options.get('placeholder'));
|
|
|
|
decorated.call(this, $element, options, dataAdapter);
|
|
}
|
|
|
|
HidePlaceholder.prototype.append = function (decorated, data) {
|
|
data.results = this.removePlaceholder(data.results);
|
|
|
|
decorated.call(this, data);
|
|
};
|
|
|
|
HidePlaceholder.prototype.normalizePlaceholder = function (_, placeholder) {
|
|
if (typeof placeholder === 'string') {
|
|
placeholder = {
|
|
id: '',
|
|
text: placeholder
|
|
};
|
|
}
|
|
|
|
return placeholder;
|
|
};
|
|
|
|
HidePlaceholder.prototype.removePlaceholder = function (_, data) {
|
|
var modifiedData = data.slice(0);
|
|
|
|
for (var d = data.length - 1; d >= 0; d--) {
|
|
var item = data[d];
|
|
|
|
if (this.placeholder.id === item.id) {
|
|
modifiedData.splice(d, 1);
|
|
}
|
|
}
|
|
|
|
return modifiedData;
|
|
};
|
|
|
|
return HidePlaceholder;
|
|
});
|
|
|
|
define('select2/dropdown/infiniteScroll',[
|
|
'jquery'
|
|
], function ($) {
|
|
function InfiniteScroll (decorated, $element, options, dataAdapter) {
|
|
this.lastParams = {};
|
|
|
|
decorated.call(this, $element, options, dataAdapter);
|
|
|
|
this.$loadingMore = this.createLoadingMore();
|
|
this.loading = false;
|
|
}
|
|
|
|
InfiniteScroll.prototype.append = function (decorated, data) {
|
|
this.$loadingMore.remove();
|
|
this.loading = false;
|
|
|
|
decorated.call(this, data);
|
|
|
|
if (this.showLoadingMore(data)) {
|
|
this.$results.append(this.$loadingMore);
|
|
}
|
|
};
|
|
|
|
InfiniteScroll.prototype.bind = function (decorated, container, $container) {
|
|
var self = this;
|
|
|
|
decorated.call(this, container, $container);
|
|
|
|
container.on('query', function (params) {
|
|
self.lastParams = params;
|
|
self.loading = true;
|
|
});
|
|
|
|
container.on('query:append', function (params) {
|
|
self.lastParams = params;
|
|
self.loading = true;
|
|
});
|
|
|
|
this.$results.on('scroll', function () {
|
|
var isLoadMoreVisible = $.contains(
|
|
document.documentElement,
|
|
self.$loadingMore[0]
|
|
);
|
|
|
|
if (self.loading || !isLoadMoreVisible) {
|
|
return;
|
|
}
|
|
|
|
var currentOffset = self.$results.offset().top +
|
|
self.$results.outerHeight(false);
|
|
var loadingMoreOffset = self.$loadingMore.offset().top +
|
|
self.$loadingMore.outerHeight(false);
|
|
|
|
if (currentOffset + 50 >= loadingMoreOffset) {
|
|
self.loadMore();
|
|
}
|
|
});
|
|
};
|
|
|
|
InfiniteScroll.prototype.loadMore = function () {
|
|
this.loading = true;
|
|
|
|
var params = $.extend({}, {page: 1}, this.lastParams);
|
|
|
|
params.page++;
|
|
|
|
this.trigger('query:append', params);
|
|
};
|
|
|
|
InfiniteScroll.prototype.showLoadingMore = function (_, data) {
|
|
return data.pagination && data.pagination.more;
|
|
};
|
|
|
|
InfiniteScroll.prototype.createLoadingMore = function () {
|
|
var $option = $(
|
|
'<li class="option load-more" role="treeitem"></li>'
|
|
);
|
|
|
|
var message = this.options.get('translations').get('loadingMore');
|
|
|
|
$option.html(message(this.lastParams));
|
|
|
|
return $option;
|
|
};
|
|
|
|
return InfiniteScroll;
|
|
});
|
|
|
|
define('select2/dropdown/attachBody',[
|
|
|
|
], function () {
|
|
function AttachBody (decorated, $element, options) {
|
|
this.$dropdownParent = options.get('dropdownParent') || document.body;
|
|
|
|
decorated.call(this, $element, options);
|
|
}
|
|
|
|
AttachBody.prototype.bind = function (decorated, container, $container) {
|
|
var self = this;
|
|
|
|
var setupResultsEvents = false;
|
|
|
|
decorated.call(this, container, $container);
|
|
|
|
container.on('open', function () {
|
|
self._showDropdown();
|
|
|
|
if (!setupResultsEvents) {
|
|
setupResultsEvents = true;
|
|
|
|
container.on('results:all', function () {
|
|
self._positionDropdown();
|
|
});
|
|
|
|
container.on('results:append', function () {
|
|
self._positionDropdown();
|
|
});
|
|
}
|
|
});
|
|
|
|
container.on('close', function () {
|
|
self._hideDropdown();
|
|
});
|
|
|
|
this.$dropdownContainer.on('mousedown', function (evt) {
|
|
evt.stopPropagation();
|
|
});
|
|
};
|
|
|
|
AttachBody.prototype.position = function (decorated, $dropdown, $container) {
|
|
// Clone all of the container classes
|
|
$dropdown.attr('class', $container.attr('class'));
|
|
|
|
$dropdown.removeClass('select2');
|
|
$dropdown.addClass('select2-container--open');
|
|
|
|
$dropdown.css({
|
|
position: 'absolute'
|
|
});
|
|
|
|
$dropdown.width($container.outerWidth(false));
|
|
|
|
this.$container = $container;
|
|
};
|
|
|
|
AttachBody.prototype.render = function (decorated) {
|
|
var $container = $('<span></span>');
|
|
|
|
var $dropdown = decorated.call(this);
|
|
$container.append($dropdown);
|
|
|
|
this.$dropdownContainer = $container;
|
|
|
|
return $container;
|
|
};
|
|
|
|
AttachBody.prototype._hideDropdown = function (decorated) {
|
|
this.$dropdownContainer.detach();
|
|
};
|
|
|
|
AttachBody.prototype._positionDropdown = function () {
|
|
var $window = $(window);
|
|
|
|
var isCurrentlyAbove = this.$dropdown.hasClass('select2-dropdown--above');
|
|
var isCurrentlyBelow = this.$dropdown.hasClass('select2-dropdown--below');
|
|
|
|
var newDirection = null;
|
|
|
|
var position = this.$container.position();
|
|
var offset = this.$container.offset();
|
|
|
|
offset.bottom = offset.top + this.$container.outerHeight(false);
|
|
|
|
var container = {
|
|
height: this.$container.outerHeight(false)
|
|
};
|
|
|
|
container.top = offset.top;
|
|
container.bottom = offset.top + container.height;
|
|
|
|
var dropdown = {
|
|
height: this.$dropdown.outerHeight(false)
|
|
};
|
|
|
|
var viewport = {
|
|
top: $window.scrollTop(),
|
|
bottom: $window.scrollTop() + $window.height()
|
|
};
|
|
|
|
var enoughRoomAbove = viewport.top < (offset.top - dropdown.height);
|
|
var enoughRoomBelow = viewport.bottom > (offset.bottom + dropdown.height);
|
|
|
|
var css = {
|
|
left: offset.left,
|
|
top: container.bottom
|
|
};
|
|
|
|
if (!isCurrentlyAbove && !isCurrentlyBelow) {
|
|
newDirection = 'below';
|
|
}
|
|
|
|
if (!enoughRoomBelow && enoughRoomAbove && !isCurrentlyAbove) {
|
|
newDirection = 'above';
|
|
} else if (!enoughRoomAbove && enoughRoomBelow && isCurrentlyAbove) {
|
|
newDirection = 'below';
|
|
}
|
|
|
|
if (newDirection == 'above' || isCurrentlyAbove) {
|
|
css.top = container.top - dropdown.height;
|
|
}
|
|
|
|
if (newDirection != null) {
|
|
this.$dropdown
|
|
.removeClass('select2-dropdown--below select2-dropdown--above')
|
|
.addClass('select2-dropdown--' + newDirection);
|
|
this.$container
|
|
.removeClass('select2-container--below select2-container--above')
|
|
.addClass('select2-container--' + newDirection);
|
|
}
|
|
|
|
this.$dropdownContainer.css(css);
|
|
};
|
|
|
|
AttachBody.prototype._showDropdown = function (decorated) {
|
|
this.$dropdownContainer.appendTo(this.$dropdownParent);
|
|
|
|
this._positionDropdown();
|
|
};
|
|
|
|
return AttachBody;
|
|
});
|
|
|
|
define('select2/dropdown/minimumResultsForSearch',[
|
|
|
|
], function () {
|
|
function countResults (data) {
|
|
count = 0;
|
|
|
|
for (var d = 0; d < data.length; d++) {
|
|
var item = data[d];
|
|
|
|
if (item.children) {
|
|
count += countResults(item.children);
|
|
} else {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
function MinimumResultsForSearch (decorated, $element, options, dataAdapter) {
|
|
this.minimumResultsForSearch = options.get('minimumResultsForSearch');
|
|
|
|
decorated.call(this, $element, options, dataAdapter);
|
|
}
|
|
|
|
MinimumResultsForSearch.prototype.showSearch = function (decorated, params) {
|
|
if (countResults(params.data.results) < this.minimumResultsForSearch) {
|
|
return false;
|
|
}
|
|
|
|
return decorated.call(this, params);
|
|
};
|
|
|
|
return MinimumResultsForSearch;
|
|
});
|
|
|
|
define('select2/i18n/en',[],function () {
|
|
// English
|
|
return {
|
|
errorLoading: function () {
|
|
return 'The results could not be loaded.';
|
|
},
|
|
inputTooLong: function (args) {
|
|
var overChars = args.input.length - args.maximum;
|
|
|
|
var message = 'Please delete ' + overChars + ' character';
|
|
|
|
if (overChars != 1) {
|
|
message += 's';
|
|
}
|
|
|
|
return message;
|
|
},
|
|
inputTooShort: function (args) {
|
|
var remainingChars = args.minimum - args.input.length;
|
|
|
|
var message = 'Please enter ' + remainingChars + ' or more characters';
|
|
|
|
return message;
|
|
},
|
|
loadingMore: function () {
|
|
return 'Loading more results…';
|
|
},
|
|
maximumSelected: function (args) {
|
|
var message = 'You can only select ' + args.maximum + ' item';
|
|
|
|
if (args.maximum != 1) {
|
|
message += 's';
|
|
}
|
|
|
|
return message;
|
|
},
|
|
noResults: function () {
|
|
return 'No results found';
|
|
},
|
|
searching: function () {
|
|
return 'Searching…';
|
|
}
|
|
};
|
|
});
|
|
|
|
define('select2/defaults',[
|
|
'jquery',
|
|
'./results',
|
|
|
|
'./selection/single',
|
|
'./selection/multiple',
|
|
'./selection/placeholder',
|
|
'./selection/allowClear',
|
|
'./selection/search',
|
|
|
|
'./utils',
|
|
'./translation',
|
|
'./diacritics',
|
|
|
|
'./data/select',
|
|
'./data/array',
|
|
'./data/ajax',
|
|
'./data/tags',
|
|
'./data/tokenizer',
|
|
'./data/minimumInputLength',
|
|
'./data/maximumInputLength',
|
|
|
|
'./dropdown',
|
|
'./dropdown/search',
|
|
'./dropdown/hidePlaceholder',
|
|
'./dropdown/infiniteScroll',
|
|
'./dropdown/attachBody',
|
|
'./dropdown/minimumResultsForSearch',
|
|
|
|
'./i18n/en'
|
|
], function ($, ResultsList,
|
|
|
|
SingleSelection, MultipleSelection, Placeholder, AllowClear,
|
|
SelectionSearch,
|
|
|
|
Utils, Translation, DIACRITICS,
|
|
|
|
SelectData, ArrayData, AjaxData, Tags, Tokenizer,
|
|
MinimumInputLength, MaximumInputLength,
|
|
|
|
Dropdown, DropdownSearch, HidePlaceholder, InfiniteScroll,
|
|
AttachBody, MinimumResultsForSearch,
|
|
|
|
EnglishTranslation) {
|
|
function Defaults () {
|
|
this.reset();
|
|
}
|
|
|
|
Defaults.prototype.apply = function (options) {
|
|
options = $.extend({}, this.defaults, options);
|
|
|
|
if (options.dataAdapter == null) {
|
|
if (options.ajax != null) {
|
|
options.dataAdapter = AjaxData;
|
|
} else if (options.data != null) {
|
|
options.dataAdapter = ArrayData;
|
|
} else {
|
|
options.dataAdapter = SelectData;
|
|
}
|
|
|
|
if (options.minimumInputLength > 0) {
|
|
options.dataAdapter = Utils.Decorate(
|
|
options.dataAdapter,
|
|
MinimumInputLength
|
|
);
|
|
}
|
|
|
|
if (options.maximumInputLength > 0) {
|
|
options.dataAdapter = Utils.Decorate(
|
|
options.dataAdapter,
|
|
MaximumInputLength
|
|
);
|
|
}
|
|
|
|
if (options.tags != null) {
|
|
options.dataAdapter = Utils.Decorate(options.dataAdapter, Tags);
|
|
}
|
|
|
|
if (options.tokenSeparators != null || options.tokenizer != null) {
|
|
options.dataAdapter = Utils.Decorate(
|
|
options.dataAdapter,
|
|
Tokenizer
|
|
);
|
|
}
|
|
}
|
|
|
|
if (options.resultsAdapter == null) {
|
|
options.resultsAdapter = ResultsList;
|
|
|
|
if (options.ajax != null) {
|
|
options.resultsAdapter = Utils.Decorate(
|
|
options.resultsAdapter,
|
|
InfiniteScroll
|
|
);
|
|
}
|
|
|
|
if (options.placeholder != null) {
|
|
options.resultsAdapter = Utils.Decorate(
|
|
options.resultsAdapter,
|
|
HidePlaceholder
|
|
);
|
|
}
|
|
}
|
|
|
|
if (options.dropdownAdapter == null) {
|
|
if (options.multiple) {
|
|
options.dropdownAdapter = Dropdown;
|
|
} else {
|
|
var SearchableDropdown = Utils.Decorate(Dropdown, DropdownSearch);
|
|
|
|
options.dropdownAdapter = SearchableDropdown;
|
|
}
|
|
|
|
if (options.minimumResultsForSearch > 0) {
|
|
options.dropdownAdapter = Utils.Decorate(
|
|
options.dropdownAdapter,
|
|
MinimumResultsForSearch
|
|
);
|
|
}
|
|
|
|
options.dropdownAdapter = Utils.Decorate(
|
|
options.dropdownAdapter,
|
|
AttachBody
|
|
);
|
|
}
|
|
|
|
if (options.selectionAdapter == null) {
|
|
if (options.multiple) {
|
|
options.selectionAdapter = MultipleSelection;
|
|
} else {
|
|
options.selectionAdapter = SingleSelection;
|
|
}
|
|
|
|
// Add the placeholder mixin if a placeholder was specified
|
|
if (options.placeholder != null) {
|
|
options.selectionAdapter = Utils.Decorate(
|
|
options.selectionAdapter,
|
|
Placeholder
|
|
);
|
|
|
|
if (options.allowClear) {
|
|
options.selectionAdapter = Utils.Decorate(
|
|
options.selectionAdapter,
|
|
AllowClear
|
|
);
|
|
}
|
|
}
|
|
|
|
if (options.multiple) {
|
|
options.selectionAdapter = Utils.Decorate(
|
|
options.selectionAdapter,
|
|
SelectionSearch
|
|
);
|
|
}
|
|
}
|
|
|
|
if (typeof options.language === 'string') {
|
|
options.language = [options.language];
|
|
}
|
|
|
|
if ($.isArray(options.language)) {
|
|
var languages = new Translation();
|
|
options.language.push('en');
|
|
|
|
var languageNames = options.language;
|
|
|
|
for (var l = 0; l < languageNames.length; l++) {
|
|
var name = languageNames[l];
|
|
var language = {};
|
|
|
|
try {
|
|
// Try to load it with the original name
|
|
language = Translation.loadPath(name);
|
|
} catch (e) {
|
|
// If we couldn't load it, check if it wasn't the full path
|
|
name = 'select2/i18n/' + name;
|
|
language = Translation.loadPath(name);
|
|
}
|
|
|
|
languages.extend(language);
|
|
}
|
|
|
|
options.translations = languages;
|
|
} else {
|
|
options.translations = new Translation(options.language);
|
|
}
|
|
|
|
return options;
|
|
};
|
|
|
|
Defaults.prototype.reset = function () {
|
|
function stripDiacritics (text) {
|
|
// Used 'uni range + named function' from http://jsperf.com/diacritics/18
|
|
function match(a) {
|
|
return DIACRITICS[a] || a;
|
|
}
|
|
|
|
return text.replace(/[^\u0000-\u007E]/g, match);
|
|
}
|
|
|
|
function matcher (params, data) {
|
|
// Always return the object if there is nothing to compare
|
|
if ($.trim(params.term) === '') {
|
|
return data;
|
|
}
|
|
|
|
// Do a recursive check for options with children
|
|
if (data.children && data.children.length > 0) {
|
|
// Clone the data object if there are children
|
|
// This is required as we modify the object to remove any non-matches
|
|
var match = $.extend(true, {}, data);
|
|
|
|
// Check each child of the option
|
|
for (var c = data.children.length - 1; c >= 0; c--) {
|
|
var child = data.children[c];
|
|
|
|
var matches = matcher(params, child);
|
|
|
|
// If there wasn't a match, remove the object in the array
|
|
if (matches == null) {
|
|
match.children.splice(c, 1);
|
|
}
|
|
}
|
|
|
|
// If any children matched, return the new object
|
|
if (match.children.length > 0) {
|
|
return match;
|
|
}
|
|
|
|
// If there were no matching children, check just the plain object
|
|
return matcher(params, match);
|
|
}
|
|
|
|
var original = stripDiacritics(data.text).toUpperCase();
|
|
var term = stripDiacritics(params.term).toUpperCase();
|
|
|
|
// Check if the text contains the term
|
|
if (original.indexOf(term) > -1) {
|
|
return data;
|
|
}
|
|
|
|
// If it doesn't contain the term, don't return anything
|
|
return null;
|
|
}
|
|
|
|
this.defaults = {
|
|
language: EnglishTranslation,
|
|
matcher: matcher,
|
|
sorter: function (data) {
|
|
return data;
|
|
},
|
|
minimumInputLength: 0,
|
|
maximumInputLength: 0,
|
|
minimumResultsForSearch: 0,
|
|
templateResult: function (result) {
|
|
return result.text;
|
|
},
|
|
templateSelection: function (selection) {
|
|
return selection.text;
|
|
},
|
|
theme: 'default'
|
|
};
|
|
};
|
|
|
|
var defaults = new Defaults();
|
|
|
|
return defaults;
|
|
});
|
|
|
|
define('select2/options',[
|
|
'jquery',
|
|
'./defaults'
|
|
], function ($, Defaults) {
|
|
function Options (options, $element) {
|
|
this.options = options;
|
|
|
|
if ($element != null) {
|
|
this.fromElement($element);
|
|
}
|
|
|
|
this.options = Defaults.apply(this.options);
|
|
}
|
|
|
|
Options.prototype.fromElement = function ($e) {
|
|
var excludedData = ['select2'];
|
|
|
|
if (this.options.multiple == null) {
|
|
this.options.multiple = $e.prop('multiple');
|
|
}
|
|
|
|
if (this.options.disabled == null) {
|
|
this.options.disabled = $e.prop('disabled');
|
|
}
|
|
|
|
if (this.options.language == null) {
|
|
if ($e.prop('lang')) {
|
|
this.options.language = $e.prop('lang').toLowerCase();
|
|
} else if ($e.closest('[lang]').prop('lang')) {
|
|
this.options.language = $e.closest('[lang]').prop('lang');
|
|
}
|
|
}
|
|
|
|
if (this.options.dir == null) {
|
|
if ($e.prop('dir')) {
|
|
this.options.dir = $e.prop('dir');
|
|
} else if ($e.closest('[dir]').prop('dir')) {
|
|
this.options.dir = $e.closest('[dir]').prop('dir');
|
|
} else {
|
|
this.options.dir = 'ltr';
|
|
}
|
|
}
|
|
|
|
$e.prop('disabled', this.options.disabled);
|
|
$e.prop('multiple', this.options.multiple);
|
|
|
|
if ($e.data('select2-tags')) {
|
|
if (console && console.warn) {
|
|
console.warn(
|
|
'Select2: The `data-select2-tags` attribute has been changed to ' +
|
|
'use the `data-data` and `data-tags="true"` attributes and will be ' +
|
|
'removed in future versions of Select2.'
|
|
);
|
|
}
|
|
|
|
$e.data('data', $e.data('select2-tags'));
|
|
$e.data('tags', true);
|
|
}
|
|
|
|
if ($e.data('ajax-url')) {
|
|
if (console && console.warn) {
|
|
console.warn(
|
|
'Select2: The `data-ajax-attribute` has been changed to ' +
|
|
'`data-ajax--url` and support for the old attribute will be removed' +
|
|
' in future versions of Select2.'
|
|
);
|
|
}
|
|
|
|
$e.data('ajax--url', $e.data('ajax-url'));
|
|
}
|
|
|
|
var data = $e.data();
|
|
|
|
function convertData (data) {
|
|
for (var originalKey in data) {
|
|
var keys = originalKey.split('-');
|
|
|
|
var dataLevel = data;
|
|
|
|
if (keys.length === 1) {
|
|
continue;
|
|
}
|
|
|
|
for (var k = 0; k < keys.length; k++) {
|
|
var key = keys[k];
|
|
|
|
// Lowercase the first letter
|
|
// By default, dash-separated becomes camelCase
|
|
key = key.substring(0, 1).toLowerCase() + key.substring(1);
|
|
|
|
if (!(key in dataLevel)) {
|
|
dataLevel[key] = {};
|
|
}
|
|
|
|
if (k == keys.length - 1) {
|
|
dataLevel[key] = data[originalKey];
|
|
}
|
|
|
|
dataLevel = dataLevel[key];
|
|
}
|
|
|
|
delete data[originalKey];
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
data = convertData(data);
|
|
|
|
for (var key in data) {
|
|
if (excludedData.indexOf(key) > -1) {
|
|
continue;
|
|
}
|
|
|
|
if ($.isPlainObject(this.options[key])) {
|
|
$.extend(this.options[key], data[key]);
|
|
} else {
|
|
this.options[key] = data[key];
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
Options.prototype.get = function (key) {
|
|
return this.options[key];
|
|
};
|
|
|
|
Options.prototype.set = function (key, val) {
|
|
this.options[key] = val;
|
|
};
|
|
|
|
return Options;
|
|
});
|
|
|
|
define('select2/core',[
|
|
'jquery',
|
|
'./options',
|
|
'./utils',
|
|
'./keys'
|
|
], function ($, Options, Utils, KEYS) {
|
|
var Select2 = function ($element, options) {
|
|
if ($element.data('select2') != null) {
|
|
$element.data('select2').destroy();
|
|
}
|
|
|
|
this.$element = $element;
|
|
|
|
this.id = this._generateId($element);
|
|
|
|
options = options || {};
|
|
|
|
this.options = new Options(options, $element);
|
|
|
|
Select2.__super__.constructor.call(this);
|
|
|
|
// Set up containers and adapters
|
|
|
|
var DataAdapter = this.options.get('dataAdapter');
|
|
this.data = new DataAdapter($element, this.options);
|
|
|
|
var $container = this.render();
|
|
|
|
this._placeContainer($container);
|
|
|
|
var SelectionAdapter = this.options.get('selectionAdapter');
|
|
this.selection = new SelectionAdapter($element, this.options);
|
|
this.$selection = this.selection.render();
|
|
|
|
this.selection.position(this.$selection, $container);
|
|
|
|
var DropdownAdapter = this.options.get('dropdownAdapter');
|
|
this.dropdown = new DropdownAdapter($element, this.options);
|
|
this.$dropdown = this.dropdown.render();
|
|
|
|
this.dropdown.position(this.$dropdown, $container);
|
|
|
|
var ResultsAdapter = this.options.get('resultsAdapter');
|
|
this.results = new ResultsAdapter($element, this.options, this.data);
|
|
this.$results = this.results.render();
|
|
|
|
this.results.position(this.$results, this.$dropdown);
|
|
|
|
// Bind events
|
|
|
|
var self = this;
|
|
|
|
// Bind the container to all of the adapters
|
|
this._bindAdapters();
|
|
|
|
// Register any DOM event handlers
|
|
this._registerDomEvents();
|
|
|
|
// Register any internal event handlers
|
|
this._registerDataEvents();
|
|
this._registerSelectionEvents();
|
|
this._registerDropdownEvents();
|
|
this._registerResultsEvents();
|
|
this._registerEvents();
|
|
|
|
// Set the initial state
|
|
this.data.current(function (initialData) {
|
|
self.trigger('selection:update', {
|
|
data: initialData
|
|
});
|
|
});
|
|
|
|
// Hide the original select
|
|
$element.hide();
|
|
|
|
// Synchronize any monitored attributes
|
|
this._syncAttributes();
|
|
|
|
this._tabindex = $element.attr('tabindex') || 0;
|
|
|
|
$element.attr('tabindex', '-1');
|
|
|
|
$element.data('select2', this);
|
|
};
|
|
|
|
Utils.Extend(Select2, Utils.Observable);
|
|
|
|
Select2.prototype._generateId = function ($element) {
|
|
var id = '';
|
|
|
|
if ($element.attr('id') != null) {
|
|
id = $element.attr('id');
|
|
} else if ($element.attr('name') != null) {
|
|
id = $element.attr('name') + '-' + Utils.generateChars(2);
|
|
} else {
|
|
id = Utils.generateChars(4);
|
|
}
|
|
|
|
id = 'select2-' + id;
|
|
|
|
return id;
|
|
};
|
|
|
|
Select2.prototype._placeContainer = function ($container) {
|
|
$container.insertAfter(this.$element);
|
|
$container.width(this.$element.outerWidth(false));
|
|
};
|
|
|
|
Select2.prototype._bindAdapters = function () {
|
|
this.data.bind(this, this.$container);
|
|
this.selection.bind(this, this.$container);
|
|
|
|
this.dropdown.bind(this, this.$container);
|
|
this.results.bind(this, this.$container);
|
|
};
|
|
|
|
Select2.prototype._registerDomEvents = function () {
|
|
var self = this;
|
|
|
|
this.$element.on('change.select2', function () {
|
|
self.data.current(function (data) {
|
|
self.trigger('selection:update', {
|
|
data: data
|
|
});
|
|
});
|
|
});
|
|
|
|
this._sync = Utils.bind(this._syncAttributes, this);
|
|
|
|
if (this.$element[0].attachEvent) {
|
|
this.$element[0].attachEvent('onpropertychange', this._sync);
|
|
}
|
|
|
|
var observer = window.MutationObserver ||
|
|
window.WebKitMutationObserver ||
|
|
window.MozMutationObserver
|
|
;
|
|
|
|
if (observer != null) {
|
|
this._observer = new observer(function (mutations) {
|
|
$.each(mutations, self._sync);
|
|
});
|
|
this._observer.observe(this.$element[0], {
|
|
attributes: true,
|
|
subtree: false
|
|
});
|
|
}
|
|
};
|
|
|
|
Select2.prototype._registerDataEvents = function () {
|
|
var self = this;
|
|
|
|
this.data.on('*', function (name, params) {
|
|
self.trigger(name, params);
|
|
});
|
|
};
|
|
|
|
Select2.prototype._registerSelectionEvents = function () {
|
|
var self = this;
|
|
var nonRelayEvents = ['open', 'close', 'toggle', 'unselected'];
|
|
|
|
this.selection.on('open', function () {
|
|
self.open();
|
|
});
|
|
this.selection.on('close', function () {
|
|
self.close();
|
|
});
|
|
this.selection.on('toggle', function () {
|
|
self.toggleDropdown();
|
|
});
|
|
|
|
this.selection.on('unselected', function (params) {
|
|
self.trigger('unselect', params);
|
|
|
|
self.close();
|
|
});
|
|
|
|
this.selection.on('*', function (name, params) {
|
|
if (nonRelayEvents.indexOf(name) !== -1) {
|
|
return;
|
|
}
|
|
|
|
self.trigger(name, params);
|
|
});
|
|
};
|
|
|
|
Select2.prototype._registerDropdownEvents = function () {
|
|
var self = this;
|
|
|
|
this.dropdown.on('*', function (name, params) {
|
|
self.trigger(name, params);
|
|
});
|
|
};
|
|
|
|
Select2.prototype._registerResultsEvents = function () {
|
|
var self = this;
|
|
var nonRelayEvents = ['selected', 'unselected'];
|
|
|
|
this.results.on('selected', function (params) {
|
|
self.trigger('select', params);
|
|
|
|
self.close();
|
|
});
|
|
|
|
this.results.on('unselected', function (params) {
|
|
self.trigger('unselect', params);
|
|
|
|
self.close();
|
|
});
|
|
|
|
this.results.on('*', function (name, params) {
|
|
if (nonRelayEvents.indexOf(name) !== -1) {
|
|
return;
|
|
}
|
|
|
|
self.trigger(name, params);
|
|
});
|
|
};
|
|
|
|
Select2.prototype._registerEvents = function () {
|
|
var self = this;
|
|
|
|
this.on('open', function () {
|
|
self.$container.addClass('select2-container--open');
|
|
});
|
|
|
|
this.on('close', function () {
|
|
self.$container.removeClass('select2-container--open');
|
|
});
|
|
|
|
this.on('enable', function () {
|
|
self.$container.removeClass('select2-container--disabled');
|
|
});
|
|
|
|
this.on('disable', function () {
|
|
self.$container.addClass('select2-container--disabled');
|
|
});
|
|
|
|
this.on('query', function (params) {
|
|
this.data.query(params, function (data) {
|
|
self.trigger('results:all', {
|
|
data: data,
|
|
query: params
|
|
});
|
|
});
|
|
});
|
|
|
|
this.on('query:append', function (params) {
|
|
this.data.query(params, function (data) {
|
|
self.trigger('results:append', {
|
|
data: data,
|
|
query: params
|
|
});
|
|
});
|
|
});
|
|
|
|
this.on('keypress', function (evt) {
|
|
var key = evt.which;
|
|
|
|
if (self.isOpen()) {
|
|
if (key === KEYS.ENTER) {
|
|
self.trigger('results:select');
|
|
|
|
evt.preventDefault();
|
|
} else if (key === KEYS.UP) {
|
|
self.trigger('results:previous');
|
|
|
|
evt.preventDefault();
|
|
} else if (key === KEYS.DOWN) {
|
|
self.trigger('results:next');
|
|
|
|
evt.preventDefault();
|
|
} else if (key === KEYS.ESC || key === KEYS.TAB) {
|
|
self.close();
|
|
|
|
evt.preventDefault();
|
|
}
|
|
} else {
|
|
if (key === KEYS.ENTER || key === KEYS.SPACE ||
|
|
((key === KEYS.DOWN || key === KEYS.UP) && evt.altKey)) {
|
|
self.open();
|
|
|
|
evt.preventDefault();
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
Select2.prototype._syncAttributes = function () {
|
|
this.options.set('disabled', this.$element.prop('disabled'));
|
|
|
|
if (this.options.get('disabled')) {
|
|
if (this.isOpen()) {
|
|
this.trigger('close');
|
|
}
|
|
|
|
this.trigger('disable');
|
|
} else {
|
|
this.trigger('enable');
|
|
}
|
|
};
|
|
|
|
Select2.prototype.toggleDropdown = function () {
|
|
if (this.options.get('disabled')) {
|
|
return;
|
|
}
|
|
|
|
if (this.isOpen()) {
|
|
this.close();
|
|
} else {
|
|
this.open();
|
|
}
|
|
};
|
|
|
|
Select2.prototype.open = function () {
|
|
if (this.isOpen()) {
|
|
return;
|
|
}
|
|
|
|
this.trigger('query', {});
|
|
|
|
this.trigger('open');
|
|
};
|
|
|
|
Select2.prototype.close = function () {
|
|
if (!this.isOpen()) {
|
|
return;
|
|
}
|
|
|
|
this.trigger('close');
|
|
};
|
|
|
|
Select2.prototype.isOpen = function () {
|
|
return this.$container.hasClass('select2-container--open');
|
|
};
|
|
|
|
Select2.prototype.enable = function (args) {
|
|
if (console && console.warn) {
|
|
console.warn(
|
|
'Select2: The `select2("val")` method has been deprecated and will be' +
|
|
' removed in later Select2 versions. Use $element.prop("disabled") ' +
|
|
'instead.'
|
|
);
|
|
}
|
|
|
|
if (args.length === 0) {
|
|
args = [true];
|
|
}
|
|
|
|
var disabled = !args[0];
|
|
|
|
this.$element.prop('disabled', disabled);
|
|
};
|
|
|
|
Select2.prototype.val = function (args) {
|
|
if (console && console.warn) {
|
|
console.warn(
|
|
'Select2: The `select2("val")` method has been deprecated and will be' +
|
|
' removed in later Select2 versions. Use $element.val() instead.'
|
|
);
|
|
}
|
|
|
|
if (args.length === 0) {
|
|
return this.$element.val();
|
|
}
|
|
|
|
var newVal = args[0];
|
|
|
|
if ($.isArray(newVal)) {
|
|
newVal = $.map(newVal, function (obj) {
|
|
return obj.toString();
|
|
});
|
|
}
|
|
|
|
this.$element.val(newVal).trigger('change');
|
|
};
|
|
|
|
Select2.prototype.destroy = function () {
|
|
this.$container.remove();
|
|
|
|
if (this.$element[0].detachEvent) {
|
|
this.$element[0].detachEvent('onpropertychange', this._sync);
|
|
}
|
|
|
|
if (this._observer != null) {
|
|
this._observer.disconnect();
|
|
this._observer = null;
|
|
}
|
|
|
|
this._sync = null;
|
|
|
|
this.$element.off('.select2');
|
|
this.$element.attr('tabindex', this._tabindex);
|
|
|
|
this.$element.show();
|
|
this.$element.removeData('select2');
|
|
|
|
this.data.destroy();
|
|
this.selection.destroy();
|
|
this.dropdown.destroy();
|
|
this.results.destroy();
|
|
|
|
this.data = null;
|
|
this.selection = null;
|
|
this.dropdown = null;
|
|
this.results = null;
|
|
};
|
|
|
|
Select2.prototype.render = function () {
|
|
var $container = $(
|
|
'<span class="select2 select2-container">' +
|
|
'<span class="selection"></span>' +
|
|
'<span class="dropdown-wrapper" aria-hidden="true"></span>' +
|
|
'</span>'
|
|
);
|
|
|
|
$container.attr('dir', this.options.get('dir'));
|
|
|
|
this.$container = $container;
|
|
|
|
this.$container.addClass('select2-container--' + this.options.get('theme'));
|
|
|
|
$container.data('element', this.$element);
|
|
|
|
return $container;
|
|
};
|
|
|
|
return Select2;
|
|
});
|
|
|
|
/*!
|
|
* jQuery Mousewheel 3.1.12
|
|
*
|
|
* Copyright 2014 jQuery Foundation and other contributors
|
|
* Released under the MIT license.
|
|
* http://jquery.org/license
|
|
*/
|
|
|
|
(function (factory) {
|
|
if ( typeof define === 'function' && define.amd ) {
|
|
// AMD. Register as an anonymous module.
|
|
define('jquery.mousewheel',['jquery'], factory);
|
|
} else if (typeof exports === 'object') {
|
|
// Node/CommonJS style for Browserify
|
|
module.exports = factory;
|
|
} else {
|
|
// Browser globals
|
|
factory(jQuery);
|
|
}
|
|
}(function ($) {
|
|
|
|
var toFix = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'],
|
|
toBind = ( 'onwheel' in document || document.documentMode >= 9 ) ?
|
|
['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'],
|
|
slice = Array.prototype.slice,
|
|
nullLowestDeltaTimeout, lowestDelta;
|
|
|
|
if ( $.event.fixHooks ) {
|
|
for ( var i = toFix.length; i; ) {
|
|
$.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;
|
|
}
|
|
}
|
|
|
|
var special = $.event.special.mousewheel = {
|
|
version: '3.1.12',
|
|
|
|
setup: function() {
|
|
if ( this.addEventListener ) {
|
|
for ( var i = toBind.length; i; ) {
|
|
this.addEventListener( toBind[--i], handler, false );
|
|
}
|
|
} else {
|
|
this.onmousewheel = handler;
|
|
}
|
|
// Store the line height and page height for this particular element
|
|
$.data(this, 'mousewheel-line-height', special.getLineHeight(this));
|
|
$.data(this, 'mousewheel-page-height', special.getPageHeight(this));
|
|
},
|
|
|
|
teardown: function() {
|
|
if ( this.removeEventListener ) {
|
|
for ( var i = toBind.length; i; ) {
|
|
this.removeEventListener( toBind[--i], handler, false );
|
|
}
|
|
} else {
|
|
this.onmousewheel = null;
|
|
}
|
|
// Clean up the data we added to the element
|
|
$.removeData(this, 'mousewheel-line-height');
|
|
$.removeData(this, 'mousewheel-page-height');
|
|
},
|
|
|
|
getLineHeight: function(elem) {
|
|
var $elem = $(elem),
|
|
$parent = $elem['offsetParent' in $.fn ? 'offsetParent' : 'parent']();
|
|
if (!$parent.length) {
|
|
$parent = $('body');
|
|
}
|
|
return parseInt($parent.css('fontSize'), 10) || parseInt($elem.css('fontSize'), 10) || 16;
|
|
},
|
|
|
|
getPageHeight: function(elem) {
|
|
return $(elem).height();
|
|
},
|
|
|
|
settings: {
|
|
adjustOldDeltas: true, // see shouldAdjustOldDeltas() below
|
|
normalizeOffset: true // calls getBoundingClientRect for each event
|
|
}
|
|
};
|
|
|
|
$.fn.extend({
|
|
mousewheel: function(fn) {
|
|
return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');
|
|
},
|
|
|
|
unmousewheel: function(fn) {
|
|
return this.unbind('mousewheel', fn);
|
|
}
|
|
});
|
|
|
|
|
|
function handler(event) {
|
|
var orgEvent = event || window.event,
|
|
args = slice.call(arguments, 1),
|
|
delta = 0,
|
|
deltaX = 0,
|
|
deltaY = 0,
|
|
absDelta = 0,
|
|
offsetX = 0,
|
|
offsetY = 0;
|
|
event = $.event.fix(orgEvent);
|
|
event.type = 'mousewheel';
|
|
|
|
// Old school scrollwheel delta
|
|
if ( 'detail' in orgEvent ) { deltaY = orgEvent.detail * -1; }
|
|
if ( 'wheelDelta' in orgEvent ) { deltaY = orgEvent.wheelDelta; }
|
|
if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY; }
|
|
if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }
|
|
|
|
// Firefox < 17 horizontal scrolling related to DOMMouseScroll event
|
|
if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
|
|
deltaX = deltaY * -1;
|
|
deltaY = 0;
|
|
}
|
|
|
|
// Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
|
|
delta = deltaY === 0 ? deltaX : deltaY;
|
|
|
|
// New school wheel delta (wheel event)
|
|
if ( 'deltaY' in orgEvent ) {
|
|
deltaY = orgEvent.deltaY * -1;
|
|
delta = deltaY;
|
|
}
|
|
if ( 'deltaX' in orgEvent ) {
|
|
deltaX = orgEvent.deltaX;
|
|
if ( deltaY === 0 ) { delta = deltaX * -1; }
|
|
}
|
|
|
|
// No change actually happened, no reason to go any further
|
|
if ( deltaY === 0 && deltaX === 0 ) { return; }
|
|
|
|
// Need to convert lines and pages to pixels if we aren't already in pixels
|
|
// There are three delta modes:
|
|
// * deltaMode 0 is by pixels, nothing to do
|
|
// * deltaMode 1 is by lines
|
|
// * deltaMode 2 is by pages
|
|
if ( orgEvent.deltaMode === 1 ) {
|
|
var lineHeight = $.data(this, 'mousewheel-line-height');
|
|
delta *= lineHeight;
|
|
deltaY *= lineHeight;
|
|
deltaX *= lineHeight;
|
|
} else if ( orgEvent.deltaMode === 2 ) {
|
|
var pageHeight = $.data(this, 'mousewheel-page-height');
|
|
delta *= pageHeight;
|
|
deltaY *= pageHeight;
|
|
deltaX *= pageHeight;
|
|
}
|
|
|
|
// Store lowest absolute delta to normalize the delta values
|
|
absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );
|
|
|
|
if ( !lowestDelta || absDelta < lowestDelta ) {
|
|
lowestDelta = absDelta;
|
|
|
|
// Adjust older deltas if necessary
|
|
if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
|
|
lowestDelta /= 40;
|
|
}
|
|
}
|
|
|
|
// Adjust older deltas if necessary
|
|
if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
|
|
// Divide all the things by 40!
|
|
delta /= 40;
|
|
deltaX /= 40;
|
|
deltaY /= 40;
|
|
}
|
|
|
|
// Get a whole, normalized value for the deltas
|
|
delta = Math[ delta >= 1 ? 'floor' : 'ceil' ](delta / lowestDelta);
|
|
deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);
|
|
deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);
|
|
|
|
// Normalise offsetX and offsetY properties
|
|
if ( special.settings.normalizeOffset && this.getBoundingClientRect ) {
|
|
var boundingRect = this.getBoundingClientRect();
|
|
offsetX = event.clientX - boundingRect.left;
|
|
offsetY = event.clientY - boundingRect.top;
|
|
}
|
|
|
|
// Add information to the event object
|
|
event.deltaX = deltaX;
|
|
event.deltaY = deltaY;
|
|
event.deltaFactor = lowestDelta;
|
|
event.offsetX = offsetX;
|
|
event.offsetY = offsetY;
|
|
// Go ahead and set deltaMode to 0 since we converted to pixels
|
|
// Although this is a little odd since we overwrite the deltaX/Y
|
|
// properties with normalized deltas.
|
|
event.deltaMode = 0;
|
|
|
|
// Add event and delta to the front of the arguments
|
|
args.unshift(event, delta, deltaX, deltaY);
|
|
|
|
// Clearout lowestDelta after sometime to better
|
|
// handle multiple device types that give different
|
|
// a different lowestDelta
|
|
// Ex: trackpad = 3 and mouse wheel = 120
|
|
if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }
|
|
nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);
|
|
|
|
return ($.event.dispatch || $.event.handle).apply(this, args);
|
|
}
|
|
|
|
function nullLowestDelta() {
|
|
lowestDelta = null;
|
|
}
|
|
|
|
function shouldAdjustOldDeltas(orgEvent, absDelta) {
|
|
// If this is an older event and the delta is divisable by 120,
|
|
// then we are assuming that the browser is treating this as an
|
|
// older mouse wheel event and that we should divide the deltas
|
|
// by 40 to try and get a more usable deltaFactor.
|
|
// Side note, this actually impacts the reported scroll distance
|
|
// in older browsers and can cause scrolling to be slower than native.
|
|
// Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false.
|
|
return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0;
|
|
}
|
|
|
|
}));
|
|
|
|
define('select2/compat/matcher',[
|
|
|
|
], function () {
|
|
function oldMatcher (matcher) {
|
|
function wrappedMatcher (params, data) {
|
|
var match = $.extend(true, {}, data);
|
|
|
|
if (params.term == null || $.trim(params.term) === '') {
|
|
return match;
|
|
}
|
|
|
|
if (data.children) {
|
|
for (var c = data.children.length - 1; c >= 0; c--) {
|
|
var child = data.children[c];
|
|
|
|
// Check if the child object matches
|
|
// The old matcher returned a boolean true or false
|
|
var doesMatch = matcher(params.term, child.text, child);
|
|
|
|
// If the child didn't match, pop it off
|
|
if (!doesMatch) {
|
|
match.children.splice(c, 1);
|
|
}
|
|
}
|
|
|
|
if (match.children.length > 0) {
|
|
return match;
|
|
}
|
|
}
|
|
|
|
if (matcher(params.term, data.text, data)) {
|
|
return match;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
return wrappedMatcher;
|
|
}
|
|
|
|
return oldMatcher;
|
|
});
|
|
|
|
define('select2/dropdown/attachContainer',[
|
|
|
|
], function () {
|
|
function AttachContainer (decorated, $element, options) {
|
|
decorated.call(this, $element, options);
|
|
}
|
|
|
|
AttachContainer.prototype.position =
|
|
function (decorated, $dropdown, $container) {
|
|
var $dropdownContainer = $container.find('.dropdown-wrapper');
|
|
$dropdownContainer.append($dropdown);
|
|
|
|
$dropdown.addClass('select2-dropdown--below');
|
|
$container.addClass('select2-container--below');
|
|
};
|
|
|
|
return AttachContainer;
|
|
});
|
|
|
|
define('jquery.select2',[
|
|
'jquery',
|
|
'select2/core'
|
|
], function ($, Select2) {
|
|
// Force jQuery.mousewheel to be loaded if it hasn't already
|
|
try {
|
|
require('jquery.mousewheel');
|
|
} catch (Exception) { }
|
|
|
|
if ($.fn.select2 == null) {
|
|
$.fn.select2 = function (options) {
|
|
options = options || {};
|
|
|
|
if (typeof options === 'object') {
|
|
this.each(function () {
|
|
var instanceOptions = $.extend({}, options, true);
|
|
|
|
var instance = new Select2($(this), instanceOptions);
|
|
});
|
|
|
|
return this;
|
|
} else if (typeof options === 'string') {
|
|
var instance = this.data('select2');
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
|
|
return instance[options](args);
|
|
} else {
|
|
throw new Error('Invalid arguments for Select2: ' + options);
|
|
}
|
|
};
|
|
}
|
|
|
|
return Select2;
|
|
});
|
|
|
|
require('jquery.select2'); $.fn.select2.amd = { define: define, require: require };}()); |