|
1
|
/*! |
|
2
|
* Select2 4.0.13 |
|
3
|
* https://select2.github.io |
|
4
|
* |
|
5
|
* Released under the MIT license |
|
6
|
* https://github.com/select2/select2/blob/master/LICENSE.md |
|
7
|
*/ |
|
8
|
;(function (factory) { |
|
9
|
if (typeof define === 'function' && define.amd) { |
|
10
|
// AMD. Register as an anonymous module. |
|
11
|
define(['jquery'], factory); |
|
12
|
} else if (typeof module === 'object' && module.exports) { |
|
13
|
// Node/CommonJS |
|
14
|
module.exports = function (root, jQuery) { |
|
15
|
if (jQuery === undefined) { |
|
16
|
// require('jQuery') returns a factory that requires window to |
|
17
|
// build a jQuery instance, we normalize how we use modules |
|
18
|
// that require this pattern but the window provided is a noop |
|
19
|
// if it's defined (how jquery works) |
|
20
|
if (typeof window !== 'undefined') { |
|
21
|
jQuery = require('jquery'); |
|
22
|
} |
|
23
|
else { |
|
24
|
jQuery = require('jquery')(root); |
|
25
|
} |
|
26
|
} |
|
27
|
factory(jQuery); |
|
28
|
return jQuery; |
|
29
|
}; |
|
30
|
} else { |
|
31
|
// Browser globals |
|
32
|
factory(jQuery); |
|
33
|
} |
|
34
|
} (function (jQuery) { |
|
35
|
// This is needed so we can catch the AMD loader configuration and use it |
|
36
|
// The inner file should be wrapped (by `banner.start.js`) in a function that |
|
37
|
// returns the AMD loader references. |
|
38
|
var S2 =(function () { |
|
39
|
// Restore the Select2 AMD loader so it can be used |
|
40
|
// Needed mostly in the language files, where the loader is not inserted |
|
41
|
if (jQuery && jQuery.fn && jQuery.fn.select2 && jQuery.fn.select2.amd) { |
|
42
|
var S2 = jQuery.fn.select2.amd; |
|
43
|
} |
|
44
|
var S2;(function () { if (!S2 || !S2.requirejs) { |
|
45
|
if (!S2) { S2 = {}; } else { require = S2; } |
|
46
|
/** |
|
47
|
* @license almond 0.3.3 Copyright jQuery Foundation and other contributors. |
|
48
|
* Released under MIT license, http://github.com/requirejs/almond/LICENSE |
|
49
|
*/ |
|
50
|
//Going sloppy to avoid 'use strict' string cost, but strict practices should |
|
51
|
//be followed. |
|
52
|
/*global setTimeout: false */ |
|
53
|
|
|
54
|
var requirejs, require, define; |
|
55
|
(function (undef) { |
|
56
|
var main, req, makeMap, handlers, |
|
57
|
defined = {}, |
|
58
|
waiting = {}, |
|
59
|
config = {}, |
|
60
|
defining = {}, |
|
61
|
hasOwn = Object.prototype.hasOwnProperty, |
|
62
|
aps = [].slice, |
|
63
|
jsSuffixRegExp = /\.js$/; |
|
64
|
|
|
65
|
function hasProp(obj, prop) { |
|
66
|
return hasOwn.call(obj, prop); |
|
67
|
} |
|
68
|
|
|
69
|
/** |
|
70
|
* Given a relative module name, like ./something, normalize it to |
|
71
|
* a real name that can be mapped to a path. |
|
72
|
* @param {String} name the relative name |
|
73
|
* @param {String} baseName a real name that the name arg is relative |
|
74
|
* to. |
|
75
|
* @returns {String} normalized name |
|
76
|
*/ |
|
77
|
function normalize(name, baseName) { |
|
78
|
var nameParts, nameSegment, mapValue, foundMap, lastIndex, |
|
79
|
foundI, foundStarMap, starI, i, j, part, normalizedBaseParts, |
|
80
|
baseParts = baseName && baseName.split("/"), |
|
81
|
map = config.map, |
|
82
|
starMap = (map && map['*']) || {}; |
|
83
|
|
|
84
|
//Adjust any relative paths. |
|
85
|
if (name) { |
|
86
|
name = name.split('/'); |
|
87
|
lastIndex = name.length - 1; |
|
88
|
|
|
89
|
// If wanting node ID compatibility, strip .js from end |
|
90
|
// of IDs. Have to do this here, and not in nameToUrl |
|
91
|
// because node allows either .js or non .js to map |
|
92
|
// to same file. |
|
93
|
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) { |
|
94
|
name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, ''); |
|
95
|
} |
|
96
|
|
|
97
|
// Starts with a '.' so need the baseName |
|
98
|
if (name[0].charAt(0) === '.' && baseParts) { |
|
99
|
//Convert baseName to array, and lop off the last part, |
|
100
|
//so that . matches that 'directory' and not name of the baseName's |
|
101
|
//module. For instance, baseName of 'one/two/three', maps to |
|
102
|
//'one/two/three.js', but we want the directory, 'one/two' for |
|
103
|
//this normalization. |
|
104
|
normalizedBaseParts = baseParts.slice(0, baseParts.length - 1); |
|
105
|
name = normalizedBaseParts.concat(name); |
|
106
|
} |
|
107
|
|
|
108
|
//start trimDots |
|
109
|
for (i = 0; i < name.length; i++) { |
|
110
|
part = name[i]; |
|
111
|
if (part === '.') { |
|
112
|
name.splice(i, 1); |
|
113
|
i -= 1; |
|
114
|
} else if (part === '..') { |
|
115
|
// If at the start, or previous value is still .., |
|
116
|
// keep them so that when converted to a path it may |
|
117
|
// still work when converted to a path, even though |
|
118
|
// as an ID it is less than ideal. In larger point |
|
119
|
// releases, may be better to just kick out an error. |
|
120
|
if (i === 0 || (i === 1 && name[2] === '..') || name[i - 1] === '..') { |
|
121
|
continue; |
|
122
|
} else if (i > 0) { |
|
123
|
name.splice(i - 1, 2); |
|
124
|
i -= 2; |
|
125
|
} |
|
126
|
} |
|
127
|
} |
|
128
|
//end trimDots |
|
129
|
|
|
130
|
name = name.join('/'); |
|
131
|
} |
|
132
|
|
|
133
|
//Apply map config if available. |
|
134
|
if ((baseParts || starMap) && map) { |
|
135
|
nameParts = name.split('/'); |
|
136
|
|
|
137
|
for (i = nameParts.length; i > 0; i -= 1) { |
|
138
|
nameSegment = nameParts.slice(0, i).join("/"); |
|
139
|
|
|
140
|
if (baseParts) { |
|
141
|
//Find the longest baseName segment match in the config. |
|
142
|
//So, do joins on the biggest to smallest lengths of baseParts. |
|
143
|
for (j = baseParts.length; j > 0; j -= 1) { |
|
144
|
mapValue = map[baseParts.slice(0, j).join('/')]; |
|
145
|
|
|
146
|
//baseName segment has config, find if it has one for |
|
147
|
//this name. |
|
148
|
if (mapValue) { |
|
149
|
mapValue = mapValue[nameSegment]; |
|
150
|
if (mapValue) { |
|
151
|
//Match, update name to the new value. |
|
152
|
foundMap = mapValue; |
|
153
|
foundI = i; |
|
154
|
break; |
|
155
|
} |
|
156
|
} |
|
157
|
} |
|
158
|
} |
|
159
|
|
|
160
|
if (foundMap) { |
|
161
|
break; |
|
162
|
} |
|
163
|
|
|
164
|
//Check for a star map match, but just hold on to it, |
|
165
|
//if there is a shorter segment match later in a matching |
|
166
|
//config, then favor over this star map. |
|
167
|
if (!foundStarMap && starMap && starMap[nameSegment]) { |
|
168
|
foundStarMap = starMap[nameSegment]; |
|
169
|
starI = i; |
|
170
|
} |
|
171
|
} |
|
172
|
|
|
173
|
if (!foundMap && foundStarMap) { |
|
174
|
foundMap = foundStarMap; |
|
175
|
foundI = starI; |
|
176
|
} |
|
177
|
|
|
178
|
if (foundMap) { |
|
179
|
nameParts.splice(0, foundI, foundMap); |
|
180
|
name = nameParts.join('/'); |
|
181
|
} |
|
182
|
} |
|
183
|
|
|
184
|
return name; |
|
185
|
} |
|
186
|
|
|
187
|
function makeRequire(relName, forceSync) { |
|
188
|
return function () { |
|
189
|
//A version of a require function that passes a moduleName |
|
190
|
//value for items that may need to |
|
191
|
//look up paths relative to the moduleName |
|
192
|
var args = aps.call(arguments, 0); |
|
193
|
|
|
194
|
//If first arg is not require('string'), and there is only |
|
195
|
//one arg, it is the array form without a callback. Insert |
|
196
|
//a null so that the following concat is correct. |
|
197
|
if (typeof args[0] !== 'string' && args.length === 1) { |
|
198
|
args.push(null); |
|
199
|
} |
|
200
|
return req.apply(undef, args.concat([relName, forceSync])); |
|
201
|
}; |
|
202
|
} |
|
203
|
|
|
204
|
function makeNormalize(relName) { |
|
205
|
return function (name) { |
|
206
|
return normalize(name, relName); |
|
207
|
}; |
|
208
|
} |
|
209
|
|
|
210
|
function makeLoad(depName) { |
|
211
|
return function (value) { |
|
212
|
defined[depName] = value; |
|
213
|
}; |
|
214
|
} |
|
215
|
|
|
216
|
function callDep(name) { |
|
217
|
if (hasProp(waiting, name)) { |
|
218
|
var args = waiting[name]; |
|
219
|
delete waiting[name]; |
|
220
|
defining[name] = true; |
|
221
|
main.apply(undef, args); |
|
222
|
} |
|
223
|
|
|
224
|
if (!hasProp(defined, name) && !hasProp(defining, name)) { |
|
225
|
throw new Error('No ' + name); |
|
226
|
} |
|
227
|
return defined[name]; |
|
228
|
} |
|
229
|
|
|
230
|
//Turns a plugin!resource to [plugin, resource] |
|
231
|
//with the plugin being undefined if the name |
|
232
|
//did not have a plugin prefix. |
|
233
|
function splitPrefix(name) { |
|
234
|
var prefix, |
|
235
|
index = name ? name.indexOf('!') : -1; |
|
236
|
if (index > -1) { |
|
237
|
prefix = name.substring(0, index); |
|
238
|
name = name.substring(index + 1, name.length); |
|
239
|
} |
|
240
|
return [prefix, name]; |
|
241
|
} |
|
242
|
|
|
243
|
//Creates a parts array for a relName where first part is plugin ID, |
|
244
|
//second part is resource ID. Assumes relName has already been normalized. |
|
245
|
function makeRelParts(relName) { |
|
246
|
return relName ? splitPrefix(relName) : []; |
|
247
|
} |
|
248
|
|
|
249
|
/** |
|
250
|
* Makes a name map, normalizing the name, and using a plugin |
|
251
|
* for normalization if necessary. Grabs a ref to plugin |
|
252
|
* too, as an optimization. |
|
253
|
*/ |
|
254
|
makeMap = function (name, relParts) { |
|
255
|
var plugin, |
|
256
|
parts = splitPrefix(name), |
|
257
|
prefix = parts[0], |
|
258
|
relResourceName = relParts[1]; |
|
259
|
|
|
260
|
name = parts[1]; |
|
261
|
|
|
262
|
if (prefix) { |
|
263
|
prefix = normalize(prefix, relResourceName); |
|
264
|
plugin = callDep(prefix); |
|
265
|
} |
|
266
|
|
|
267
|
//Normalize according |
|
268
|
if (prefix) { |
|
269
|
if (plugin && plugin.normalize) { |
|
270
|
name = plugin.normalize(name, makeNormalize(relResourceName)); |
|
271
|
} else { |
|
272
|
name = normalize(name, relResourceName); |
|
273
|
} |
|
274
|
} else { |
|
275
|
name = normalize(name, relResourceName); |
|
276
|
parts = splitPrefix(name); |
|
277
|
prefix = parts[0]; |
|
278
|
name = parts[1]; |
|
279
|
if (prefix) { |
|
280
|
plugin = callDep(prefix); |
|
281
|
} |
|
282
|
} |
|
283
|
|
|
284
|
//Using ridiculous property names for space reasons |
|
285
|
return { |
|
286
|
f: prefix ? prefix + '!' + name : name, //fullName |
|
287
|
n: name, |
|
288
|
pr: prefix, |
|
289
|
p: plugin |
|
290
|
}; |
|
291
|
}; |
|
292
|
|
|
293
|
function makeConfig(name) { |
|
294
|
return function () { |
|
295
|
return (config && config.config && config.config[name]) || {}; |
|
296
|
}; |
|
297
|
} |
|
298
|
|
|
299
|
handlers = { |
|
300
|
require: function (name) { |
|
301
|
return makeRequire(name); |
|
302
|
}, |
|
303
|
exports: function (name) { |
|
304
|
var e = defined[name]; |
|
305
|
if (typeof e !== 'undefined') { |
|
306
|
return e; |
|
307
|
} else { |
|
308
|
return (defined[name] = {}); |
|
309
|
} |
|
310
|
}, |
|
311
|
module: function (name) { |
|
312
|
return { |
|
313
|
id: name, |
|
314
|
uri: '', |
|
315
|
exports: defined[name], |
|
316
|
config: makeConfig(name) |
|
317
|
}; |
|
318
|
} |
|
319
|
}; |
|
320
|
|
|
321
|
main = function (name, deps, callback, relName) { |
|
322
|
var cjsModule, depName, ret, map, i, relParts, |
|
323
|
args = [], |
|
324
|
callbackType = typeof callback, |
|
325
|
usingExports; |
|
326
|
|
|
327
|
//Use name if no relName |
|
328
|
relName = relName || name; |
|
329
|
relParts = makeRelParts(relName); |
|
330
|
|
|
331
|
//Call the callback to define the module, if necessary. |
|
332
|
if (callbackType === 'undefined' || callbackType === 'function') { |
|
333
|
//Pull out the defined dependencies and pass the ordered |
|
334
|
//values to the callback. |
|
335
|
//Default to [require, exports, module] if no deps |
|
336
|
deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps; |
|
337
|
for (i = 0; i < deps.length; i += 1) { |
|
338
|
map = makeMap(deps[i], relParts); |
|
339
|
depName = map.f; |
|
340
|
|
|
341
|
//Fast path CommonJS standard dependencies. |
|
342
|
if (depName === "require") { |
|
343
|
args[i] = handlers.require(name); |
|
344
|
} else if (depName === "exports") { |
|
345
|
//CommonJS module spec 1.1 |
|
346
|
args[i] = handlers.exports(name); |
|
347
|
usingExports = true; |
|
348
|
} else if (depName === "module") { |
|
349
|
//CommonJS module spec 1.1 |
|
350
|
cjsModule = args[i] = handlers.module(name); |
|
351
|
} else if (hasProp(defined, depName) || |
|
352
|
hasProp(waiting, depName) || |
|
353
|
hasProp(defining, depName)) { |
|
354
|
args[i] = callDep(depName); |
|
355
|
} else if (map.p) { |
|
356
|
map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {}); |
|
357
|
args[i] = defined[depName]; |
|
358
|
} else { |
|
359
|
throw new Error(name + ' missing ' + depName); |
|
360
|
} |
|
361
|
} |
|
362
|
|
|
363
|
ret = callback ? callback.apply(defined[name], args) : undefined; |
|
364
|
|
|
365
|
if (name) { |
|
366
|
//If setting exports via "module" is in play, |
|
367
|
//favor that over return value and exports. After that, |
|
368
|
//favor a non-undefined return value over exports use. |
|
369
|
if (cjsModule && cjsModule.exports !== undef && |
|
370
|
cjsModule.exports !== defined[name]) { |
|
371
|
defined[name] = cjsModule.exports; |
|
372
|
} else if (ret !== undef || !usingExports) { |
|
373
|
//Use the return value from the function. |
|
374
|
defined[name] = ret; |
|
375
|
} |
|
376
|
} |
|
377
|
} else if (name) { |
|
378
|
//May just be an object definition for the module. Only |
|
379
|
//worry about defining if have a module name. |
|
380
|
defined[name] = callback; |
|
381
|
} |
|
382
|
}; |
|
383
|
|
|
384
|
requirejs = require = req = function (deps, callback, relName, forceSync, alt) { |
|
385
|
if (typeof deps === "string") { |
|
386
|
if (handlers[deps]) { |
|
387
|
//callback in this case is really relName |
|
388
|
return handlers[deps](callback); |
|
389
|
} |
|
390
|
//Just return the module wanted. In this scenario, the |
|
391
|
//deps arg is the module name, and second arg (if passed) |
|
392
|
//is just the relName. |
|
393
|
//Normalize module name, if it contains . or .. |
|
394
|
return callDep(makeMap(deps, makeRelParts(callback)).f); |
|
395
|
} else if (!deps.splice) { |
|
396
|
//deps is a config object, not an array. |
|
397
|
config = deps; |
|
398
|
if (config.deps) { |
|
399
|
req(config.deps, config.callback); |
|
400
|
} |
|
401
|
if (!callback) { |
|
402
|
return; |
|
403
|
} |
|
404
|
|
|
405
|
if (callback.splice) { |
|
406
|
//callback is an array, which means it is a dependency list. |
|
407
|
//Adjust args if there are dependencies |
|
408
|
deps = callback; |
|
409
|
callback = relName; |
|
410
|
relName = null; |
|
411
|
} else { |
|
412
|
deps = undef; |
|
413
|
} |
|
414
|
} |
|
415
|
|
|
416
|
//Support require(['a']) |
|
417
|
callback = callback || function () {}; |
|
418
|
|
|
419
|
//If relName is a function, it is an errback handler, |
|
420
|
//so remove it. |
|
421
|
if (typeof relName === 'function') { |
|
422
|
relName = forceSync; |
|
423
|
forceSync = alt; |
|
424
|
} |
|
425
|
|
|
426
|
//Simulate async callback; |
|
427
|
if (forceSync) { |
|
428
|
main(undef, deps, callback, relName); |
|
429
|
} else { |
|
430
|
//Using a non-zero value because of concern for what old browsers |
|
431
|
//do, and latest browsers "upgrade" to 4 if lower value is used: |
|
432
|
//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout: |
|
433
|
//If want a value immediately, use require('id') instead -- something |
|
434
|
//that works in almond on the global level, but not guaranteed and |
|
435
|
//unlikely to work in other AMD implementations. |
|
436
|
setTimeout(function () { |
|
437
|
main(undef, deps, callback, relName); |
|
438
|
}, 4); |
|
439
|
} |
|
440
|
|
|
441
|
return req; |
|
442
|
}; |
|
443
|
|
|
444
|
/** |
|
445
|
* Just drops the config on the floor, but returns req in case |
|
446
|
* the config return value is used. |
|
447
|
*/ |
|
448
|
req.config = function (cfg) { |
|
449
|
return req(cfg); |
|
450
|
}; |
|
451
|
|
|
452
|
/** |
|
453
|
* Expose module registry for debugging and tooling |
|
454
|
*/ |
|
455
|
requirejs._defined = defined; |
|
456
|
|
|
457
|
define = function (name, deps, callback) { |
|
458
|
if (typeof name !== 'string') { |
|
459
|
throw new Error('See almond README: incorrect module build, no module name'); |
|
460
|
} |
|
461
|
|
|
462
|
//This module may not have dependencies |
|
463
|
if (!deps.splice) { |
|
464
|
//deps is not an array, so probably means |
|
465
|
//an object literal or factory function for |
|
466
|
//the value. Adjust args. |
|
467
|
callback = deps; |
|
468
|
deps = []; |
|
469
|
} |
|
470
|
|
|
471
|
if (!hasProp(defined, name) && !hasProp(waiting, name)) { |
|
472
|
waiting[name] = [name, deps, callback]; |
|
473
|
} |
|
474
|
}; |
|
475
|
|
|
476
|
define.amd = { |
|
477
|
jQuery: true |
|
478
|
}; |
|
479
|
}()); |
|
480
|
|
|
481
|
S2.requirejs = requirejs;S2.require = require;S2.define = define; |
|
482
|
} |
|
483
|
}()); |
|
484
|
S2.define("almond", function(){}); |
|
485
|
|
|
486
|
/* global jQuery:false, $:false */ |
|
487
|
S2.define('jquery',[],function () { |
|
488
|
var _$ = jQuery || $; |
|
489
|
|
|
490
|
if (_$ == null && console && console.error) { |
|
491
|
console.error( |
|
492
|
'Select2: An instance of jQuery or a jQuery-compatible library was not ' + |
|
493
|
'found. Make sure that you are including jQuery before Select2 on your ' + |
|
494
|
'web page.' |
|
495
|
); |
|
496
|
} |
|
497
|
|
|
498
|
return _$; |
|
499
|
}); |
|
500
|
|
|
501
|
S2.define('select2/utils',[ |
|
502
|
'jquery' |
|
503
|
], function ($) { |
|
504
|
var Utils = {}; |
|
505
|
|
|
506
|
Utils.Extend = function (ChildClass, SuperClass) { |
|
507
|
var __hasProp = {}.hasOwnProperty; |
|
508
|
|
|
509
|
function BaseConstructor () { |
|
510
|
this.constructor = ChildClass; |
|
511
|
} |
|
512
|
|
|
513
|
for (var key in SuperClass) { |
|
514
|
if (__hasProp.call(SuperClass, key)) { |
|
515
|
ChildClass[key] = SuperClass[key]; |
|
516
|
} |
|
517
|
} |
|
518
|
|
|
519
|
BaseConstructor.prototype = SuperClass.prototype; |
|
520
|
ChildClass.prototype = new BaseConstructor(); |
|
521
|
ChildClass.__super__ = SuperClass.prototype; |
|
522
|
|
|
523
|
return ChildClass; |
|
524
|
}; |
|
525
|
|
|
526
|
function getMethods (theClass) { |
|
527
|
var proto = theClass.prototype; |
|
528
|
|
|
529
|
var methods = []; |
|
530
|
|
|
531
|
for (var methodName in proto) { |
|
532
|
var m = proto[methodName]; |
|
533
|
|
|
534
|
if (typeof m !== 'function') { |
|
535
|
continue; |
|
536
|
} |
|
537
|
|
|
538
|
if (methodName === 'constructor') { |
|
539
|
continue; |
|
540
|
} |
|
541
|
|
|
542
|
methods.push(methodName); |
|
543
|
} |
|
544
|
|
|
545
|
return methods; |
|
546
|
} |
|
547
|
|
|
548
|
Utils.Decorate = function (SuperClass, DecoratorClass) { |
|
549
|
var decoratedMethods = getMethods(DecoratorClass); |
|
550
|
var superMethods = getMethods(SuperClass); |
|
551
|
|
|
552
|
function DecoratedClass () { |
|
553
|
var unshift = Array.prototype.unshift; |
|
554
|
|
|
555
|
var argCount = DecoratorClass.prototype.constructor.length; |
|
556
|
|
|
557
|
var calledConstructor = SuperClass.prototype.constructor; |
|
558
|
|
|
559
|
if (argCount > 0) { |
|
560
|
unshift.call(arguments, SuperClass.prototype.constructor); |
|
561
|
|
|
562
|
calledConstructor = DecoratorClass.prototype.constructor; |
|
563
|
} |
|
564
|
|
|
565
|
calledConstructor.apply(this, arguments); |
|
566
|
} |
|
567
|
|
|
568
|
DecoratorClass.displayName = SuperClass.displayName; |
|
569
|
|
|
570
|
function ctr () { |
|
571
|
this.constructor = DecoratedClass; |
|
572
|
} |
|
573
|
|
|
574
|
DecoratedClass.prototype = new ctr(); |
|
575
|
|
|
576
|
for (var m = 0; m < superMethods.length; m++) { |
|
577
|
var superMethod = superMethods[m]; |
|
578
|
|
|
579
|
DecoratedClass.prototype[superMethod] = |
|
580
|
SuperClass.prototype[superMethod]; |
|
581
|
} |
|
582
|
|
|
583
|
var calledMethod = function (methodName) { |
|
584
|
// Stub out the original method if it's not decorating an actual method |
|
585
|
var originalMethod = function () {}; |
|
586
|
|
|
587
|
if (methodName in DecoratedClass.prototype) { |
|
588
|
originalMethod = DecoratedClass.prototype[methodName]; |
|
589
|
} |
|
590
|
|
|
591
|
var decoratedMethod = DecoratorClass.prototype[methodName]; |
|
592
|
|
|
593
|
return function () { |
|
594
|
var unshift = Array.prototype.unshift; |
|
595
|
|
|
596
|
unshift.call(arguments, originalMethod); |
|
597
|
|
|
598
|
return decoratedMethod.apply(this, arguments); |
|
599
|
}; |
|
600
|
}; |
|
601
|
|
|
602
|
for (var d = 0; d < decoratedMethods.length; d++) { |
|
603
|
var decoratedMethod = decoratedMethods[d]; |
|
604
|
|
|
605
|
DecoratedClass.prototype[decoratedMethod] = calledMethod(decoratedMethod); |
|
606
|
} |
|
607
|
|
|
608
|
return DecoratedClass; |
|
609
|
}; |
|
610
|
|
|
611
|
var Observable = function () { |
|
612
|
this.listeners = {}; |
|
613
|
}; |
|
614
|
|
|
615
|
Observable.prototype.on = function (event, callback) { |
|
616
|
this.listeners = this.listeners || {}; |
|
617
|
|
|
618
|
if (event in this.listeners) { |
|
619
|
this.listeners[event].push(callback); |
|
620
|
} else { |
|
621
|
this.listeners[event] = [callback]; |
|
622
|
} |
|
623
|
}; |
|
624
|
|
|
625
|
Observable.prototype.trigger = function (event) { |
|
626
|
var slice = Array.prototype.slice; |
|
627
|
var params = slice.call(arguments, 1); |
|
628
|
|
|
629
|
this.listeners = this.listeners || {}; |
|
630
|
|
|
631
|
// Params should always come in as an array |
|
632
|
if (params == null) { |
|
633
|
params = []; |
|
634
|
} |
|
635
|
|
|
636
|
// If there are no arguments to the event, use a temporary object |
|
637
|
if (params.length === 0) { |
|
638
|
params.push({}); |
|
639
|
} |
|
640
|
|
|
641
|
// Set the `_type` of the first object to the event |
|
642
|
params[0]._type = event; |
|
643
|
|
|
644
|
if (event in this.listeners) { |
|
645
|
this.invoke(this.listeners[event], slice.call(arguments, 1)); |
|
646
|
} |
|
647
|
|
|
648
|
if ('*' in this.listeners) { |
|
649
|
this.invoke(this.listeners['*'], arguments); |
|
650
|
} |
|
651
|
}; |
|
652
|
|
|
653
|
Observable.prototype.invoke = function (listeners, params) { |
|
654
|
for (var i = 0, len = listeners.length; i < len; i++) { |
|
655
|
listeners[i].apply(this, params); |
|
656
|
} |
|
657
|
}; |
|
658
|
|
|
659
|
Utils.Observable = Observable; |
|
660
|
|
|
661
|
Utils.generateChars = function (length) { |
|
662
|
var chars = ''; |
|
663
|
|
|
664
|
for (var i = 0; i < length; i++) { |
|
665
|
var randomChar = Math.floor(Math.random() * 36); |
|
666
|
chars += randomChar.toString(36); |
|
667
|
} |
|
668
|
|
|
669
|
return chars; |
|
670
|
}; |
|
671
|
|
|
672
|
Utils.bind = function (func, context) { |
|
673
|
return function () { |
|
674
|
func.apply(context, arguments); |
|
675
|
}; |
|
676
|
}; |
|
677
|
|
|
678
|
Utils._convertData = function (data) { |
|
679
|
for (var originalKey in data) { |
|
680
|
var keys = originalKey.split('-'); |
|
681
|
|
|
682
|
var dataLevel = data; |
|
683
|
|
|
684
|
if (keys.length === 1) { |
|
685
|
continue; |
|
686
|
} |
|
687
|
|
|
688
|
for (var k = 0; k < keys.length; k++) { |
|
689
|
var key = keys[k]; |
|
690
|
|
|
691
|
// Lowercase the first letter |
|
692
|
// By default, dash-separated becomes camelCase |
|
693
|
key = key.substring(0, 1).toLowerCase() + key.substring(1); |
|
694
|
|
|
695
|
if (!(key in dataLevel)) { |
|
696
|
dataLevel[key] = {}; |
|
697
|
} |
|
698
|
|
|
699
|
if (k == keys.length - 1) { |
|
700
|
dataLevel[key] = data[originalKey]; |
|
701
|
} |
|
702
|
|
|
703
|
dataLevel = dataLevel[key]; |
|
704
|
} |
|
705
|
|
|
706
|
delete data[originalKey]; |
|
707
|
} |
|
708
|
|
|
709
|
return data; |
|
710
|
}; |
|
711
|
|
|
712
|
Utils.hasScroll = function (index, el) { |
|
713
|
// Adapted from the function created by @ShadowScripter |
|
714
|
// and adapted by @BillBarry on the Stack Exchange Code Review website. |
|
715
|
// The original code can be found at |
|
716
|
// http://codereview.stackexchange.com/q/13338 |
|
717
|
// and was designed to be used with the Sizzle selector engine. |
|
718
|
|
|
719
|
var $el = $(el); |
|
720
|
var overflowX = el.style.overflowX; |
|
721
|
var overflowY = el.style.overflowY; |
|
722
|
|
|
723
|
//Check both x and y declarations |
|
724
|
if (overflowX === overflowY && |
|
725
|
(overflowY === 'hidden' || overflowY === 'visible')) { |
|
726
|
return false; |
|
727
|
} |
|
728
|
|
|
729
|
if (overflowX === 'scroll' || overflowY === 'scroll') { |
|
730
|
return true; |
|
731
|
} |
|
732
|
|
|
733
|
return ($el.innerHeight() < el.scrollHeight || |
|
734
|
$el.innerWidth() < el.scrollWidth); |
|
735
|
}; |
|
736
|
|
|
737
|
Utils.escapeMarkup = function (markup) { |
|
738
|
var replaceMap = { |
|
739
|
'\\': '\', |
|
740
|
'&': '&', |
|
741
|
'<': '<', |
|
742
|
'>': '>', |
|
743
|
'"': '"', |
|
744
|
'\'': ''', |
|
745
|
'/': '/' |
|
746
|
}; |
|
747
|
|
|
748
|
// Do not try to escape the markup if it's not a string |
|
749
|
if (typeof markup !== 'string') { |
|
750
|
return markup; |
|
751
|
} |
|
752
|
|
|
753
|
return String(markup).replace(/[&<>"'\/\\]/g, function (match) { |
|
754
|
return replaceMap[match]; |
|
755
|
}); |
|
756
|
}; |
|
757
|
|
|
758
|
// Append an array of jQuery nodes to a given element. |
|
759
|
Utils.appendMany = function ($element, $nodes) { |
|
760
|
// jQuery 1.7.x does not support $.fn.append() with an array |
|
761
|
// Fall back to a jQuery object collection using $.fn.add() |
|
762
|
if ($.fn.jquery.substr(0, 3) === '1.7') { |
|
763
|
var $jqNodes = $(); |
|
764
|
|
|
765
|
$.map($nodes, function (node) { |
|
766
|
$jqNodes = $jqNodes.add(node); |
|
767
|
}); |
|
768
|
|
|
769
|
$nodes = $jqNodes; |
|
770
|
} |
|
771
|
|
|
772
|
$element.append($nodes); |
|
773
|
}; |
|
774
|
|
|
775
|
// Cache objects in Utils.__cache instead of $.data (see #4346) |
|
776
|
Utils.__cache = {}; |
|
777
|
|
|
778
|
var id = 0; |
|
779
|
Utils.GetUniqueElementId = function (element) { |
|
780
|
// Get a unique element Id. If element has no id, |
|
781
|
// creates a new unique number, stores it in the id |
|
782
|
// attribute and returns the new id. |
|
783
|
// If an id already exists, it simply returns it. |
|
784
|
|
|
785
|
var select2Id = element.getAttribute('data-select2-id'); |
|
786
|
if (select2Id == null) { |
|
787
|
// If element has id, use it. |
|
788
|
if (element.id) { |
|
789
|
select2Id = element.id; |
|
790
|
element.setAttribute('data-select2-id', select2Id); |
|
791
|
} else { |
|
792
|
element.setAttribute('data-select2-id', ++id); |
|
793
|
select2Id = id.toString(); |
|
794
|
} |
|
795
|
} |
|
796
|
return select2Id; |
|
797
|
}; |
|
798
|
|
|
799
|
Utils.StoreData = function (element, name, value) { |
|
800
|
// Stores an item in the cache for a specified element. |
|
801
|
// name is the cache key. |
|
802
|
var id = Utils.GetUniqueElementId(element); |
|
803
|
if (!Utils.__cache[id]) { |
|
804
|
Utils.__cache[id] = {}; |
|
805
|
} |
|
806
|
|
|
807
|
Utils.__cache[id][name] = value; |
|
808
|
}; |
|
809
|
|
|
810
|
Utils.GetData = function (element, name) { |
|
811
|
// Retrieves a value from the cache by its key (name) |
|
812
|
// name is optional. If no name specified, return |
|
813
|
// all cache items for the specified element. |
|
814
|
// and for a specified element. |
|
815
|
var id = Utils.GetUniqueElementId(element); |
|
816
|
if (name) { |
|
817
|
if (Utils.__cache[id]) { |
|
818
|
if (Utils.__cache[id][name] != null) { |
|
819
|
return Utils.__cache[id][name]; |
|
820
|
} |
|
821
|
return $(element).data(name); // Fallback to HTML5 data attribs. |
|
822
|
} |
|
823
|
return $(element).data(name); // Fallback to HTML5 data attribs. |
|
824
|
} else { |
|
825
|
return Utils.__cache[id]; |
|
826
|
} |
|
827
|
}; |
|
828
|
|
|
829
|
Utils.RemoveData = function (element) { |
|
830
|
// Removes all cached items for a specified element. |
|
831
|
var id = Utils.GetUniqueElementId(element); |
|
832
|
if (Utils.__cache[id] != null) { |
|
833
|
delete Utils.__cache[id]; |
|
834
|
} |
|
835
|
|
|
836
|
element.removeAttribute('data-select2-id'); |
|
837
|
}; |
|
838
|
|
|
839
|
return Utils; |
|
840
|
}); |
|
841
|
|
|
842
|
S2.define('select2/results',[ |
|
843
|
'jquery', |
|
844
|
'./utils' |
|
845
|
], function ($, Utils) { |
|
846
|
function Results ($element, options, dataAdapter) { |
|
847
|
this.$element = $element; |
|
848
|
this.data = dataAdapter; |
|
849
|
this.options = options; |
|
850
|
|
|
851
|
Results.__super__.constructor.call(this); |
|
852
|
} |
|
853
|
|
|
854
|
Utils.Extend(Results, Utils.Observable); |
|
855
|
|
|
856
|
Results.prototype.render = function () { |
|
857
|
var $results = $( |
|
858
|
'<ul class="select2-results__options" role="listbox"></ul>' |
|
859
|
); |
|
860
|
|
|
861
|
if (this.options.get('multiple')) { |
|
862
|
$results.attr('aria-multiselectable', 'true'); |
|
863
|
} |
|
864
|
|
|
865
|
this.$results = $results; |
|
866
|
|
|
867
|
return $results; |
|
868
|
}; |
|
869
|
|
|
870
|
Results.prototype.clear = function () { |
|
871
|
this.$results.empty(); |
|
872
|
}; |
|
873
|
|
|
874
|
Results.prototype.displayMessage = function (params) { |
|
875
|
var escapeMarkup = this.options.get('escapeMarkup'); |
|
876
|
|
|
877
|
this.clear(); |
|
878
|
this.hideLoading(); |
|
879
|
|
|
880
|
var $message = $( |
|
881
|
'<li role="alert" aria-live="assertive"' + |
|
882
|
' class="select2-results__option"></li>' |
|
883
|
); |
|
884
|
|
|
885
|
var message = this.options.get('translations').get(params.message); |
|
886
|
|
|
887
|
$message.append( |
|
888
|
escapeMarkup( |
|
889
|
message(params.args) |
|
890
|
) |
|
891
|
); |
|
892
|
|
|
893
|
$message[0].className += ' select2-results__message'; |
|
894
|
|
|
895
|
this.$results.append($message); |
|
896
|
}; |
|
897
|
|
|
898
|
Results.prototype.hideMessages = function () { |
|
899
|
this.$results.find('.select2-results__message').remove(); |
|
900
|
}; |
|
901
|
|
|
902
|
Results.prototype.append = function (data) { |
|
903
|
this.hideLoading(); |
|
904
|
|
|
905
|
var $options = []; |
|
906
|
|
|
907
|
if (data.results == null || data.results.length === 0) { |
|
908
|
if (this.$results.children().length === 0) { |
|
909
|
this.trigger('results:message', { |
|
910
|
message: 'noResults' |
|
911
|
}); |
|
912
|
} |
|
913
|
|
|
914
|
return; |
|
915
|
} |
|
916
|
|
|
917
|
data.results = this.sort(data.results); |
|
918
|
|
|
919
|
for (var d = 0; d < data.results.length; d++) { |
|
920
|
var item = data.results[d]; |
|
921
|
|
|
922
|
var $option = this.option(item); |
|
923
|
|
|
924
|
$options.push($option); |
|
925
|
} |
|
926
|
|
|
927
|
this.$results.append($options); |
|
928
|
}; |
|
929
|
|
|
930
|
Results.prototype.position = function ($results, $dropdown) { |
|
931
|
var $resultsContainer = $dropdown.find('.select2-results'); |
|
932
|
$resultsContainer.append($results); |
|
933
|
}; |
|
934
|
|
|
935
|
Results.prototype.sort = function (data) { |
|
936
|
var sorter = this.options.get('sorter'); |
|
937
|
|
|
938
|
return sorter(data); |
|
939
|
}; |
|
940
|
|
|
941
|
Results.prototype.highlightFirstItem = function () { |
|
942
|
var $options = this.$results |
|
943
|
.find('.select2-results__option[aria-selected]'); |
|
944
|
|
|
945
|
var $selected = $options.filter('[aria-selected=true]'); |
|
946
|
|
|
947
|
// Check if there are any selected options |
|
948
|
if ($selected.length > 0) { |
|
949
|
// If there are selected options, highlight the first |
|
950
|
$selected.first().trigger('mouseenter'); |
|
951
|
} else { |
|
952
|
// If there are no selected options, highlight the first option |
|
953
|
// in the dropdown |
|
954
|
$options.first().trigger('mouseenter'); |
|
955
|
} |
|
956
|
|
|
957
|
this.ensureHighlightVisible(); |
|
958
|
}; |
|
959
|
|
|
960
|
Results.prototype.setClasses = function () { |
|
961
|
var self = this; |
|
962
|
|
|
963
|
this.data.current(function (selected) { |
|
964
|
var selectedIds = $.map(selected, function (s) { |
|
965
|
return s.id.toString(); |
|
966
|
}); |
|
967
|
|
|
968
|
var $options = self.$results |
|
969
|
.find('.select2-results__option[aria-selected]'); |
|
970
|
|
|
971
|
$options.each(function () { |
|
972
|
var $option = $(this); |
|
973
|
|
|
974
|
var item = Utils.GetData(this, 'data'); |
|
975
|
|
|
976
|
// id needs to be converted to a string when comparing |
|
977
|
var id = '' + item.id; |
|
978
|
|
|
979
|
if ((item.element != null && item.element.selected) || |
|
980
|
(item.element == null && $.inArray(id, selectedIds) > -1)) { |
|
981
|
$option.attr('aria-selected', 'true'); |
|
982
|
} else { |
|
983
|
$option.attr('aria-selected', 'false'); |
|
984
|
} |
|
985
|
}); |
|
986
|
|
|
987
|
}); |
|
988
|
}; |
|
989
|
|
|
990
|
Results.prototype.showLoading = function (params) { |
|
991
|
this.hideLoading(); |
|
992
|
|
|
993
|
var loadingMore = this.options.get('translations').get('searching'); |
|
994
|
|
|
995
|
var loading = { |
|
996
|
disabled: true, |
|
997
|
loading: true, |
|
998
|
text: loadingMore(params) |
|
999
|
}; |
|
1000
|
var $loading = this.option(loading); |
|
1001
|
$loading.className += ' loading-results'; |
|
1002
|
|
|
1003
|
this.$results.prepend($loading); |
|
1004
|
}; |
|
1005
|
|
|
1006
|
Results.prototype.hideLoading = function () { |
|
1007
|
this.$results.find('.loading-results').remove(); |
|
1008
|
}; |
|
1009
|
|
|
1010
|
Results.prototype.option = function (data) { |
|
1011
|
var option = document.createElement('li'); |
|
1012
|
option.className = 'select2-results__option'; |
|
1013
|
|
|
1014
|
var attrs = { |
|
1015
|
'role': 'option', |
|
1016
|
'aria-selected': 'false' |
|
1017
|
}; |
|
1018
|
|
|
1019
|
var matches = window.Element.prototype.matches || |
|
1020
|
window.Element.prototype.msMatchesSelector || |
|
1021
|
window.Element.prototype.webkitMatchesSelector; |
|
1022
|
|
|
1023
|
if ((data.element != null && matches.call(data.element, ':disabled')) || |
|
1024
|
(data.element == null && data.disabled)) { |
|
1025
|
delete attrs['aria-selected']; |
|
1026
|
attrs['aria-disabled'] = 'true'; |
|
1027
|
} |
|
1028
|
|
|
1029
|
if (data.id == null) { |
|
1030
|
delete attrs['aria-selected']; |
|
1031
|
} |
|
1032
|
|
|
1033
|
if (data._resultId != null) { |
|
1034
|
option.id = data._resultId; |
|
1035
|
} |
|
1036
|
|
|
1037
|
if (data.title) { |
|
1038
|
option.title = data.title; |
|
1039
|
} |
|
1040
|
|
|
1041
|
if (data.children) { |
|
1042
|
attrs.role = 'group'; |
|
1043
|
attrs['aria-label'] = data.text; |
|
1044
|
delete attrs['aria-selected']; |
|
1045
|
} |
|
1046
|
|
|
1047
|
for (var attr in attrs) { |
|
1048
|
var val = attrs[attr]; |
|
1049
|
|
|
1050
|
option.setAttribute(attr, val); |
|
1051
|
} |
|
1052
|
|
|
1053
|
if (data.children) { |
|
1054
|
var $option = $(option); |
|
1055
|
|
|
1056
|
var label = document.createElement('strong'); |
|
1057
|
label.className = 'select2-results__group'; |
|
1058
|
|
|
1059
|
var $label = $(label); |
|
1060
|
this.template(data, label); |
|
1061
|
|
|
1062
|
var $children = []; |
|
1063
|
|
|
1064
|
for (var c = 0; c < data.children.length; c++) { |
|
1065
|
var child = data.children[c]; |
|
1066
|
|
|
1067
|
var $child = this.option(child); |
|
1068
|
|
|
1069
|
$children.push($child); |
|
1070
|
} |
|
1071
|
|
|
1072
|
var $childrenContainer = $('<ul></ul>', { |
|
1073
|
'class': 'select2-results__options select2-results__options--nested' |
|
1074
|
}); |
|
1075
|
|
|
1076
|
$childrenContainer.append($children); |
|
1077
|
|
|
1078
|
$option.append(label); |
|
1079
|
$option.append($childrenContainer); |
|
1080
|
} else { |
|
1081
|
this.template(data, option); |
|
1082
|
} |
|
1083
|
|
|
1084
|
Utils.StoreData(option, 'data', data); |
|
1085
|
|
|
1086
|
return option; |
|
1087
|
}; |
|
1088
|
|
|
1089
|
Results.prototype.bind = function (container, $container) { |
|
1090
|
var self = this; |
|
1091
|
|
|
1092
|
var id = container.id + '-results'; |
|
1093
|
|
|
1094
|
this.$results.attr('id', id); |
|
1095
|
|
|
1096
|
container.on('results:all', function (params) { |
|
1097
|
self.clear(); |
|
1098
|
self.append(params.data); |
|
1099
|
|
|
1100
|
if (container.isOpen()) { |
|
1101
|
self.setClasses(); |
|
1102
|
self.highlightFirstItem(); |
|
1103
|
} |
|
1104
|
}); |
|
1105
|
|
|
1106
|
container.on('results:append', function (params) { |
|
1107
|
self.append(params.data); |
|
1108
|
|
|
1109
|
if (container.isOpen()) { |
|
1110
|
self.setClasses(); |
|
1111
|
} |
|
1112
|
}); |
|
1113
|
|
|
1114
|
container.on('query', function (params) { |
|
1115
|
self.hideMessages(); |
|
1116
|
self.showLoading(params); |
|
1117
|
}); |
|
1118
|
|
|
1119
|
container.on('select', function () { |
|
1120
|
if (!container.isOpen()) { |
|
1121
|
return; |
|
1122
|
} |
|
1123
|
|
|
1124
|
self.setClasses(); |
|
1125
|
|
|
1126
|
if (self.options.get('scrollAfterSelect')) { |
|
1127
|
self.highlightFirstItem(); |
|
1128
|
} |
|
1129
|
}); |
|
1130
|
|
|
1131
|
container.on('unselect', function () { |
|
1132
|
if (!container.isOpen()) { |
|
1133
|
return; |
|
1134
|
} |
|
1135
|
|
|
1136
|
self.setClasses(); |
|
1137
|
|
|
1138
|
if (self.options.get('scrollAfterSelect')) { |
|
1139
|
self.highlightFirstItem(); |
|
1140
|
} |
|
1141
|
}); |
|
1142
|
|
|
1143
|
container.on('open', function () { |
|
1144
|
// When the dropdown is open, aria-expended="true" |
|
1145
|
self.$results.attr('aria-expanded', 'true'); |
|
1146
|
self.$results.attr('aria-hidden', 'false'); |
|
1147
|
|
|
1148
|
self.setClasses(); |
|
1149
|
self.ensureHighlightVisible(); |
|
1150
|
}); |
|
1151
|
|
|
1152
|
container.on('close', function () { |
|
1153
|
// When the dropdown is closed, aria-expended="false" |
|
1154
|
self.$results.attr('aria-expanded', 'false'); |
|
1155
|
self.$results.attr('aria-hidden', 'true'); |
|
1156
|
self.$results.removeAttr('aria-activedescendant'); |
|
1157
|
}); |
|
1158
|
|
|
1159
|
container.on('results:toggle', function () { |
|
1160
|
var $highlighted = self.getHighlightedResults(); |
|
1161
|
|
|
1162
|
if ($highlighted.length === 0) { |
|
1163
|
return; |
|
1164
|
} |
|
1165
|
|
|
1166
|
$highlighted.trigger('mouseup'); |
|
1167
|
}); |
|
1168
|
|
|
1169
|
container.on('results:select', function () { |
|
1170
|
var $highlighted = self.getHighlightedResults(); |
|
1171
|
|
|
1172
|
if ($highlighted.length === 0) { |
|
1173
|
return; |
|
1174
|
} |
|
1175
|
|
|
1176
|
var data = Utils.GetData($highlighted[0], 'data'); |
|
1177
|
|
|
1178
|
if ($highlighted.attr('aria-selected') == 'true') { |
|
1179
|
self.trigger('close', {}); |
|
1180
|
} else { |
|
1181
|
self.trigger('select', { |
|
1182
|
data: data |
|
1183
|
}); |
|
1184
|
} |
|
1185
|
}); |
|
1186
|
|
|
1187
|
container.on('results:previous', function () { |
|
1188
|
var $highlighted = self.getHighlightedResults(); |
|
1189
|
|
|
1190
|
var $options = self.$results.find('[aria-selected]'); |
|
1191
|
|
|
1192
|
var currentIndex = $options.index($highlighted); |
|
1193
|
|
|
1194
|
// If we are already at the top, don't move further |
|
1195
|
// If no options, currentIndex will be -1 |
|
1196
|
if (currentIndex <= 0) { |
|
1197
|
return; |
|
1198
|
} |
|
1199
|
|
|
1200
|
var nextIndex = currentIndex - 1; |
|
1201
|
|
|
1202
|
// If none are highlighted, highlight the first |
|
1203
|
if ($highlighted.length === 0) { |
|
1204
|
nextIndex = 0; |
|
1205
|
} |
|
1206
|
|
|
1207
|
var $next = $options.eq(nextIndex); |
|
1208
|
|
|
1209
|
$next.trigger('mouseenter'); |
|
1210
|
|
|
1211
|
var currentOffset = self.$results.offset().top; |
|
1212
|
var nextTop = $next.offset().top; |
|
1213
|
var nextOffset = self.$results.scrollTop() + (nextTop - currentOffset); |
|
1214
|
|
|
1215
|
if (nextIndex === 0) { |
|
1216
|
self.$results.scrollTop(0); |
|
1217
|
} else if (nextTop - currentOffset < 0) { |
|
1218
|
self.$results.scrollTop(nextOffset); |
|
1219
|
} |
|
1220
|
}); |
|
1221
|
|
|
1222
|
container.on('results:next', function () { |
|
1223
|
var $highlighted = self.getHighlightedResults(); |
|
1224
|
|
|
1225
|
var $options = self.$results.find('[aria-selected]'); |
|
1226
|
|
|
1227
|
var currentIndex = $options.index($highlighted); |
|
1228
|
|
|
1229
|
var nextIndex = currentIndex + 1; |
|
1230
|
|
|
1231
|
// If we are at the last option, stay there |
|
1232
|
if (nextIndex >= $options.length) { |
|
1233
|
return; |
|
1234
|
} |
|
1235
|
|
|
1236
|
var $next = $options.eq(nextIndex); |
|
1237
|
|
|
1238
|
$next.trigger('mouseenter'); |
|
1239
|
|
|
1240
|
var currentOffset = self.$results.offset().top + |
|
1241
|
self.$results.outerHeight(false); |
|
1242
|
var nextBottom = $next.offset().top + $next.outerHeight(false); |
|
1243
|
var nextOffset = self.$results.scrollTop() + nextBottom - currentOffset; |
|
1244
|
|
|
1245
|
if (nextIndex === 0) { |
|
1246
|
self.$results.scrollTop(0); |
|
1247
|
} else if (nextBottom > currentOffset) { |
|
1248
|
self.$results.scrollTop(nextOffset); |
|
1249
|
} |
|
1250
|
}); |
|
1251
|
|
|
1252
|
container.on('results:focus', function (params) { |
|
1253
|
params.element.addClass('select2-results__option--highlighted'); |
|
1254
|
}); |
|
1255
|
|
|
1256
|
container.on('results:message', function (params) { |
|
1257
|
self.displayMessage(params); |
|
1258
|
}); |
|
1259
|
|
|
1260
|
if ($.fn.mousewheel) { |
|
1261
|
this.$results.on('mousewheel', function (e) { |
|
1262
|
var top = self.$results.scrollTop(); |
|
1263
|
|
|
1264
|
var bottom = self.$results.get(0).scrollHeight - top + e.deltaY; |
|
1265
|
|
|
1266
|
var isAtTop = e.deltaY > 0 && top - e.deltaY <= 0; |
|
1267
|
var isAtBottom = e.deltaY < 0 && bottom <= self.$results.height(); |
|
1268
|
|
|
1269
|
if (isAtTop) { |
|
1270
|
self.$results.scrollTop(0); |
|
1271
|
|
|
1272
|
e.preventDefault(); |
|
1273
|
e.stopPropagation(); |
|
1274
|
} else if (isAtBottom) { |
|
1275
|
self.$results.scrollTop( |
|
1276
|
self.$results.get(0).scrollHeight - self.$results.height() |
|
1277
|
); |
|
1278
|
|
|
1279
|
e.preventDefault(); |
|
1280
|
e.stopPropagation(); |
|
1281
|
} |
|
1282
|
}); |
|
1283
|
} |
|
1284
|
|
|
1285
|
this.$results.on('mouseup', '.select2-results__option[aria-selected]', |
|
1286
|
function (evt) { |
|
1287
|
var $this = $(this); |
|
1288
|
|
|
1289
|
var data = Utils.GetData(this, 'data'); |
|
1290
|
|
|
1291
|
if ($this.attr('aria-selected') === 'true') { |
|
1292
|
if (self.options.get('multiple')) { |
|
1293
|
self.trigger('unselect', { |
|
1294
|
originalEvent: evt, |
|
1295
|
data: data |
|
1296
|
}); |
|
1297
|
} else { |
|
1298
|
self.trigger('close', {}); |
|
1299
|
} |
|
1300
|
|
|
1301
|
return; |
|
1302
|
} |
|
1303
|
|
|
1304
|
self.trigger('select', { |
|
1305
|
originalEvent: evt, |
|
1306
|
data: data |
|
1307
|
}); |
|
1308
|
}); |
|
1309
|
|
|
1310
|
this.$results.on('mouseenter', '.select2-results__option[aria-selected]', |
|
1311
|
function (evt) { |
|
1312
|
var data = Utils.GetData(this, 'data'); |
|
1313
|
|
|
1314
|
self.getHighlightedResults() |
|
1315
|
.removeClass('select2-results__option--highlighted'); |
|
1316
|
|
|
1317
|
self.trigger('results:focus', { |
|
1318
|
data: data, |
|
1319
|
element: $(this) |
|
1320
|
}); |
|
1321
|
}); |
|
1322
|
}; |
|
1323
|
|
|
1324
|
Results.prototype.getHighlightedResults = function () { |
|
1325
|
var $highlighted = this.$results |
|
1326
|
.find('.select2-results__option--highlighted'); |
|
1327
|
|
|
1328
|
return $highlighted; |
|
1329
|
}; |
|
1330
|
|
|
1331
|
Results.prototype.destroy = function () { |
|
1332
|
this.$results.remove(); |
|
1333
|
}; |
|
1334
|
|
|
1335
|
Results.prototype.ensureHighlightVisible = function () { |
|
1336
|
var $highlighted = this.getHighlightedResults(); |
|
1337
|
|
|
1338
|
if ($highlighted.length === 0) { |
|
1339
|
return; |
|
1340
|
} |
|
1341
|
|
|
1342
|
var $options = this.$results.find('[aria-selected]'); |
|
1343
|
|
|
1344
|
var currentIndex = $options.index($highlighted); |
|
1345
|
|
|
1346
|
var currentOffset = this.$results.offset().top; |
|
1347
|
var nextTop = $highlighted.offset().top; |
|
1348
|
var nextOffset = this.$results.scrollTop() + (nextTop - currentOffset); |
|
1349
|
|
|
1350
|
var offsetDelta = nextTop - currentOffset; |
|
1351
|
nextOffset -= $highlighted.outerHeight(false) * 2; |
|
1352
|
|
|
1353
|
if (currentIndex <= 2) { |
|
1354
|
this.$results.scrollTop(0); |
|
1355
|
} else if (offsetDelta > this.$results.outerHeight() || offsetDelta < 0) { |
|
1356
|
this.$results.scrollTop(nextOffset); |
|
1357
|
} |
|
1358
|
}; |
|
1359
|
|
|
1360
|
Results.prototype.template = function (result, container) { |
|
1361
|
var template = this.options.get('templateResult'); |
|
1362
|
var escapeMarkup = this.options.get('escapeMarkup'); |
|
1363
|
|
|
1364
|
var content = template(result, container); |
|
1365
|
|
|
1366
|
if (content == null) { |
|
1367
|
container.style.display = 'none'; |
|
1368
|
} else if (typeof content === 'string') { |
|
1369
|
container.innerHTML = escapeMarkup(content); |
|
1370
|
} else { |
|
1371
|
$(container).append(content); |
|
1372
|
} |
|
1373
|
}; |
|
1374
|
|
|
1375
|
return Results; |
|
1376
|
}); |
|
1377
|
|
|
1378
|
S2.define('select2/keys',[ |
|
1379
|
|
|
1380
|
], function () { |
|
1381
|
var KEYS = { |
|
1382
|
BACKSPACE: 8, |
|
1383
|
TAB: 9, |
|
1384
|
ENTER: 13, |
|
1385
|
SHIFT: 16, |
|
1386
|
CTRL: 17, |
|
1387
|
ALT: 18, |
|
1388
|
ESC: 27, |
|
1389
|
SPACE: 32, |
|
1390
|
PAGE_UP: 33, |
|
1391
|
PAGE_DOWN: 34, |
|
1392
|
END: 35, |
|
1393
|
HOME: 36, |
|
1394
|
LEFT: 37, |
|
1395
|
UP: 38, |
|
1396
|
RIGHT: 39, |
|
1397
|
DOWN: 40, |
|
1398
|
DELETE: 46 |
|
1399
|
}; |
|
1400
|
|
|
1401
|
return KEYS; |
|
1402
|
}); |
|
1403
|
|
|
1404
|
S2.define('select2/selection/base',[ |
|
1405
|
'jquery', |
|
1406
|
'../utils', |
|
1407
|
'../keys' |
|
1408
|
], function ($, Utils, KEYS) { |
|
1409
|
function BaseSelection ($element, options) { |
|
1410
|
this.$element = $element; |
|
1411
|
this.options = options; |
|
1412
|
|
|
1413
|
BaseSelection.__super__.constructor.call(this); |
|
1414
|
} |
|
1415
|
|
|
1416
|
Utils.Extend(BaseSelection, Utils.Observable); |
|
1417
|
|
|
1418
|
BaseSelection.prototype.render = function () { |
|
1419
|
var $selection = $( |
|
1420
|
'<span class="select2-selection" role="combobox" ' + |
|
1421
|
' aria-haspopup="true" aria-expanded="false">' + |
|
1422
|
'</span>' |
|
1423
|
); |
|
1424
|
|
|
1425
|
this._tabindex = 0; |
|
1426
|
|
|
1427
|
if (Utils.GetData(this.$element[0], 'old-tabindex') != null) { |
|
1428
|
this._tabindex = Utils.GetData(this.$element[0], 'old-tabindex'); |
|
1429
|
} else if (this.$element.attr('tabindex') != null) { |
|
1430
|
this._tabindex = this.$element.attr('tabindex'); |
|
1431
|
} |
|
1432
|
|
|
1433
|
$selection.attr('title', this.$element.attr('title')); |
|
1434
|
$selection.attr('tabindex', this._tabindex); |
|
1435
|
$selection.attr('aria-disabled', 'false'); |
|
1436
|
|
|
1437
|
this.$selection = $selection; |
|
1438
|
|
|
1439
|
return $selection; |
|
1440
|
}; |
|
1441
|
|
|
1442
|
BaseSelection.prototype.bind = function (container, $container) { |
|
1443
|
var self = this; |
|
1444
|
|
|
1445
|
var resultsId = container.id + '-results'; |
|
1446
|
|
|
1447
|
this.container = container; |
|
1448
|
|
|
1449
|
this.$selection.on('focus', function (evt) { |
|
1450
|
self.trigger('focus', evt); |
|
1451
|
}); |
|
1452
|
|
|
1453
|
this.$selection.on('blur', function (evt) { |
|
1454
|
self._handleBlur(evt); |
|
1455
|
}); |
|
1456
|
|
|
1457
|
this.$selection.on('keydown', function (evt) { |
|
1458
|
self.trigger('keypress', evt); |
|
1459
|
|
|
1460
|
if (evt.which === KEYS.SPACE) { |
|
1461
|
evt.preventDefault(); |
|
1462
|
} |
|
1463
|
}); |
|
1464
|
|
|
1465
|
container.on('results:focus', function (params) { |
|
1466
|
self.$selection.attr('aria-activedescendant', params.data._resultId); |
|
1467
|
}); |
|
1468
|
|
|
1469
|
container.on('selection:update', function (params) { |
|
1470
|
self.update(params.data); |
|
1471
|
}); |
|
1472
|
|
|
1473
|
container.on('open', function () { |
|
1474
|
// When the dropdown is open, aria-expanded="true" |
|
1475
|
self.$selection.attr('aria-expanded', 'true'); |
|
1476
|
self.$selection.attr('aria-owns', resultsId); |
|
1477
|
|
|
1478
|
self._attachCloseHandler(container); |
|
1479
|
}); |
|
1480
|
|
|
1481
|
container.on('close', function () { |
|
1482
|
// When the dropdown is closed, aria-expanded="false" |
|
1483
|
self.$selection.attr('aria-expanded', 'false'); |
|
1484
|
self.$selection.removeAttr('aria-activedescendant'); |
|
1485
|
self.$selection.removeAttr('aria-owns'); |
|
1486
|
|
|
1487
|
self.$selection.trigger('focus'); |
|
1488
|
|
|
1489
|
self._detachCloseHandler(container); |
|
1490
|
}); |
|
1491
|
|
|
1492
|
container.on('enable', function () { |
|
1493
|
self.$selection.attr('tabindex', self._tabindex); |
|
1494
|
self.$selection.attr('aria-disabled', 'false'); |
|
1495
|
}); |
|
1496
|
|
|
1497
|
container.on('disable', function () { |
|
1498
|
self.$selection.attr('tabindex', '-1'); |
|
1499
|
self.$selection.attr('aria-disabled', 'true'); |
|
1500
|
}); |
|
1501
|
}; |
|
1502
|
|
|
1503
|
BaseSelection.prototype._handleBlur = function (evt) { |
|
1504
|
var self = this; |
|
1505
|
|
|
1506
|
// This needs to be delayed as the active element is the body when the tab |
|
1507
|
// key is pressed, possibly along with others. |
|
1508
|
window.setTimeout(function () { |
|
1509
|
// Don't trigger `blur` if the focus is still in the selection |
|
1510
|
if ( |
|
1511
|
(document.activeElement == self.$selection[0]) || |
|
1512
|
($.contains(self.$selection[0], document.activeElement)) |
|
1513
|
) { |
|
1514
|
return; |
|
1515
|
} |
|
1516
|
|
|
1517
|
self.trigger('blur', evt); |
|
1518
|
}, 1); |
|
1519
|
}; |
|
1520
|
|
|
1521
|
BaseSelection.prototype._attachCloseHandler = function (container) { |
|
1522
|
|
|
1523
|
$(document.body).on('mousedown.select2.' + container.id, function (e) { |
|
1524
|
var $target = $(e.target); |
|
1525
|
|
|
1526
|
var $select = $target.closest('.select2'); |
|
1527
|
|
|
1528
|
var $all = $('.select2.select2-container--open'); |
|
1529
|
|
|
1530
|
$all.each(function () { |
|
1531
|
if (this == $select[0]) { |
|
1532
|
return; |
|
1533
|
} |
|
1534
|
|
|
1535
|
var $element = Utils.GetData(this, 'element'); |
|
1536
|
|
|
1537
|
$element.select2('close'); |
|
1538
|
}); |
|
1539
|
}); |
|
1540
|
}; |
|
1541
|
|
|
1542
|
BaseSelection.prototype._detachCloseHandler = function (container) { |
|
1543
|
$(document.body).off('mousedown.select2.' + container.id); |
|
1544
|
}; |
|
1545
|
|
|
1546
|
BaseSelection.prototype.position = function ($selection, $container) { |
|
1547
|
var $selectionContainer = $container.find('.selection'); |
|
1548
|
$selectionContainer.append($selection); |
|
1549
|
}; |
|
1550
|
|
|
1551
|
BaseSelection.prototype.destroy = function () { |
|
1552
|
this._detachCloseHandler(this.container); |
|
1553
|
}; |
|
1554
|
|
|
1555
|
BaseSelection.prototype.update = function (data) { |
|
1556
|
throw new Error('The `update` method must be defined in child classes.'); |
|
1557
|
}; |
|
1558
|
|
|
1559
|
/** |
|
1560
|
* Helper method to abstract the "enabled" (not "disabled") state of this |
|
1561
|
* object. |
|
1562
|
* |
|
1563
|
* @return {true} if the instance is not disabled. |
|
1564
|
* @return {false} if the instance is disabled. |
|
1565
|
*/ |
|
1566
|
BaseSelection.prototype.isEnabled = function () { |
|
1567
|
return !this.isDisabled(); |
|
1568
|
}; |
|
1569
|
|
|
1570
|
/** |
|
1571
|
* Helper method to abstract the "disabled" state of this object. |
|
1572
|
* |
|
1573
|
* @return {true} if the disabled option is true. |
|
1574
|
* @return {false} if the disabled option is false. |
|
1575
|
*/ |
|
1576
|
BaseSelection.prototype.isDisabled = function () { |
|
1577
|
return this.options.get('disabled'); |
|
1578
|
}; |
|
1579
|
|
|
1580
|
return BaseSelection; |
|
1581
|
}); |
|
1582
|
|
|
1583
|
S2.define('select2/selection/single',[ |
|
1584
|
'jquery', |
|
1585
|
'./base', |
|
1586
|
'../utils', |
|
1587
|
'../keys' |
|
1588
|
], function ($, BaseSelection, Utils, KEYS) { |
|
1589
|
function SingleSelection () { |
|
1590
|
SingleSelection.__super__.constructor.apply(this, arguments); |
|
1591
|
} |
|
1592
|
|
|
1593
|
Utils.Extend(SingleSelection, BaseSelection); |
|
1594
|
|
|
1595
|
SingleSelection.prototype.render = function () { |
|
1596
|
var $selection = SingleSelection.__super__.render.call(this); |
|
1597
|
|
|
1598
|
$selection.addClass('select2-selection--single'); |
|
1599
|
|
|
1600
|
$selection.html( |
|
1601
|
'<span class="select2-selection__rendered"></span>' + |
|
1602
|
'<span class="select2-selection__arrow" role="presentation">' + |
|
1603
|
'<b role="presentation"></b>' + |
|
1604
|
'</span>' |
|
1605
|
); |
|
1606
|
|
|
1607
|
return $selection; |
|
1608
|
}; |
|
1609
|
|
|
1610
|
SingleSelection.prototype.bind = function (container, $container) { |
|
1611
|
var self = this; |
|
1612
|
|
|
1613
|
SingleSelection.__super__.bind.apply(this, arguments); |
|
1614
|
|
|
1615
|
var id = container.id + '-container'; |
|
1616
|
|
|
1617
|
this.$selection.find('.select2-selection__rendered') |
|
1618
|
.attr('id', id) |
|
1619
|
.attr('role', 'textbox') |
|
1620
|
.attr('aria-readonly', 'true'); |
|
1621
|
this.$selection.attr('aria-labelledby', id); |
|
1622
|
|
|
1623
|
this.$selection.on('mousedown', function (evt) { |
|
1624
|
// Only respond to left clicks |
|
1625
|
if (evt.which !== 1) { |
|
1626
|
return; |
|
1627
|
} |
|
1628
|
|
|
1629
|
self.trigger('toggle', { |
|
1630
|
originalEvent: evt |
|
1631
|
}); |
|
1632
|
}); |
|
1633
|
|
|
1634
|
this.$selection.on('focus', function (evt) { |
|
1635
|
// User focuses on the container |
|
1636
|
}); |
|
1637
|
|
|
1638
|
this.$selection.on('blur', function (evt) { |
|
1639
|
// User exits the container |
|
1640
|
}); |
|
1641
|
|
|
1642
|
container.on('focus', function (evt) { |
|
1643
|
if (!container.isOpen()) { |
|
1644
|
self.$selection.trigger('focus'); |
|
1645
|
} |
|
1646
|
}); |
|
1647
|
}; |
|
1648
|
|
|
1649
|
SingleSelection.prototype.clear = function () { |
|
1650
|
var $rendered = this.$selection.find('.select2-selection__rendered'); |
|
1651
|
$rendered.empty(); |
|
1652
|
$rendered.removeAttr('title'); // clear tooltip on empty |
|
1653
|
}; |
|
1654
|
|
|
1655
|
SingleSelection.prototype.display = function (data, container) { |
|
1656
|
var template = this.options.get('templateSelection'); |
|
1657
|
var escapeMarkup = this.options.get('escapeMarkup'); |
|
1658
|
|
|
1659
|
return escapeMarkup(template(data, container)); |
|
1660
|
}; |
|
1661
|
|
|
1662
|
SingleSelection.prototype.selectionContainer = function () { |
|
1663
|
return $('<span></span>'); |
|
1664
|
}; |
|
1665
|
|
|
1666
|
SingleSelection.prototype.update = function (data) { |
|
1667
|
if (data.length === 0) { |
|
1668
|
this.clear(); |
|
1669
|
return; |
|
1670
|
} |
|
1671
|
|
|
1672
|
var selection = data[0]; |
|
1673
|
|
|
1674
|
var $rendered = this.$selection.find('.select2-selection__rendered'); |
|
1675
|
var formatted = this.display(selection, $rendered); |
|
1676
|
|
|
1677
|
$rendered.empty().append(formatted); |
|
1678
|
|
|
1679
|
var title = selection.title || selection.text; |
|
1680
|
|
|
1681
|
if (title) { |
|
1682
|
$rendered.attr('title', title); |
|
1683
|
} else { |
|
1684
|
$rendered.removeAttr('title'); |
|
1685
|
} |
|
1686
|
}; |
|
1687
|
|
|
1688
|
return SingleSelection; |
|
1689
|
}); |
|
1690
|
|
|
1691
|
S2.define('select2/selection/multiple',[ |
|
1692
|
'jquery', |
|
1693
|
'./base', |
|
1694
|
'../utils' |
|
1695
|
], function ($, BaseSelection, Utils) { |
|
1696
|
function MultipleSelection ($element, options) { |
|
1697
|
MultipleSelection.__super__.constructor.apply(this, arguments); |
|
1698
|
} |
|
1699
|
|
|
1700
|
Utils.Extend(MultipleSelection, BaseSelection); |
|
1701
|
|
|
1702
|
MultipleSelection.prototype.render = function () { |
|
1703
|
var $selection = MultipleSelection.__super__.render.call(this); |
|
1704
|
|
|
1705
|
$selection.addClass('select2-selection--multiple'); |
|
1706
|
|
|
1707
|
$selection.html( |
|
1708
|
'<ul class="select2-selection__rendered"></ul>' |
|
1709
|
); |
|
1710
|
|
|
1711
|
return $selection; |
|
1712
|
}; |
|
1713
|
|
|
1714
|
MultipleSelection.prototype.bind = function (container, $container) { |
|
1715
|
var self = this; |
|
1716
|
|
|
1717
|
MultipleSelection.__super__.bind.apply(this, arguments); |
|
1718
|
|
|
1719
|
this.$selection.on('click', function (evt) { |
|
1720
|
self.trigger('toggle', { |
|
1721
|
originalEvent: evt |
|
1722
|
}); |
|
1723
|
}); |
|
1724
|
|
|
1725
|
this.$selection.on( |
|
1726
|
'click', |
|
1727
|
'.select2-selection__choice__remove', |
|
1728
|
function (evt) { |
|
1729
|
// Ignore the event if it is disabled |
|
1730
|
if (self.isDisabled()) { |
|
1731
|
return; |
|
1732
|
} |
|
1733
|
|
|
1734
|
var $remove = $(this); |
|
1735
|
var $selection = $remove.parent(); |
|
1736
|
|
|
1737
|
var data = Utils.GetData($selection[0], 'data'); |
|
1738
|
|
|
1739
|
self.trigger('unselect', { |
|
1740
|
originalEvent: evt, |
|
1741
|
data: data |
|
1742
|
}); |
|
1743
|
} |
|
1744
|
); |
|
1745
|
}; |
|
1746
|
|
|
1747
|
MultipleSelection.prototype.clear = function () { |
|
1748
|
var $rendered = this.$selection.find('.select2-selection__rendered'); |
|
1749
|
$rendered.empty(); |
|
1750
|
$rendered.removeAttr('title'); |
|
1751
|
}; |
|
1752
|
|
|
1753
|
MultipleSelection.prototype.display = function (data, container) { |
|
1754
|
var template = this.options.get('templateSelection'); |
|
1755
|
var escapeMarkup = this.options.get('escapeMarkup'); |
|
1756
|
|
|
1757
|
return escapeMarkup(template(data, container)); |
|
1758
|
}; |
|
1759
|
|
|
1760
|
MultipleSelection.prototype.selectionContainer = function () { |
|
1761
|
var $container = $( |
|
1762
|
'<li class="select2-selection__choice">' + |
|
1763
|
'<span class="select2-selection__choice__remove" role="presentation">' + |
|
1764
|
'×' + |
|
1765
|
'</span>' + |
|
1766
|
'</li>' |
|
1767
|
); |
|
1768
|
|
|
1769
|
return $container; |
|
1770
|
}; |
|
1771
|
|
|
1772
|
MultipleSelection.prototype.update = function (data) { |
|
1773
|
this.clear(); |
|
1774
|
|
|
1775
|
if (data.length === 0) { |
|
1776
|
return; |
|
1777
|
} |
|
1778
|
|
|
1779
|
var $selections = []; |
|
1780
|
|
|
1781
|
for (var d = 0; d < data.length; d++) { |
|
1782
|
var selection = data[d]; |
|
1783
|
|
|
1784
|
var $selection = this.selectionContainer(); |
|
1785
|
var formatted = this.display(selection, $selection); |
|
1786
|
|
|
1787
|
$selection.append(formatted); |
|
1788
|
|
|
1789
|
var title = selection.title || selection.text; |
|
1790
|
|
|
1791
|
if (title) { |
|
1792
|
$selection.attr('title', title); |
|
1793
|
} |
|
1794
|
|
|
1795
|
Utils.StoreData($selection[0], 'data', selection); |
|
1796
|
|
|
1797
|
$selections.push($selection); |
|
1798
|
} |
|
1799
|
|
|
1800
|
var $rendered = this.$selection.find('.select2-selection__rendered'); |
|
1801
|
|
|
1802
|
Utils.appendMany($rendered, $selections); |
|
1803
|
}; |
|
1804
|
|
|
1805
|
return MultipleSelection; |
|
1806
|
}); |
|
1807
|
|
|
1808
|
S2.define('select2/selection/placeholder',[ |
|
1809
|
'../utils' |
|
1810
|
], function (Utils) { |
|
1811
|
function Placeholder (decorated, $element, options) { |
|
1812
|
this.placeholder = this.normalizePlaceholder(options.get('placeholder')); |
|
1813
|
|
|
1814
|
decorated.call(this, $element, options); |
|
1815
|
} |
|
1816
|
|
|
1817
|
Placeholder.prototype.normalizePlaceholder = function (_, placeholder) { |
|
1818
|
if (typeof placeholder === 'string') { |
|
1819
|
placeholder = { |
|
1820
|
id: '', |
|
1821
|
text: placeholder |
|
1822
|
}; |
|
1823
|
} |
|
1824
|
|
|
1825
|
return placeholder; |
|
1826
|
}; |
|
1827
|
|
|
1828
|
Placeholder.prototype.createPlaceholder = function (decorated, placeholder) { |
|
1829
|
var $placeholder = this.selectionContainer(); |
|
1830
|
|
|
1831
|
$placeholder.html(this.display(placeholder)); |
|
1832
|
$placeholder.addClass('select2-selection__placeholder') |
|
1833
|
.removeClass('select2-selection__choice'); |
|
1834
|
|
|
1835
|
return $placeholder; |
|
1836
|
}; |
|
1837
|
|
|
1838
|
Placeholder.prototype.update = function (decorated, data) { |
|
1839
|
var singlePlaceholder = ( |
|
1840
|
data.length == 1 && data[0].id != this.placeholder.id |
|
1841
|
); |
|
1842
|
var multipleSelections = data.length > 1; |
|
1843
|
|
|
1844
|
if (multipleSelections || singlePlaceholder) { |
|
1845
|
return decorated.call(this, data); |
|
1846
|
} |
|
1847
|
|
|
1848
|
this.clear(); |
|
1849
|
|
|
1850
|
var $placeholder = this.createPlaceholder(this.placeholder); |
|
1851
|
|
|
1852
|
this.$selection.find('.select2-selection__rendered').append($placeholder); |
|
1853
|
}; |
|
1854
|
|
|
1855
|
return Placeholder; |
|
1856
|
}); |
|
1857
|
|
|
1858
|
S2.define('select2/selection/allowClear',[ |
|
1859
|
'jquery', |
|
1860
|
'../keys', |
|
1861
|
'../utils' |
|
1862
|
], function ($, KEYS, Utils) { |
|
1863
|
function AllowClear () { } |
|
1864
|
|
|
1865
|
AllowClear.prototype.bind = function (decorated, container, $container) { |
|
1866
|
var self = this; |
|
1867
|
|
|
1868
|
decorated.call(this, container, $container); |
|
1869
|
|
|
1870
|
if (this.placeholder == null) { |
|
1871
|
if (this.options.get('debug') && window.console && console.error) { |
|
1872
|
console.error( |
|
1873
|
'Select2: The `allowClear` option should be used in combination ' + |
|
1874
|
'with the `placeholder` option.' |
|
1875
|
); |
|
1876
|
} |
|
1877
|
} |
|
1878
|
|
|
1879
|
this.$selection.on('mousedown', '.select2-selection__clear', |
|
1880
|
function (evt) { |
|
1881
|
self._handleClear(evt); |
|
1882
|
}); |
|
1883
|
|
|
1884
|
container.on('keypress', function (evt) { |
|
1885
|
self._handleKeyboardClear(evt, container); |
|
1886
|
}); |
|
1887
|
}; |
|
1888
|
|
|
1889
|
AllowClear.prototype._handleClear = function (_, evt) { |
|
1890
|
// Ignore the event if it is disabled |
|
1891
|
if (this.isDisabled()) { |
|
1892
|
return; |
|
1893
|
} |
|
1894
|
|
|
1895
|
var $clear = this.$selection.find('.select2-selection__clear'); |
|
1896
|
|
|
1897
|
// Ignore the event if nothing has been selected |
|
1898
|
if ($clear.length === 0) { |
|
1899
|
return; |
|
1900
|
} |
|
1901
|
|
|
1902
|
evt.stopPropagation(); |
|
1903
|
|
|
1904
|
var data = Utils.GetData($clear[0], 'data'); |
|
1905
|
|
|
1906
|
var previousVal = this.$element.val(); |
|
1907
|
this.$element.val(this.placeholder.id); |
|
1908
|
|
|
1909
|
var unselectData = { |
|
1910
|
data: data |
|
1911
|
}; |
|
1912
|
this.trigger('clear', unselectData); |
|
1913
|
if (unselectData.prevented) { |
|
1914
|
this.$element.val(previousVal); |
|
1915
|
return; |
|
1916
|
} |
|
1917
|
|
|
1918
|
for (var d = 0; d < data.length; d++) { |
|
1919
|
unselectData = { |
|
1920
|
data: data[d] |
|
1921
|
}; |
|
1922
|
|
|
1923
|
// Trigger the `unselect` event, so people can prevent it from being |
|
1924
|
// cleared. |
|
1925
|
this.trigger('unselect', unselectData); |
|
1926
|
|
|
1927
|
// If the event was prevented, don't clear it out. |
|
1928
|
if (unselectData.prevented) { |
|
1929
|
this.$element.val(previousVal); |
|
1930
|
return; |
|
1931
|
} |
|
1932
|
} |
|
1933
|
|
|
1934
|
this.$element.trigger('input').trigger('change'); |
|
1935
|
|
|
1936
|
this.trigger('toggle', {}); |
|
1937
|
}; |
|
1938
|
|
|
1939
|
AllowClear.prototype._handleKeyboardClear = function (_, evt, container) { |
|
1940
|
if (container.isOpen()) { |
|
1941
|
return; |
|
1942
|
} |
|
1943
|
|
|
1944
|
if (evt.which == KEYS.DELETE || evt.which == KEYS.BACKSPACE) { |
|
1945
|
this._handleClear(evt); |
|
1946
|
} |
|
1947
|
}; |
|
1948
|
|
|
1949
|
AllowClear.prototype.update = function (decorated, data) { |
|
1950
|
decorated.call(this, data); |
|
1951
|
|
|
1952
|
if (this.$selection.find('.select2-selection__placeholder').length > 0 || |
|
1953
|
data.length === 0) { |
|
1954
|
return; |
|
1955
|
} |
|
1956
|
|
|
1957
|
var removeAll = this.options.get('translations').get('removeAllItems'); |
|
1958
|
|
|
1959
|
var $remove = $( |
|
1960
|
'<span class="select2-selection__clear" title="' + removeAll() +'">' + |
|
1961
|
'×' + |
|
1962
|
'</span>' |
|
1963
|
); |
|
1964
|
Utils.StoreData($remove[0], 'data', data); |
|
1965
|
|
|
1966
|
this.$selection.find('.select2-selection__rendered').prepend($remove); |
|
1967
|
}; |
|
1968
|
|
|
1969
|
return AllowClear; |
|
1970
|
}); |
|
1971
|
|
|
1972
|
S2.define('select2/selection/search',[ |
|
1973
|
'jquery', |
|
1974
|
'../utils', |
|
1975
|
'../keys' |
|
1976
|
], function ($, Utils, KEYS) { |
|
1977
|
function Search (decorated, $element, options) { |
|
1978
|
decorated.call(this, $element, options); |
|
1979
|
} |
|
1980
|
|
|
1981
|
Search.prototype.render = function (decorated) { |
|
1982
|
var $search = $( |
|
1983
|
'<li class="select2-search select2-search--inline">' + |
|
1984
|
'<input class="select2-search__field" type="search" tabindex="-1"' + |
|
1985
|
' autocomplete="off" autocorrect="off" autocapitalize="none"' + |
|
1986
|
' spellcheck="false" role="searchbox" aria-autocomplete="list" />' + |
|
1987
|
'</li>' |
|
1988
|
); |
|
1989
|
|
|
1990
|
this.$searchContainer = $search; |
|
1991
|
this.$search = $search.find('input'); |
|
1992
|
|
|
1993
|
var $rendered = decorated.call(this); |
|
1994
|
|
|
1995
|
this._transferTabIndex(); |
|
1996
|
|
|
1997
|
return $rendered; |
|
1998
|
}; |
|
1999
|
|
|
2000
|
Search.prototype.bind = function (decorated, container, $container) { |
|
2001
|
var self = this; |
|
2002
|
|
|
2003
|
var resultsId = container.id + '-results'; |
|
2004
|
|
|
2005
|
decorated.call(this, container, $container); |
|
2006
|
|
|
2007
|
container.on('open', function () { |
|
2008
|
self.$search.attr('aria-controls', resultsId); |
|
2009
|
self.$search.trigger('focus'); |
|
2010
|
}); |
|
2011
|
|
|
2012
|
container.on('close', function () { |
|
2013
|
self.$search.val(''); |
|
2014
|
self.$search.removeAttr('aria-controls'); |
|
2015
|
self.$search.removeAttr('aria-activedescendant'); |
|
2016
|
self.$search.trigger('focus'); |
|
2017
|
}); |
|
2018
|
|
|
2019
|
container.on('enable', function () { |
|
2020
|
self.$search.prop('disabled', false); |
|
2021
|
|
|
2022
|
self._transferTabIndex(); |
|
2023
|
}); |
|
2024
|
|
|
2025
|
container.on('disable', function () { |
|
2026
|
self.$search.prop('disabled', true); |
|
2027
|
}); |
|
2028
|
|
|
2029
|
container.on('focus', function (evt) { |
|
2030
|
self.$search.trigger('focus'); |
|
2031
|
}); |
|
2032
|
|
|
2033
|
container.on('results:focus', function (params) { |
|
2034
|
if (params.data._resultId) { |
|
2035
|
self.$search.attr('aria-activedescendant', params.data._resultId); |
|
2036
|
} else { |
|
2037
|
self.$search.removeAttr('aria-activedescendant'); |
|
2038
|
} |
|
2039
|
}); |
|
2040
|
|
|
2041
|
this.$selection.on('focusin', '.select2-search--inline', function (evt) { |
|
2042
|
self.trigger('focus', evt); |
|
2043
|
}); |
|
2044
|
|
|
2045
|
this.$selection.on('focusout', '.select2-search--inline', function (evt) { |
|
2046
|
self._handleBlur(evt); |
|
2047
|
}); |
|
2048
|
|
|
2049
|
this.$selection.on('keydown', '.select2-search--inline', function (evt) { |
|
2050
|
evt.stopPropagation(); |
|
2051
|
|
|
2052
|
self.trigger('keypress', evt); |
|
2053
|
|
|
2054
|
self._keyUpPrevented = evt.isDefaultPrevented(); |
|
2055
|
|
|
2056
|
var key = evt.which; |
|
2057
|
|
|
2058
|
if (key === KEYS.BACKSPACE && self.$search.val() === '') { |
|
2059
|
var $previousChoice = self.$searchContainer |
|
2060
|
.prev('.select2-selection__choice'); |
|
2061
|
|
|
2062
|
if ($previousChoice.length > 0) { |
|
2063
|
var item = Utils.GetData($previousChoice[0], 'data'); |
|
2064
|
|
|
2065
|
self.searchRemoveChoice(item); |
|
2066
|
|
|
2067
|
evt.preventDefault(); |
|
2068
|
} |
|
2069
|
} |
|
2070
|
}); |
|
2071
|
|
|
2072
|
this.$selection.on('click', '.select2-search--inline', function (evt) { |
|
2073
|
if (self.$search.val()) { |
|
2074
|
evt.stopPropagation(); |
|
2075
|
} |
|
2076
|
}); |
|
2077
|
|
|
2078
|
// Try to detect the IE version should the `documentMode` property that |
|
2079
|
// is stored on the document. This is only implemented in IE and is |
|
2080
|
// slightly cleaner than doing a user agent check. |
|
2081
|
// This property is not available in Edge, but Edge also doesn't have |
|
2082
|
// this bug. |
|
2083
|
var msie = document.documentMode; |
|
2084
|
var disableInputEvents = msie && msie <= 11; |
|
2085
|
|
|
2086
|
// Workaround for browsers which do not support the `input` event |
|
2087
|
// This will prevent double-triggering of events for browsers which support |
|
2088
|
// both the `keyup` and `input` events. |
|
2089
|
this.$selection.on( |
|
2090
|
'input.searchcheck', |
|
2091
|
'.select2-search--inline', |
|
2092
|
function (evt) { |
|
2093
|
// IE will trigger the `input` event when a placeholder is used on a |
|
2094
|
// search box. To get around this issue, we are forced to ignore all |
|
2095
|
// `input` events in IE and keep using `keyup`. |
|
2096
|
if (disableInputEvents) { |
|
2097
|
self.$selection.off('input.search input.searchcheck'); |
|
2098
|
return; |
|
2099
|
} |
|
2100
|
|
|
2101
|
// Unbind the duplicated `keyup` event |
|
2102
|
self.$selection.off('keyup.search'); |
|
2103
|
} |
|
2104
|
); |
|
2105
|
|
|
2106
|
this.$selection.on( |
|
2107
|
'keyup.search input.search', |
|
2108
|
'.select2-search--inline', |
|
2109
|
function (evt) { |
|
2110
|
// IE will trigger the `input` event when a placeholder is used on a |
|
2111
|
// search box. To get around this issue, we are forced to ignore all |
|
2112
|
// `input` events in IE and keep using `keyup`. |
|
2113
|
if (disableInputEvents && evt.type === 'input') { |
|
2114
|
self.$selection.off('input.search input.searchcheck'); |
|
2115
|
return; |
|
2116
|
} |
|
2117
|
|
|
2118
|
var key = evt.which; |
|
2119
|
|
|
2120
|
// We can freely ignore events from modifier keys |
|
2121
|
if (key == KEYS.SHIFT || key == KEYS.CTRL || key == KEYS.ALT) { |
|
2122
|
return; |
|
2123
|
} |
|
2124
|
|
|
2125
|
// Tabbing will be handled during the `keydown` phase |
|
2126
|
if (key == KEYS.TAB) { |
|
2127
|
return; |
|
2128
|
} |
|
2129
|
|
|
2130
|
self.handleSearch(evt); |
|
2131
|
} |
|
2132
|
); |
|
2133
|
}; |
|
2134
|
|
|
2135
|
/** |
|
2136
|
* This method will transfer the tabindex attribute from the rendered |
|
2137
|
* selection to the search box. This allows for the search box to be used as |
|
2138
|
* the primary focus instead of the selection container. |
|
2139
|
* |
|
2140
|
* @private |
|
2141
|
*/ |
|
2142
|
Search.prototype._transferTabIndex = function (decorated) { |
|
2143
|
this.$search.attr('tabindex', this.$selection.attr('tabindex')); |
|
2144
|
this.$selection.attr('tabindex', '-1'); |
|
2145
|
}; |
|
2146
|
|
|
2147
|
Search.prototype.createPlaceholder = function (decorated, placeholder) { |
|
2148
|
this.$search.attr('placeholder', placeholder.text); |
|
2149
|
}; |
|
2150
|
|
|
2151
|
Search.prototype.update = function (decorated, data) { |
|
2152
|
var searchHadFocus = this.$search[0] == document.activeElement; |
|
2153
|
|
|
2154
|
this.$search.attr('placeholder', ''); |
|
2155
|
|
|
2156
|
decorated.call(this, data); |
|
2157
|
|
|
2158
|
this.$selection.find('.select2-selection__rendered') |
|
2159
|
.append(this.$searchContainer); |
|
2160
|
|
|
2161
|
this.resizeSearch(); |
|
2162
|
if (searchHadFocus) { |
|
2163
|
this.$search.trigger('focus'); |
|
2164
|
} |
|
2165
|
}; |
|
2166
|
|
|
2167
|
Search.prototype.handleSearch = function () { |
|
2168
|
this.resizeSearch(); |
|
2169
|
|
|
2170
|
if (!this._keyUpPrevented) { |
|
2171
|
var input = this.$search.val(); |
|
2172
|
|
|
2173
|
this.trigger('query', { |
|
2174
|
term: input |
|
2175
|
}); |
|
2176
|
} |
|
2177
|
|
|
2178
|
this._keyUpPrevented = false; |
|
2179
|
}; |
|
2180
|
|
|
2181
|
Search.prototype.searchRemoveChoice = function (decorated, item) { |
|
2182
|
this.trigger('unselect', { |
|
2183
|
data: item |
|
2184
|
}); |
|
2185
|
|
|
2186
|
this.$search.val(item.text); |
|
2187
|
this.handleSearch(); |
|
2188
|
}; |
|
2189
|
|
|
2190
|
Search.prototype.resizeSearch = function () { |
|
2191
|
this.$search.css('width', '25px'); |
|
2192
|
|
|
2193
|
var width = ''; |
|
2194
|
|
|
2195
|
if (this.$search.attr('placeholder') !== '') { |
|
2196
|
width = this.$selection.find('.select2-selection__rendered').width(); |
|
2197
|
} else { |
|
2198
|
var minimumWidth = this.$search.val().length + 1; |
|
2199
|
|
|
2200
|
width = (minimumWidth * 0.75) + 'em'; |
|
2201
|
} |
|
2202
|
|
|
2203
|
this.$search.css('width', width); |
|
2204
|
}; |
|
2205
|
|
|
2206
|
return Search; |
|
2207
|
}); |
|
2208
|
|
|
2209
|
S2.define('select2/selection/eventRelay',[ |
|
2210
|
'jquery' |
|
2211
|
], function ($) { |
|
2212
|
function EventRelay () { } |
|
2213
|
|
|
2214
|
EventRelay.prototype.bind = function (decorated, container, $container) { |
|
2215
|
var self = this; |
|
2216
|
var relayEvents = [ |
|
2217
|
'open', 'opening', |
|
2218
|
'close', 'closing', |
|
2219
|
'select', 'selecting', |
|
2220
|
'unselect', 'unselecting', |
|
2221
|
'clear', 'clearing' |
|
2222
|
]; |
|
2223
|
|
|
2224
|
var preventableEvents = [ |
|
2225
|
'opening', 'closing', 'selecting', 'unselecting', 'clearing' |
|
2226
|
]; |
|
2227
|
|
|
2228
|
decorated.call(this, container, $container); |
|
2229
|
|
|
2230
|
container.on('*', function (name, params) { |
|
2231
|
// Ignore events that should not be relayed |
|
2232
|
if ($.inArray(name, relayEvents) === -1) { |
|
2233
|
return; |
|
2234
|
} |
|
2235
|
|
|
2236
|
// The parameters should always be an object |
|
2237
|
params = params || {}; |
|
2238
|
|
|
2239
|
// Generate the jQuery event for the Select2 event |
|
2240
|
var evt = $.Event('select2:' + name, { |
|
2241
|
params: params |
|
2242
|
}); |
|
2243
|
|
|
2244
|
self.$element.trigger(evt); |
|
2245
|
|
|
2246
|
// Only handle preventable events if it was one |
|
2247
|
if ($.inArray(name, preventableEvents) === -1) { |
|
2248
|
return; |
|
2249
|
} |
|
2250
|
|
|
2251
|
params.prevented = evt.isDefaultPrevented(); |
|
2252
|
}); |
|
2253
|
}; |
|
2254
|
|
|
2255
|
return EventRelay; |
|
2256
|
}); |
|
2257
|
|
|
2258
|
S2.define('select2/translation',[ |
|
2259
|
'jquery', |
|
2260
|
'require' |
|
2261
|
], function ($, require) { |
|
2262
|
function Translation (dict) { |
|
2263
|
this.dict = dict || {}; |
|
2264
|
} |
|
2265
|
|
|
2266
|
Translation.prototype.all = function () { |
|
2267
|
return this.dict; |
|
2268
|
}; |
|
2269
|
|
|
2270
|
Translation.prototype.get = function (key) { |
|
2271
|
return this.dict[key]; |
|
2272
|
}; |
|
2273
|
|
|
2274
|
Translation.prototype.extend = function (translation) { |
|
2275
|
this.dict = $.extend({}, translation.all(), this.dict); |
|
2276
|
}; |
|
2277
|
|
|
2278
|
// Static functions |
|
2279
|
|
|
2280
|
Translation._cache = {}; |
|
2281
|
|
|
2282
|
Translation.loadPath = function (path) { |
|
2283
|
if (!(path in Translation._cache)) { |
|
2284
|
var translations = require(path); |
|
2285
|
|
|
2286
|
Translation._cache[path] = translations; |
|
2287
|
} |
|
2288
|
|
|
2289
|
return new Translation(Translation._cache[path]); |
|
2290
|
}; |
|
2291
|
|
|
2292
|
return Translation; |
|
2293
|
}); |
|
2294
|
|
|
2295
|
S2.define('select2/diacritics',[ |
|
2296
|
|
|
2297
|
], function () { |
|
2298
|
var diacritics = { |
|
2299
|
'\u24B6': 'A', |
|
2300
|
'\uFF21': 'A', |
|
2301
|
'\u00C0': 'A', |
|
2302
|
'\u00C1': 'A', |
|
2303
|
'\u00C2': 'A', |
|
2304
|
'\u1EA6': 'A', |
|
2305
|
'\u1EA4': 'A', |
|
2306
|
'\u1EAA': 'A', |
|
2307
|
'\u1EA8': 'A', |
|
2308
|
'\u00C3': 'A', |
|
2309
|
'\u0100': 'A', |
|
2310
|
'\u0102': 'A', |
|
2311
|
'\u1EB0': 'A', |
|
2312
|
'\u1EAE': 'A', |
|
2313
|
'\u1EB4': 'A', |
|
2314
|
'\u1EB2': 'A', |
|
2315
|
'\u0226': 'A', |
|
2316
|
'\u01E0': 'A', |
|
2317
|
'\u00C4': 'A', |
|
2318
|
'\u01DE': 'A', |
|
2319
|
'\u1EA2': 'A', |
|
2320
|
'\u00C5': 'A', |
|
2321
|
'\u01FA': 'A', |
|
2322
|
'\u01CD': 'A', |
|
2323
|
'\u0200': 'A', |
|
2324
|
'\u0202': 'A', |
|
2325
|
'\u1EA0': 'A', |
|
2326
|
'\u1EAC': 'A', |
|
2327
|
'\u1EB6': 'A', |
|
2328
|
'\u1E00': 'A', |
|
2329
|
'\u0104': 'A', |
|
2330
|
'\u023A': 'A', |
|
2331
|
'\u2C6F': 'A', |
|
2332
|
'\uA732': 'AA', |
|
2333
|
'\u00C6': 'AE', |
|
2334
|
'\u01FC': 'AE', |
|
2335
|
'\u01E2': 'AE', |
|
2336
|
'\uA734': 'AO', |
|
2337
|
'\uA736': 'AU', |
|
2338
|
'\uA738': 'AV', |
|
2339
|
'\uA73A': 'AV', |
|
2340
|
'\uA73C': 'AY', |
|
2341
|
'\u24B7': 'B', |
|
2342
|
'\uFF22': 'B', |
|
2343
|
'\u1E02': 'B', |
|
2344
|
'\u1E04': 'B', |
|
2345
|
'\u1E06': 'B', |
|
2346
|
'\u0243': 'B', |
|
2347
|
'\u0182': 'B', |
|
2348
|
'\u0181': 'B', |
|
2349
|
'\u24B8': 'C', |
|
2350
|
'\uFF23': 'C', |
|
2351
|
'\u0106': 'C', |
|
2352
|
'\u0108': 'C', |
|
2353
|
'\u010A': 'C', |
|
2354
|
'\u010C': 'C', |
|
2355
|
'\u00C7': 'C', |
|
2356
|
'\u1E08': 'C', |
|
2357
|
'\u0187': 'C', |
|
2358
|
'\u023B': 'C', |
|
2359
|
'\uA73E': 'C', |
|
2360
|
'\u24B9': 'D', |
|
2361
|
'\uFF24': 'D', |
|
2362
|
'\u1E0A': 'D', |
|
2363
|
'\u010E': 'D', |
|
2364
|
'\u1E0C': 'D', |
|
2365
|
'\u1E10': 'D', |
|
2366
|
'\u1E12': 'D', |
|
2367
|
'\u1E0E': 'D', |
|
2368
|
'\u0110': 'D', |
|
2369
|
'\u018B': 'D', |
|
2370
|
'\u018A': 'D', |
|
2371
|
'\u0189': 'D', |
|
2372
|
'\uA779': 'D', |
|
2373
|
'\u01F1': 'DZ', |
|
2374
|
'\u01C4': 'DZ', |
|
2375
|
'\u01F2': 'Dz', |
|
2376
|
'\u01C5': 'Dz', |
|
2377
|
'\u24BA': 'E', |
|
2378
|
'\uFF25': 'E', |
|
2379
|
'\u00C8': 'E', |
|
2380
|
'\u00C9': 'E', |
|
2381
|
'\u00CA': 'E', |
|
2382
|
'\u1EC0': 'E', |
|
2383
|
'\u1EBE': 'E', |
|
2384
|
'\u1EC4': 'E', |
|
2385
|
'\u1EC2': 'E', |
|
2386
|
'\u1EBC': 'E', |
|
2387
|
'\u0112': 'E', |
|
2388
|
'\u1E14': 'E', |
|
2389
|
'\u1E16': 'E', |
|
2390
|
'\u0114': 'E', |
|
2391
|
'\u0116': 'E', |
|
2392
|
'\u00CB': 'E', |
|
2393
|
'\u1EBA': 'E', |
|
2394
|
'\u011A': 'E', |
|
2395
|
'\u0204': 'E', |
|
2396
|
'\u0206': 'E', |
|
2397
|
'\u1EB8': 'E', |
|
2398
|
'\u1EC6': 'E', |
|
2399
|
'\u0228': 'E', |
|
2400
|
'\u1E1C': 'E', |
|
2401
|
'\u0118': 'E', |
|
2402
|
'\u1E18': 'E', |
|
2403
|
'\u1E1A': 'E', |
|
2404
|
'\u0190': 'E', |
|
2405
|
'\u018E': 'E', |
|
2406
|
'\u24BB': 'F', |
|
2407
|
'\uFF26': 'F', |
|
2408
|
'\u1E1E': 'F', |
|
2409
|
'\u0191': 'F', |
|
2410
|
'\uA77B': 'F', |
|
2411
|
'\u24BC': 'G', |
|
2412
|
'\uFF27': 'G', |
|
2413
|
'\u01F4': 'G', |
|
2414
|
'\u011C': 'G', |
|
2415
|
'\u1E20': 'G', |
|
2416
|
'\u011E': 'G', |
|
2417
|
'\u0120': 'G', |
|
2418
|
'\u01E6': 'G', |
|
2419
|
'\u0122': 'G', |
|
2420
|
'\u01E4': 'G', |
|
2421
|
'\u0193': 'G', |
|
2422
|
'\uA7A0': 'G', |
|
2423
|
'\uA77D': 'G', |
|
2424
|
'\uA77E': 'G', |
|
2425
|
'\u24BD': 'H', |
|
2426
|
'\uFF28': 'H', |
|
2427
|
'\u0124': 'H', |
|
2428
|
'\u1E22': 'H', |
|
2429
|
'\u1E26': 'H', |
|
2430
|
'\u021E': 'H', |
|
2431
|
'\u1E24': 'H', |
|
2432
|
'\u1E28': 'H', |
|
2433
|
'\u1E2A': 'H', |
|
2434
|
'\u0126': 'H', |
|
2435
|
'\u2C67': 'H', |
|
2436
|
'\u2C75': 'H', |
|
2437
|
'\uA78D': 'H', |
|
2438
|
'\u24BE': 'I', |
|
2439
|
'\uFF29': 'I', |
|
2440
|
'\u00CC': 'I', |
|
2441
|
'\u00CD': 'I', |
|
2442
|
'\u00CE': 'I', |
|
2443
|
'\u0128': 'I', |
|
2444
|
'\u012A': 'I', |
|
2445
|
'\u012C': 'I', |
|
2446
|
'\u0130': 'I', |
|
2447
|
'\u00CF': 'I', |
|
2448
|
'\u1E2E': 'I', |
|
2449
|
'\u1EC8': 'I', |
|
2450
|
'\u01CF': 'I', |
|
2451
|
'\u0208': 'I', |
|
2452
|
'\u020A': 'I', |
|
2453
|
'\u1ECA': 'I', |
|
2454
|
'\u012E': 'I', |
|
2455
|
'\u1E2C': 'I', |
|
2456
|
'\u0197': 'I', |
|
2457
|
'\u24BF': 'J', |
|
2458
|
'\uFF2A': 'J', |
|
2459
|
'\u0134': 'J', |
|
2460
|
'\u0248': 'J', |
|
2461
|
'\u24C0': 'K', |
|
2462
|
'\uFF2B': 'K', |
|
2463
|
'\u1E30': 'K', |
|
2464
|
'\u01E8': 'K', |
|
2465
|
'\u1E32': 'K', |
|
2466
|
'\u0136': 'K', |
|
2467
|
'\u1E34': 'K', |
|
2468
|
'\u0198': 'K', |
|
2469
|
'\u2C69': 'K', |
|
2470
|
'\uA740': 'K', |
|
2471
|
'\uA742': 'K', |
|
2472
|
'\uA744': 'K', |
|
2473
|
'\uA7A2': 'K', |
|
2474
|
'\u24C1': 'L', |
|
2475
|
'\uFF2C': 'L', |
|
2476
|
'\u013F': 'L', |
|
2477
|
'\u0139': 'L', |
|
2478
|
'\u013D': 'L', |
|
2479
|
'\u1E36': 'L', |
|
2480
|
'\u1E38': 'L', |
|
2481
|
'\u013B': 'L', |
|
2482
|
'\u1E3C': 'L', |
|
2483
|
'\u1E3A': 'L', |
|
2484
|
'\u0141': 'L', |
|
2485
|
'\u023D': 'L', |
|
2486
|
'\u2C62': 'L', |
|
2487
|
'\u2C60': 'L', |
|
2488
|
'\uA748': 'L', |
|
2489
|
'\uA746': 'L', |
|
2490
|
'\uA780': 'L', |
|
2491
|
'\u01C7': 'LJ', |
|
2492
|
'\u01C8': 'Lj', |
|
2493
|
'\u24C2': 'M', |
|
2494
|
'\uFF2D': 'M', |
|
2495
|
'\u1E3E': 'M', |
|
2496
|
'\u1E40': 'M', |
|
2497
|
'\u1E42': 'M', |
|
2498
|
'\u2C6E': 'M', |
|
2499
|
'\u019C': 'M', |
|
2500
|
'\u24C3': 'N', |
|
2501
|
'\uFF2E': 'N', |
|
2502
|
'\u01F8': 'N', |
|
2503
|
'\u0143': 'N', |
|
2504
|
'\u00D1': 'N', |
|
2505
|
'\u1E44': 'N', |
|
2506
|
'\u0147': 'N', |
|
2507
|
'\u1E46': 'N', |
|
2508
|
'\u0145': 'N', |
|
2509
|
'\u1E4A': 'N', |
|
2510
|
'\u1E48': 'N', |
|
2511
|
'\u0220': 'N', |
|
2512
|
'\u019D': 'N', |
|
2513
|
'\uA790': 'N', |
|
2514
|
'\uA7A4': 'N', |
|
2515
|
'\u01CA': 'NJ', |
|
2516
|
'\u01CB': 'Nj', |
|
2517
|
'\u24C4': 'O', |
|
2518
|
'\uFF2F': 'O', |
|
2519
|
'\u00D2': 'O', |
|
2520
|
'\u00D3': 'O', |
|
2521
|
'\u00D4': 'O', |
|
2522
|
'\u1ED2': 'O', |
|
2523
|
'\u1ED0': 'O', |
|
2524
|
'\u1ED6': 'O', |
|
2525
|
'\u1ED4': 'O', |
|
2526
|
'\u00D5': 'O', |
|
2527
|
'\u1E4C': 'O', |
|
2528
|
'\u022C': 'O', |
|
2529
|
'\u1E4E': 'O', |
|
2530
|
'\u014C': 'O', |
|
2531
|
'\u1E50': 'O', |
|
2532
|
'\u1E52': 'O', |
|
2533
|
'\u014E': 'O', |
|
2534
|
'\u022E': 'O', |
|
2535
|
'\u0230': 'O', |
|
2536
|
'\u00D6': 'O', |
|
2537
|
'\u022A': 'O', |
|
2538
|
'\u1ECE': 'O', |
|
2539
|
'\u0150': 'O', |
|
2540
|
'\u01D1': 'O', |
|
2541
|
'\u020C': 'O', |
|
2542
|
'\u020E': 'O', |
|
2543
|
'\u01A0': 'O', |
|
2544
|
'\u1EDC': 'O', |
|
2545
|
'\u1EDA': 'O', |
|
2546
|
'\u1EE0': 'O', |
|
2547
|
'\u1EDE': 'O', |
|
2548
|
'\u1EE2': 'O', |
|
2549
|
'\u1ECC': 'O', |
|
2550
|
'\u1ED8': 'O', |
|
2551
|
'\u01EA': 'O', |
|
2552
|
'\u01EC': 'O', |
|
2553
|
'\u00D8': 'O', |
|
2554
|
'\u01FE': 'O', |
|
2555
|
'\u0186': 'O', |
|
2556
|
'\u019F': 'O', |
|
2557
|
'\uA74A': 'O', |
|
2558
|
'\uA74C': 'O', |
|
2559
|
'\u0152': 'OE', |
|
2560
|
'\u01A2': 'OI', |
|
2561
|
'\uA74E': 'OO', |
|
2562
|
'\u0222': 'OU', |
|
2563
|
'\u24C5': 'P', |
|
2564
|
'\uFF30': 'P', |
|
2565
|
'\u1E54': 'P', |
|
2566
|
'\u1E56': 'P', |
|
2567
|
'\u01A4': 'P', |
|
2568
|
'\u2C63': 'P', |
|
2569
|
'\uA750': 'P', |
|
2570
|
'\uA752': 'P', |
|
2571
|
'\uA754': 'P', |
|
2572
|
'\u24C6': 'Q', |
|
2573
|
'\uFF31': 'Q', |
|
2574
|
'\uA756': 'Q', |
|
2575
|
'\uA758': 'Q', |
|
2576
|
'\u024A': 'Q', |
|
2577
|
'\u24C7': 'R', |
|
2578
|
'\uFF32': 'R', |
|
2579
|
'\u0154': 'R', |
|
2580
|
'\u1E58': 'R', |
|
2581
|
'\u0158': 'R', |
|
2582
|
'\u0210': 'R', |
|
2583
|
'\u0212': 'R', |
|
2584
|
'\u1E5A': 'R', |
|
2585
|
'\u1E5C': 'R', |
|
2586
|
'\u0156': 'R', |
|
2587
|
'\u1E5E': 'R', |
|
2588
|
'\u024C': 'R', |
|
2589
|
'\u2C64': 'R', |
|
2590
|
'\uA75A': 'R', |
|
2591
|
'\uA7A6': 'R', |
|
2592
|
'\uA782': 'R', |
|
2593
|
'\u24C8': 'S', |
|
2594
|
'\uFF33': 'S', |
|
2595
|
'\u1E9E': 'S', |
|
2596
|
'\u015A': 'S', |
|
2597
|
'\u1E64': 'S', |
|
2598
|
'\u015C': 'S', |
|
2599
|
'\u1E60': 'S', |
|
2600
|
'\u0160': 'S', |
|
2601
|
'\u1E66': 'S', |
|
2602
|
'\u1E62': 'S', |
|
2603
|
'\u1E68': 'S', |
|
2604
|
'\u0218': 'S', |
|
2605
|
'\u015E': 'S', |
|
2606
|
'\u2C7E': 'S', |
|
2607
|
'\uA7A8': 'S', |
|
2608
|
'\uA784': 'S', |
|
2609
|
'\u24C9': 'T', |
|
2610
|
'\uFF34': 'T', |
|
2611
|
'\u1E6A': 'T', |
|
2612
|
'\u0164': 'T', |
|
2613
|
'\u1E6C': 'T', |
|
2614
|
'\u021A': 'T', |
|
2615
|
'\u0162': 'T', |
|
2616
|
'\u1E70': 'T', |
|
2617
|
'\u1E6E': 'T', |
|
2618
|
'\u0166': 'T', |
|
2619
|
'\u01AC': 'T', |
|
2620
|
'\u01AE': 'T', |
|
2621
|
'\u023E': 'T', |
|
2622
|
'\uA786': 'T', |
|
2623
|
'\uA728': 'TZ', |
|
2624
|
'\u24CA': 'U', |
|
2625
|
'\uFF35': 'U', |
|
2626
|
'\u00D9': 'U', |
|
2627
|
'\u00DA': 'U', |
|
2628
|
'\u00DB': 'U', |
|
2629
|
'\u0168': 'U', |
|
2630
|
'\u1E78': 'U', |
|
2631
|
'\u016A': 'U', |
|
2632
|
'\u1E7A': 'U', |
|
2633
|
'\u016C': 'U', |
|
2634
|
'\u00DC': 'U', |
|
2635
|
'\u01DB': 'U', |
|
2636
|
'\u01D7': 'U', |
|
2637
|
'\u01D5': 'U', |
|
2638
|
'\u01D9': 'U', |
|
2639
|
'\u1EE6': 'U', |
|
2640
|
'\u016E': 'U', |
|
2641
|
'\u0170': 'U', |
|
2642
|
'\u01D3': 'U', |
|
2643
|
'\u0214': 'U', |
|
2644
|
'\u0216': 'U', |
|
2645
|
'\u01AF': 'U', |
|
2646
|
'\u1EEA': 'U', |
|
2647
|
'\u1EE8': 'U', |
|
2648
|
'\u1EEE': 'U', |
|
2649
|
'\u1EEC': 'U', |
|
2650
|
'\u1EF0': 'U', |
|
2651
|
'\u1EE4': 'U', |
|
2652
|
'\u1E72': 'U', |
|
2653
|
'\u0172': 'U', |
|
2654
|
'\u1E76': 'U', |
|
2655
|
'\u1E74': 'U', |
|
2656
|
'\u0244': 'U', |
|
2657
|
'\u24CB': 'V', |
|
2658
|
'\uFF36': 'V', |
|
2659
|
'\u1E7C': 'V', |
|
2660
|
'\u1E7E': 'V', |
|
2661
|
'\u01B2': 'V', |
|
2662
|
'\uA75E': 'V', |
|
2663
|
'\u0245': 'V', |
|
2664
|
'\uA760': 'VY', |
|
2665
|
'\u24CC': 'W', |
|
2666
|
'\uFF37': 'W', |
|
2667
|
'\u1E80': 'W', |
|
2668
|
'\u1E82': 'W', |
|
2669
|
'\u0174': 'W', |
|
2670
|
'\u1E86': 'W', |
|
2671
|
'\u1E84': 'W', |
|
2672
|
'\u1E88': 'W', |
|
2673
|
'\u2C72': 'W', |
|
2674
|
'\u24CD': 'X', |
|
2675
|
'\uFF38': 'X', |
|
2676
|
'\u1E8A': 'X', |
|
2677
|
'\u1E8C': 'X', |
|
2678
|
'\u24CE': 'Y', |
|
2679
|
'\uFF39': 'Y', |
|
2680
|
'\u1EF2': 'Y', |
|
2681
|
'\u00DD': 'Y', |
|
2682
|
'\u0176': 'Y', |
|
2683
|
'\u1EF8': 'Y', |
|
2684
|
'\u0232': 'Y', |
|
2685
|
'\u1E8E': 'Y', |
|
2686
|
'\u0178': 'Y', |
|
2687
|
'\u1EF6': 'Y', |
|
2688
|
'\u1EF4': 'Y', |
|
2689
|
'\u01B3': 'Y', |
|
2690
|
'\u024E': 'Y', |
|
2691
|
'\u1EFE': 'Y', |
|
2692
|
'\u24CF': 'Z', |
|
2693
|
'\uFF3A': 'Z', |
|
2694
|
'\u0179': 'Z', |
|
2695
|
'\u1E90': 'Z', |
|
2696
|
'\u017B': 'Z', |
|
2697
|
'\u017D': 'Z', |
|
2698
|
'\u1E92': 'Z', |
|
2699
|
'\u1E94': 'Z', |
|
2700
|
'\u01B5': 'Z', |
|
2701
|
'\u0224': 'Z', |
|
2702
|
'\u2C7F': 'Z', |
|
2703
|
'\u2C6B': 'Z', |
|
2704
|
'\uA762': 'Z', |
|
2705
|
'\u24D0': 'a', |
|
2706
|
'\uFF41': 'a', |
|
2707
|
'\u1E9A': 'a', |
|
2708
|
'\u00E0': 'a', |
|
2709
|
'\u00E1': 'a', |
|
2710
|
'\u00E2': 'a', |
|
2711
|
'\u1EA7': 'a', |
|
2712
|
'\u1EA5': 'a', |
|
2713
|
'\u1EAB': 'a', |
|
2714
|
'\u1EA9': 'a', |
|
2715
|
'\u00E3': 'a', |
|
2716
|
'\u0101': 'a', |
|
2717
|
'\u0103': 'a', |
|
2718
|
'\u1EB1': 'a', |
|
2719
|
'\u1EAF': 'a', |
|
2720
|
'\u1EB5': 'a', |
|
2721
|
'\u1EB3': 'a', |
|
2722
|
'\u0227': 'a', |
|
2723
|
'\u01E1': 'a', |
|
2724
|
'\u00E4': 'a', |
|
2725
|
'\u01DF': 'a', |
|
2726
|
'\u1EA3': 'a', |
|
2727
|
'\u00E5': 'a', |
|
2728
|
'\u01FB': 'a', |
|
2729
|
'\u01CE': 'a', |
|
2730
|
'\u0201': 'a', |
|
2731
|
'\u0203': 'a', |
|
2732
|
'\u1EA1': 'a', |
|
2733
|
'\u1EAD': 'a', |
|
2734
|
'\u1EB7': 'a', |
|
2735
|
'\u1E01': 'a', |
|
2736
|
'\u0105': 'a', |
|
2737
|
'\u2C65': 'a', |
|
2738
|
'\u0250': 'a', |
|
2739
|
'\uA733': 'aa', |
|
2740
|
'\u00E6': 'ae', |
|
2741
|
'\u01FD': 'ae', |
|
2742
|
'\u01E3': 'ae', |
|
2743
|
'\uA735': 'ao', |
|
2744
|
'\uA737': 'au', |
|
2745
|
'\uA739': 'av', |
|
2746
|
'\uA73B': 'av', |
|
2747
|
'\uA73D': 'ay', |
|
2748
|
'\u24D1': 'b', |
|
2749
|
'\uFF42': 'b', |
|
2750
|
'\u1E03': 'b', |
|
2751
|
'\u1E05': 'b', |
|
2752
|
'\u1E07': 'b', |
|
2753
|
'\u0180': 'b', |
|
2754
|
'\u0183': 'b', |
|
2755
|
'\u0253': 'b', |
|
2756
|
'\u24D2': 'c', |
|
2757
|
'\uFF43': 'c', |
|
2758
|
'\u0107': 'c', |
|
2759
|
'\u0109': 'c', |
|
2760
|
'\u010B': 'c', |
|
2761
|
'\u010D': 'c', |
|
2762
|
'\u00E7': 'c', |
|
2763
|
'\u1E09': 'c', |
|
2764
|
'\u0188': 'c', |
|
2765
|
'\u023C': 'c', |
|
2766
|
'\uA73F': 'c', |
|
2767
|
'\u2184': 'c', |
|
2768
|
'\u24D3': 'd', |
|
2769
|
'\uFF44': 'd', |
|
2770
|
'\u1E0B': 'd', |
|
2771
|
'\u010F': 'd', |
|
2772
|
'\u1E0D': 'd', |
|
2773
|
'\u1E11': 'd', |
|
2774
|
'\u1E13': 'd', |
|
2775
|
'\u1E0F': 'd', |
|
2776
|
'\u0111': 'd', |
|
2777
|
'\u018C': 'd', |
|
2778
|
'\u0256': 'd', |
|
2779
|
'\u0257': 'd', |
|
2780
|
'\uA77A': 'd', |
|
2781
|
'\u01F3': 'dz', |
|
2782
|
'\u01C6': 'dz', |
|
2783
|
'\u24D4': 'e', |
|
2784
|
'\uFF45': 'e', |
|
2785
|
'\u00E8': 'e', |
|
2786
|
'\u00E9': 'e', |
|
2787
|
'\u00EA': 'e', |
|
2788
|
'\u1EC1': 'e', |
|
2789
|
'\u1EBF': 'e', |
|
2790
|
'\u1EC5': 'e', |
|
2791
|
'\u1EC3': 'e', |
|
2792
|
'\u1EBD': 'e', |
|
2793
|
'\u0113': 'e', |
|
2794
|
'\u1E15': 'e', |
|
2795
|
'\u1E17': 'e', |
|
2796
|
'\u0115': 'e', |
|
2797
|
'\u0117': 'e', |
|
2798
|
'\u00EB': 'e', |
|
2799
|
'\u1EBB': 'e', |
|
2800
|
'\u011B': 'e', |
|
2801
|
'\u0205': 'e', |
|
2802
|
'\u0207': 'e', |
|
2803
|
'\u1EB9': 'e', |
|
2804
|
'\u1EC7': 'e', |
|
2805
|
'\u0229': 'e', |
|
2806
|
'\u1E1D': 'e', |
|
2807
|
'\u0119': 'e', |
|
2808
|
'\u1E19': 'e', |
|
2809
|
'\u1E1B': 'e', |
|
2810
|
'\u0247': 'e', |
|
2811
|
'\u025B': 'e', |
|
2812
|
'\u01DD': 'e', |
|
2813
|
'\u24D5': 'f', |
|
2814
|
'\uFF46': 'f', |
|
2815
|
'\u1E1F': 'f', |
|
2816
|
'\u0192': 'f', |
|
2817
|
'\uA77C': 'f', |
|
2818
|
'\u24D6': 'g', |
|
2819
|
'\uFF47': 'g', |
|
2820
|
'\u01F5': 'g', |
|
2821
|
'\u011D': 'g', |
|
2822
|
'\u1E21': 'g', |
|
2823
|
'\u011F': 'g', |
|
2824
|
'\u0121': 'g', |
|
2825
|
'\u01E7': 'g', |
|
2826
|
'\u0123': 'g', |
|
2827
|
'\u01E5': 'g', |
|
2828
|
'\u0260': 'g', |
|
2829
|
'\uA7A1': 'g', |
|
2830
|
'\u1D79': 'g', |
|
2831
|
'\uA77F': 'g', |
|
2832
|
'\u24D7': 'h', |
|
2833
|
'\uFF48': 'h', |
|
2834
|
'\u0125': 'h', |
|
2835
|
'\u1E23': 'h', |
|
2836
|
'\u1E27': 'h', |
|
2837
|
'\u021F': 'h', |
|
2838
|
'\u1E25': 'h', |
|
2839
|
'\u1E29': 'h', |
|
2840
|
'\u1E2B': 'h', |
|
2841
|
'\u1E96': 'h', |
|
2842
|
'\u0127': 'h', |
|
2843
|
'\u2C68': 'h', |
|
2844
|
'\u2C76': 'h', |
|
2845
|
'\u0265': 'h', |
|
2846
|
'\u0195': 'hv', |
|
2847
|
'\u24D8': 'i', |
|
2848
|
'\uFF49': 'i', |
|
2849
|
'\u00EC': 'i', |
|
2850
|
'\u00ED': 'i', |
|
2851
|
'\u00EE': 'i', |
|
2852
|
'\u0129': 'i', |
|
2853
|
'\u012B': 'i', |
|
2854
|
'\u012D': 'i', |
|
2855
|
'\u00EF': 'i', |
|
2856
|
'\u1E2F': 'i', |
|
2857
|
'\u1EC9': 'i', |
|
2858
|
'\u01D0': 'i', |
|
2859
|
'\u0209': 'i', |
|
2860
|
'\u020B': 'i', |
|
2861
|
'\u1ECB': 'i', |
|
2862
|
'\u012F': 'i', |
|
2863
|
'\u1E2D': 'i', |
|
2864
|
'\u0268': 'i', |
|
2865
|
'\u0131': 'i', |
|
2866
|
'\u24D9': 'j', |
|
2867
|
'\uFF4A': 'j', |
|
2868
|
'\u0135': 'j', |
|
2869
|
'\u01F0': 'j', |
|
2870
|
'\u0249': 'j', |
|
2871
|
'\u24DA': 'k', |
|
2872
|
'\uFF4B': 'k', |
|
2873
|
'\u1E31': 'k', |
|
2874
|
'\u01E9': 'k', |
|
2875
|
'\u1E33': 'k', |
|
2876
|
'\u0137': 'k', |
|
2877
|
'\u1E35': 'k', |
|
2878
|
'\u0199': 'k', |
|
2879
|
'\u2C6A': 'k', |
|
2880
|
'\uA741': 'k', |
|
2881
|
'\uA743': 'k', |
|
2882
|
'\uA745': 'k', |
|
2883
|
'\uA7A3': 'k', |
|
2884
|
'\u24DB': 'l', |
|
2885
|
'\uFF4C': 'l', |
|
2886
|
'\u0140': 'l', |
|
2887
|
'\u013A': 'l', |
|
2888
|
'\u013E': 'l', |
|
2889
|
'\u1E37': 'l', |
|
2890
|
'\u1E39': 'l', |
|
2891
|
'\u013C': 'l', |
|
2892
|
'\u1E3D': 'l', |
|
2893
|
'\u1E3B': 'l', |
|
2894
|
'\u017F': 'l', |
|
2895
|
'\u0142': 'l', |
|
2896
|
'\u019A': 'l', |
|
2897
|
'\u026B': 'l', |
|
2898
|
'\u2C61': 'l', |
|
2899
|
'\uA749': 'l', |
|
2900
|
'\uA781': 'l', |
|
2901
|
'\uA747': 'l', |
|
2902
|
'\u01C9': 'lj', |
|
2903
|
'\u24DC': 'm', |
|
2904
|
'\uFF4D': 'm', |
|
2905
|
'\u1E3F': 'm', |
|
2906
|
'\u1E41': 'm', |
|
2907
|
'\u1E43': 'm', |
|
2908
|
'\u0271': 'm', |
|
2909
|
'\u026F': 'm', |
|
2910
|
'\u24DD': 'n', |
|
2911
|
'\uFF4E': 'n', |
|
2912
|
'\u01F9': 'n', |
|
2913
|
'\u0144': 'n', |
|
2914
|
'\u00F1': 'n', |
|
2915
|
'\u1E45': 'n', |
|
2916
|
'\u0148': 'n', |
|
2917
|
'\u1E47': 'n', |
|
2918
|
'\u0146': 'n', |
|
2919
|
'\u1E4B': 'n', |
|
2920
|
'\u1E49': 'n', |
|
2921
|
'\u019E': 'n', |
|
2922
|
'\u0272': 'n', |
|
2923
|
'\u0149': 'n', |
|
2924
|
'\uA791': 'n', |
|
2925
|
'\uA7A5': 'n', |
|
2926
|
'\u01CC': 'nj', |
|
2927
|
'\u24DE': 'o', |
|
2928
|
'\uFF4F': 'o', |
|
2929
|
'\u00F2': 'o', |
|
2930
|
'\u00F3': 'o', |
|
2931
|
'\u00F4': 'o', |
|
2932
|
'\u1ED3': 'o', |
|
2933
|
'\u1ED1': 'o', |
|
2934
|
'\u1ED7': 'o', |
|
2935
|
'\u1ED5': 'o', |
|
2936
|
'\u00F5': 'o', |
|
2937
|
'\u1E4D': 'o', |
|
2938
|
'\u022D': 'o', |
|
2939
|
'\u1E4F': 'o', |
|
2940
|
'\u014D': 'o', |
|
2941
|
'\u1E51': 'o', |
|
2942
|
'\u1E53': 'o', |
|
2943
|
'\u014F': 'o', |
|
2944
|
'\u022F': 'o', |
|
2945
|
'\u0231': 'o', |
|
2946
|
'\u00F6': 'o', |
|
2947
|
'\u022B': 'o', |
|
2948
|
'\u1ECF': 'o', |
|
2949
|
'\u0151': 'o', |
|
2950
|
'\u01D2': 'o', |
|
2951
|
'\u020D': 'o', |
|
2952
|
'\u020F': 'o', |
|
2953
|
'\u01A1': 'o', |
|
2954
|
'\u1EDD': 'o', |
|
2955
|
'\u1EDB': 'o', |
|
2956
|
'\u1EE1': 'o', |
|
2957
|
'\u1EDF': 'o', |
|
2958
|
'\u1EE3': 'o', |
|
2959
|
'\u1ECD': 'o', |
|
2960
|
'\u1ED9': 'o', |
|
2961
|
'\u01EB': 'o', |
|
2962
|
'\u01ED': 'o', |
|
2963
|
'\u00F8': 'o', |
|
2964
|
'\u01FF': 'o', |
|
2965
|
'\u0254': 'o', |
|
2966
|
'\uA74B': 'o', |
|
2967
|
'\uA74D': 'o', |
|
2968
|
'\u0275': 'o', |
|
2969
|
'\u0153': 'oe', |
|
2970
|
'\u01A3': 'oi', |
|
2971
|
'\u0223': 'ou', |
|
2972
|
'\uA74F': 'oo', |
|
2973
|
'\u24DF': 'p', |
|
2974
|
'\uFF50': 'p', |
|
2975
|
'\u1E55': 'p', |
|
2976
|
'\u1E57': 'p', |
|
2977
|
'\u01A5': 'p', |
|
2978
|
'\u1D7D': 'p', |
|
2979
|
'\uA751': 'p', |
|
2980
|
'\uA753': 'p', |
|
2981
|
'\uA755': 'p', |
|
2982
|
'\u24E0': 'q', |
|
2983
|
'\uFF51': 'q', |
|
2984
|
'\u024B': 'q', |
|
2985
|
'\uA757': 'q', |
|
2986
|
'\uA759': 'q', |
|
2987
|
'\u24E1': 'r', |
|
2988
|
'\uFF52': 'r', |
|
2989
|
'\u0155': 'r', |
|
2990
|
'\u1E59': 'r', |
|
2991
|
'\u0159': 'r', |
|
2992
|
'\u0211': 'r', |
|
2993
|
'\u0213': 'r', |
|
2994
|
'\u1E5B': 'r', |
|
2995
|
'\u1E5D': 'r', |
|
2996
|
'\u0157': 'r', |
|
2997
|
'\u1E5F': 'r', |
|
2998
|
'\u024D': 'r', |
|
2999
|
'\u027D': 'r', |
|
3000
|
'\uA75B': 'r', |
|
3001
|
'\uA7A7': 'r', |
|
3002
|
'\uA783': 'r', |
|
3003
|
'\u24E2': 's', |
|
3004
|
'\uFF53': 's', |
|
3005
|
'\u00DF': 's', |
|
3006
|
'\u015B': 's', |
|
3007
|
'\u1E65': 's', |
|
3008
|
'\u015D': 's', |
|
3009
|
'\u1E61': 's', |
|
3010
|
'\u0161': 's', |
|
3011
|
'\u1E67': 's', |
|
3012
|
'\u1E63': 's', |
|
3013
|
'\u1E69': 's', |
|
3014
|
'\u0219': 's', |
|
3015
|
'\u015F': 's', |
|
3016
|
'\u023F': 's', |
|
3017
|
'\uA7A9': 's', |
|
3018
|
'\uA785': 's', |
|
3019
|
'\u1E9B': 's', |
|
3020
|
'\u24E3': 't', |
|
3021
|
'\uFF54': 't', |
|
3022
|
'\u1E6B': 't', |
|
3023
|
'\u1E97': 't', |
|
3024
|
'\u0165': 't', |
|
3025
|
'\u1E6D': 't', |
|
3026
|
'\u021B': 't', |
|
3027
|
'\u0163': 't', |
|
3028
|
'\u1E71': 't', |
|
3029
|
'\u1E6F': 't', |
|
3030
|
'\u0167': 't', |
|
3031
|
'\u01AD': 't', |
|
3032
|
'\u0288': 't', |
|
3033
|
'\u2C66': 't', |
|
3034
|
'\uA787': 't', |
|
3035
|
'\uA729': 'tz', |
|
3036
|
'\u24E4': 'u', |
|
3037
|
'\uFF55': 'u', |
|
3038
|
'\u00F9': 'u', |
|
3039
|
'\u00FA': 'u', |
|
3040
|
'\u00FB': 'u', |
|
3041
|
'\u0169': 'u', |
|
3042
|
'\u1E79': 'u', |
|
3043
|
'\u016B': 'u', |
|
3044
|
'\u1E7B': 'u', |
|
3045
|
'\u016D': 'u', |
|
3046
|
'\u00FC': 'u', |
|
3047
|
'\u01DC': 'u', |
|
3048
|
'\u01D8': 'u', |
|
3049
|
'\u01D6': 'u', |
|
3050
|
'\u01DA': 'u', |
|
3051
|
'\u1EE7': 'u', |
|
3052
|
'\u016F': 'u', |
|
3053
|
'\u0171': 'u', |
|
3054
|
'\u01D4': 'u', |
|
3055
|
'\u0215': 'u', |
|
3056
|
'\u0217': 'u', |
|
3057
|
'\u01B0': 'u', |
|
3058
|
'\u1EEB': 'u', |
|
3059
|
'\u1EE9': 'u', |
|
3060
|
'\u1EEF': 'u', |
|
3061
|
'\u1EED': 'u', |
|
3062
|
'\u1EF1': 'u', |
|
3063
|
'\u1EE5': 'u', |
|
3064
|
'\u1E73': 'u', |
|
3065
|
'\u0173': 'u', |
|
3066
|
'\u1E77': 'u', |
|
3067
|
'\u1E75': 'u', |
|
3068
|
'\u0289': 'u', |
|
3069
|
'\u24E5': 'v', |
|
3070
|
'\uFF56': 'v', |
|
3071
|
'\u1E7D': 'v', |
|
3072
|
'\u1E7F': 'v', |
|
3073
|
'\u028B': 'v', |
|
3074
|
'\uA75F': 'v', |
|
3075
|
'\u028C': 'v', |
|
3076
|
'\uA761': 'vy', |
|
3077
|
'\u24E6': 'w', |
|
3078
|
'\uFF57': 'w', |
|
3079
|
'\u1E81': 'w', |
|
3080
|
'\u1E83': 'w', |
|
3081
|
'\u0175': 'w', |
|
3082
|
'\u1E87': 'w', |
|
3083
|
'\u1E85': 'w', |
|
3084
|
'\u1E98': 'w', |
|
3085
|
'\u1E89': 'w', |
|
3086
|
'\u2C73': 'w', |
|
3087
|
'\u24E7': 'x', |
|
3088
|
'\uFF58': 'x', |
|
3089
|
'\u1E8B': 'x', |
|
3090
|
'\u1E8D': 'x', |
|
3091
|
'\u24E8': 'y', |
|
3092
|
'\uFF59': 'y', |
|
3093
|
'\u1EF3': 'y', |
|
3094
|
'\u00FD': 'y', |
|
3095
|
'\u0177': 'y', |
|
3096
|
'\u1EF9': 'y', |
|
3097
|
'\u0233': 'y', |
|
3098
|
'\u1E8F': 'y', |
|
3099
|
'\u00FF': 'y', |
|
3100
|
'\u1EF7': 'y', |
|
3101
|
'\u1E99': 'y', |
|
3102
|
'\u1EF5': 'y', |
|
3103
|
'\u01B4': 'y', |
|
3104
|
'\u024F': 'y', |
|
3105
|
'\u1EFF': 'y', |
|
3106
|
'\u24E9': 'z', |
|
3107
|
'\uFF5A': 'z', |
|
3108
|
'\u017A': 'z', |
|
3109
|
'\u1E91': 'z', |
|
3110
|
'\u017C': 'z', |
|
3111
|
'\u017E': 'z', |
|
3112
|
'\u1E93': 'z', |
|
3113
|
'\u1E95': 'z', |
|
3114
|
'\u01B6': 'z', |
|
3115
|
'\u0225': 'z', |
|
3116
|
'\u0240': 'z', |
|
3117
|
'\u2C6C': 'z', |
|
3118
|
'\uA763': 'z', |
|
3119
|
'\u0386': '\u0391', |
|
3120
|
'\u0388': '\u0395', |
|
3121
|
'\u0389': '\u0397', |
|
3122
|
'\u038A': '\u0399', |
|
3123
|
'\u03AA': '\u0399', |
|
3124
|
'\u038C': '\u039F', |
|
3125
|
'\u038E': '\u03A5', |
|
3126
|
'\u03AB': '\u03A5', |
|
3127
|
'\u038F': '\u03A9', |
|
3128
|
'\u03AC': '\u03B1', |
|
3129
|
'\u03AD': '\u03B5', |
|
3130
|
'\u03AE': '\u03B7', |
|
3131
|
'\u03AF': '\u03B9', |
|
3132
|
'\u03CA': '\u03B9', |
|
3133
|
'\u0390': '\u03B9', |
|
3134
|
'\u03CC': '\u03BF', |
|
3135
|
'\u03CD': '\u03C5', |
|
3136
|
'\u03CB': '\u03C5', |
|
3137
|
'\u03B0': '\u03C5', |
|
3138
|
'\u03CE': '\u03C9', |
|
3139
|
'\u03C2': '\u03C3', |
|
3140
|
'\u2019': '\'' |
|
3141
|
}; |
|
3142
|
|
|
3143
|
return diacritics; |
|
3144
|
}); |
|
3145
|
|
|
3146
|
S2.define('select2/data/base',[ |
|
3147
|
'../utils' |
|
3148
|
], function (Utils) { |
|
3149
|
function BaseAdapter ($element, options) { |
|
3150
|
BaseAdapter.__super__.constructor.call(this); |
|
3151
|
} |
|
3152
|
|
|
3153
|
Utils.Extend(BaseAdapter, Utils.Observable); |
|
3154
|
|
|
3155
|
BaseAdapter.prototype.current = function (callback) { |
|
3156
|
throw new Error('The `current` method must be defined in child classes.'); |
|
3157
|
}; |
|
3158
|
|
|
3159
|
BaseAdapter.prototype.query = function (params, callback) { |
|
3160
|
throw new Error('The `query` method must be defined in child classes.'); |
|
3161
|
}; |
|
3162
|
|
|
3163
|
BaseAdapter.prototype.bind = function (container, $container) { |
|
3164
|
// Can be implemented in subclasses |
|
3165
|
}; |
|
3166
|
|
|
3167
|
BaseAdapter.prototype.destroy = function () { |
|
3168
|
// Can be implemented in subclasses |
|
3169
|
}; |
|
3170
|
|
|
3171
|
BaseAdapter.prototype.generateResultId = function (container, data) { |
|
3172
|
var id = container.id + '-result-'; |
|
3173
|
|
|
3174
|
id += Utils.generateChars(4); |
|
3175
|
|
|
3176
|
if (data.id != null) { |
|
3177
|
id += '-' + data.id.toString(); |
|
3178
|
} else { |
|
3179
|
id += '-' + Utils.generateChars(4); |
|
3180
|
} |
|
3181
|
return id; |
|
3182
|
}; |
|
3183
|
|
|
3184
|
return BaseAdapter; |
|
3185
|
}); |
|
3186
|
|
|
3187
|
S2.define('select2/data/select',[ |
|
3188
|
'./base', |
|
3189
|
'../utils', |
|
3190
|
'jquery' |
|
3191
|
], function (BaseAdapter, Utils, $) { |
|
3192
|
function SelectAdapter ($element, options) { |
|
3193
|
this.$element = $element; |
|
3194
|
this.options = options; |
|
3195
|
|
|
3196
|
SelectAdapter.__super__.constructor.call(this); |
|
3197
|
} |
|
3198
|
|
|
3199
|
Utils.Extend(SelectAdapter, BaseAdapter); |
|
3200
|
|
|
3201
|
SelectAdapter.prototype.current = function (callback) { |
|
3202
|
var data = []; |
|
3203
|
var self = this; |
|
3204
|
|
|
3205
|
this.$element.find(':selected').each(function () { |
|
3206
|
var $option = $(this); |
|
3207
|
|
|
3208
|
var option = self.item($option); |
|
3209
|
|
|
3210
|
data.push(option); |
|
3211
|
}); |
|
3212
|
|
|
3213
|
callback(data); |
|
3214
|
}; |
|
3215
|
|
|
3216
|
SelectAdapter.prototype.select = function (data) { |
|
3217
|
var self = this; |
|
3218
|
|
|
3219
|
data.selected = true; |
|
3220
|
|
|
3221
|
// If data.element is a DOM node, use it instead |
|
3222
|
if ($(data.element).is('option')) { |
|
3223
|
data.element.selected = true; |
|
3224
|
|
|
3225
|
this.$element.trigger('input').trigger('change'); |
|
3226
|
|
|
3227
|
return; |
|
3228
|
} |
|
3229
|
|
|
3230
|
if (this.$element.prop('multiple')) { |
|
3231
|
this.current(function (currentData) { |
|
3232
|
var val = []; |
|
3233
|
|
|
3234
|
data = [data]; |
|
3235
|
data.push.apply(data, currentData); |
|
3236
|
|
|
3237
|
for (var d = 0; d < data.length; d++) { |
|
3238
|
var id = data[d].id; |
|
3239
|
|
|
3240
|
if ($.inArray(id, val) === -1) { |
|
3241
|
val.push(id); |
|
3242
|
} |
|
3243
|
} |
|
3244
|
|
|
3245
|
self.$element.val(val); |
|
3246
|
self.$element.trigger('input').trigger('change'); |
|
3247
|
}); |
|
3248
|
} else { |
|
3249
|
var val = data.id; |
|
3250
|
|
|
3251
|
this.$element.val(val); |
|
3252
|
this.$element.trigger('input').trigger('change'); |
|
3253
|
} |
|
3254
|
}; |
|
3255
|
|
|
3256
|
SelectAdapter.prototype.unselect = function (data) { |
|
3257
|
var self = this; |
|
3258
|
|
|
3259
|
if (!this.$element.prop('multiple')) { |
|
3260
|
return; |
|
3261
|
} |
|
3262
|
|
|
3263
|
data.selected = false; |
|
3264
|
|
|
3265
|
if ($(data.element).is('option')) { |
|
3266
|
data.element.selected = false; |
|
3267
|
|
|
3268
|
this.$element.trigger('input').trigger('change'); |
|
3269
|
|
|
3270
|
return; |
|
3271
|
} |
|
3272
|
|
|
3273
|
this.current(function (currentData) { |
|
3274
|
var val = []; |
|
3275
|
|
|
3276
|
for (var d = 0; d < currentData.length; d++) { |
|
3277
|
var id = currentData[d].id; |
|
3278
|
|
|
3279
|
if (id !== data.id && $.inArray(id, val) === -1) { |
|
3280
|
val.push(id); |
|
3281
|
} |
|
3282
|
} |
|
3283
|
|
|
3284
|
self.$element.val(val); |
|
3285
|
|
|
3286
|
self.$element.trigger('input').trigger('change'); |
|
3287
|
}); |
|
3288
|
}; |
|
3289
|
|
|
3290
|
SelectAdapter.prototype.bind = function (container, $container) { |
|
3291
|
var self = this; |
|
3292
|
|
|
3293
|
this.container = container; |
|
3294
|
|
|
3295
|
container.on('select', function (params) { |
|
3296
|
self.select(params.data); |
|
3297
|
}); |
|
3298
|
|
|
3299
|
container.on('unselect', function (params) { |
|
3300
|
self.unselect(params.data); |
|
3301
|
}); |
|
3302
|
}; |
|
3303
|
|
|
3304
|
SelectAdapter.prototype.destroy = function () { |
|
3305
|
// Remove anything added to child elements |
|
3306
|
this.$element.find('*').each(function () { |
|
3307
|
// Remove any custom data set by Select2 |
|
3308
|
Utils.RemoveData(this); |
|
3309
|
}); |
|
3310
|
}; |
|
3311
|
|
|
3312
|
SelectAdapter.prototype.query = function (params, callback) { |
|
3313
|
var data = []; |
|
3314
|
var self = this; |
|
3315
|
|
|
3316
|
var $options = this.$element.children(); |
|
3317
|
|
|
3318
|
$options.each(function () { |
|
3319
|
var $option = $(this); |
|
3320
|
|
|
3321
|
if (!$option.is('option') && !$option.is('optgroup')) { |
|
3322
|
return; |
|
3323
|
} |
|
3324
|
|
|
3325
|
var option = self.item($option); |
|
3326
|
|
|
3327
|
var matches = self.matches(params, option); |
|
3328
|
|
|
3329
|
if (matches !== null) { |
|
3330
|
data.push(matches); |
|
3331
|
} |
|
3332
|
}); |
|
3333
|
|
|
3334
|
callback({ |
|
3335
|
results: data |
|
3336
|
}); |
|
3337
|
}; |
|
3338
|
|
|
3339
|
SelectAdapter.prototype.addOptions = function ($options) { |
|
3340
|
Utils.appendMany(this.$element, $options); |
|
3341
|
}; |
|
3342
|
|
|
3343
|
SelectAdapter.prototype.option = function (data) { |
|
3344
|
var option; |
|
3345
|
|
|
3346
|
if (data.children) { |
|
3347
|
option = document.createElement('optgroup'); |
|
3348
|
option.label = data.text; |
|
3349
|
} else { |
|
3350
|
option = document.createElement('option'); |
|
3351
|
|
|
3352
|
if (option.textContent !== undefined) { |
|
3353
|
option.textContent = data.text; |
|
3354
|
} else { |
|
3355
|
option.innerText = data.text; |
|
3356
|
} |
|
3357
|
} |
|
3358
|
|
|
3359
|
if (data.id !== undefined) { |
|
3360
|
option.value = data.id; |
|
3361
|
} |
|
3362
|
|
|
3363
|
if (data.disabled) { |
|
3364
|
option.disabled = true; |
|
3365
|
} |
|
3366
|
|
|
3367
|
if (data.selected) { |
|
3368
|
option.selected = true; |
|
3369
|
} |
|
3370
|
|
|
3371
|
if (data.title) { |
|
3372
|
option.title = data.title; |
|
3373
|
} |
|
3374
|
|
|
3375
|
var $option = $(option); |
|
3376
|
|
|
3377
|
var normalizedData = this._normalizeItem(data); |
|
3378
|
normalizedData.element = option; |
|
3379
|
|
|
3380
|
// Override the option's data with the combined data |
|
3381
|
Utils.StoreData(option, 'data', normalizedData); |
|
3382
|
|
|
3383
|
return $option; |
|
3384
|
}; |
|
3385
|
|
|
3386
|
SelectAdapter.prototype.item = function ($option) { |
|
3387
|
var data = {}; |
|
3388
|
|
|
3389
|
data = Utils.GetData($option[0], 'data'); |
|
3390
|
|
|
3391
|
if (data != null) { |
|
3392
|
return data; |
|
3393
|
} |
|
3394
|
|
|
3395
|
if ($option.is('option')) { |
|
3396
|
data = { |
|
3397
|
id: $option.val(), |
|
3398
|
text: $option.text(), |
|
3399
|
disabled: $option.prop('disabled'), |
|
3400
|
selected: $option.prop('selected'), |
|
3401
|
title: $option.prop('title') |
|
3402
|
}; |
|
3403
|
} else if ($option.is('optgroup')) { |
|
3404
|
data = { |
|
3405
|
text: $option.prop('label'), |
|
3406
|
children: [], |
|
3407
|
title: $option.prop('title') |
|
3408
|
}; |
|
3409
|
|
|
3410
|
var $children = $option.children('option'); |
|
3411
|
var children = []; |
|
3412
|
|
|
3413
|
for (var c = 0; c < $children.length; c++) { |
|
3414
|
var $child = $($children[c]); |
|
3415
|
|
|
3416
|
var child = this.item($child); |
|
3417
|
|
|
3418
|
children.push(child); |
|
3419
|
} |
|
3420
|
|
|
3421
|
data.children = children; |
|
3422
|
} |
|
3423
|
|
|
3424
|
data = this._normalizeItem(data); |
|
3425
|
data.element = $option[0]; |
|
3426
|
|
|
3427
|
Utils.StoreData($option[0], 'data', data); |
|
3428
|
|
|
3429
|
return data; |
|
3430
|
}; |
|
3431
|
|
|
3432
|
SelectAdapter.prototype._normalizeItem = function (item) { |
|
3433
|
if (item !== Object(item)) { |
|
3434
|
item = { |
|
3435
|
id: item, |
|
3436
|
text: item |
|
3437
|
}; |
|
3438
|
} |
|
3439
|
|
|
3440
|
item = $.extend({}, { |
|
3441
|
text: '' |
|
3442
|
}, item); |
|
3443
|
|
|
3444
|
var defaults = { |
|
3445
|
selected: false, |
|
3446
|
disabled: false |
|
3447
|
}; |
|
3448
|
|
|
3449
|
if (item.id != null) { |
|
3450
|
item.id = item.id.toString(); |
|
3451
|
} |
|
3452
|
|
|
3453
|
if (item.text != null) { |
|
3454
|
item.text = item.text.toString(); |
|
3455
|
} |
|
3456
|
|
|
3457
|
if (item._resultId == null && item.id && this.container != null) { |
|
3458
|
item._resultId = this.generateResultId(this.container, item); |
|
3459
|
} |
|
3460
|
|
|
3461
|
return $.extend({}, defaults, item); |
|
3462
|
}; |
|
3463
|
|
|
3464
|
SelectAdapter.prototype.matches = function (params, data) { |
|
3465
|
var matcher = this.options.get('matcher'); |
|
3466
|
|
|
3467
|
return matcher(params, data); |
|
3468
|
}; |
|
3469
|
|
|
3470
|
return SelectAdapter; |
|
3471
|
}); |
|
3472
|
|
|
3473
|
S2.define('select2/data/array',[ |
|
3474
|
'./select', |
|
3475
|
'../utils', |
|
3476
|
'jquery' |
|
3477
|
], function (SelectAdapter, Utils, $) { |
|
3478
|
function ArrayAdapter ($element, options) { |
|
3479
|
this._dataToConvert = options.get('data') || []; |
|
3480
|
|
|
3481
|
ArrayAdapter.__super__.constructor.call(this, $element, options); |
|
3482
|
} |
|
3483
|
|
|
3484
|
Utils.Extend(ArrayAdapter, SelectAdapter); |
|
3485
|
|
|
3486
|
ArrayAdapter.prototype.bind = function (container, $container) { |
|
3487
|
ArrayAdapter.__super__.bind.call(this, container, $container); |
|
3488
|
|
|
3489
|
this.addOptions(this.convertToOptions(this._dataToConvert)); |
|
3490
|
}; |
|
3491
|
|
|
3492
|
ArrayAdapter.prototype.select = function (data) { |
|
3493
|
var $option = this.$element.find('option').filter(function (i, elm) { |
|
3494
|
return elm.value == data.id.toString(); |
|
3495
|
}); |
|
3496
|
|
|
3497
|
if ($option.length === 0) { |
|
3498
|
$option = this.option(data); |
|
3499
|
|
|
3500
|
this.addOptions($option); |
|
3501
|
} |
|
3502
|
|
|
3503
|
ArrayAdapter.__super__.select.call(this, data); |
|
3504
|
}; |
|
3505
|
|
|
3506
|
ArrayAdapter.prototype.convertToOptions = function (data) { |
|
3507
|
var self = this; |
|
3508
|
|
|
3509
|
var $existing = this.$element.find('option'); |
|
3510
|
var existingIds = $existing.map(function () { |
|
3511
|
return self.item($(this)).id; |
|
3512
|
}).get(); |
|
3513
|
|
|
3514
|
var $options = []; |
|
3515
|
|
|
3516
|
// Filter out all items except for the one passed in the argument |
|
3517
|
function onlyItem (item) { |
|
3518
|
return function () { |
|
3519
|
return $(this).val() == item.id; |
|
3520
|
}; |
|
3521
|
} |
|
3522
|
|
|
3523
|
for (var d = 0; d < data.length; d++) { |
|
3524
|
var item = this._normalizeItem(data[d]); |
|
3525
|
|
|
3526
|
// Skip items which were pre-loaded, only merge the data |
|
3527
|
if ($.inArray(item.id, existingIds) >= 0) { |
|
3528
|
var $existingOption = $existing.filter(onlyItem(item)); |
|
3529
|
|
|
3530
|
var existingData = this.item($existingOption); |
|
3531
|
var newData = $.extend(true, {}, item, existingData); |
|
3532
|
|
|
3533
|
var $newOption = this.option(newData); |
|
3534
|
|
|
3535
|
$existingOption.replaceWith($newOption); |
|
3536
|
|
|
3537
|
continue; |
|
3538
|
} |
|
3539
|
|
|
3540
|
var $option = this.option(item); |
|
3541
|
|
|
3542
|
if (item.children) { |
|
3543
|
var $children = this.convertToOptions(item.children); |
|
3544
|
|
|
3545
|
Utils.appendMany($option, $children); |
|
3546
|
} |
|
3547
|
|
|
3548
|
$options.push($option); |
|
3549
|
} |
|
3550
|
|
|
3551
|
return $options; |
|
3552
|
}; |
|
3553
|
|
|
3554
|
return ArrayAdapter; |
|
3555
|
}); |
|
3556
|
|
|
3557
|
S2.define('select2/data/ajax',[ |
|
3558
|
'./array', |
|
3559
|
'../utils', |
|
3560
|
'jquery' |
|
3561
|
], function (ArrayAdapter, Utils, $) { |
|
3562
|
function AjaxAdapter ($element, options) { |
|
3563
|
this.ajaxOptions = this._applyDefaults(options.get('ajax')); |
|
3564
|
|
|
3565
|
if (this.ajaxOptions.processResults != null) { |
|
3566
|
this.processResults = this.ajaxOptions.processResults; |
|
3567
|
} |
|
3568
|
|
|
3569
|
AjaxAdapter.__super__.constructor.call(this, $element, options); |
|
3570
|
} |
|
3571
|
|
|
3572
|
Utils.Extend(AjaxAdapter, ArrayAdapter); |
|
3573
|
|
|
3574
|
AjaxAdapter.prototype._applyDefaults = function (options) { |
|
3575
|
var defaults = { |
|
3576
|
data: function (params) { |
|
3577
|
return $.extend({}, params, { |
|
3578
|
q: params.term |
|
3579
|
}); |
|
3580
|
}, |
|
3581
|
transport: function (params, success, failure) { |
|
3582
|
var $request = $.ajax(params); |
|
3583
|
|
|
3584
|
$request.then(success); |
|
3585
|
$request.fail(failure); |
|
3586
|
|
|
3587
|
return $request; |
|
3588
|
} |
|
3589
|
}; |
|
3590
|
|
|
3591
|
return $.extend({}, defaults, options, true); |
|
3592
|
}; |
|
3593
|
|
|
3594
|
AjaxAdapter.prototype.processResults = function (results) { |
|
3595
|
return results; |
|
3596
|
}; |
|
3597
|
|
|
3598
|
AjaxAdapter.prototype.query = function (params, callback) { |
|
3599
|
var matches = []; |
|
3600
|
var self = this; |
|
3601
|
|
|
3602
|
if (this._request != null) { |
|
3603
|
// JSONP requests cannot always be aborted |
|
3604
|
if ($.isFunction(this._request.abort)) { |
|
3605
|
this._request.abort(); |
|
3606
|
} |
|
3607
|
|
|
3608
|
this._request = null; |
|
3609
|
} |
|
3610
|
|
|
3611
|
var options = $.extend({ |
|
3612
|
type: 'GET' |
|
3613
|
}, this.ajaxOptions); |
|
3614
|
|
|
3615
|
if (typeof options.url === 'function') { |
|
3616
|
options.url = options.url.call(this.$element, params); |
|
3617
|
} |
|
3618
|
|
|
3619
|
if (typeof options.data === 'function') { |
|
3620
|
options.data = options.data.call(this.$element, params); |
|
3621
|
} |
|
3622
|
|
|
3623
|
function request () { |
|
3624
|
var $request = options.transport(options, function (data) { |
|
3625
|
var results = self.processResults(data, params); |
|
3626
|
|
|
3627
|
if (self.options.get('debug') && window.console && console.error) { |
|
3628
|
// Check to make sure that the response included a `results` key. |
|
3629
|
if (!results || !results.results || !$.isArray(results.results)) { |
|
3630
|
console.error( |
|
3631
|
'Select2: The AJAX results did not return an array in the ' + |
|
3632
|
'`results` key of the response.' |
|
3633
|
); |
|
3634
|
} |
|
3635
|
} |
|
3636
|
|
|
3637
|
callback(results); |
|
3638
|
}, function () { |
|
3639
|
// Attempt to detect if a request was aborted |
|
3640
|
// Only works if the transport exposes a status property |
|
3641
|
if ('status' in $request && |
|
3642
|
($request.status === 0 || $request.status === '0')) { |
|
3643
|
return; |
|
3644
|
} |
|
3645
|
|
|
3646
|
self.trigger('results:message', { |
|
3647
|
message: 'errorLoading' |
|
3648
|
}); |
|
3649
|
}); |
|
3650
|
|
|
3651
|
self._request = $request; |
|
3652
|
} |
|
3653
|
|
|
3654
|
if (this.ajaxOptions.delay && params.term != null) { |
|
3655
|
if (this._queryTimeout) { |
|
3656
|
window.clearTimeout(this._queryTimeout); |
|
3657
|
} |
|
3658
|
|
|
3659
|
this._queryTimeout = window.setTimeout(request, this.ajaxOptions.delay); |
|
3660
|
} else { |
|
3661
|
request(); |
|
3662
|
} |
|
3663
|
}; |
|
3664
|
|
|
3665
|
return AjaxAdapter; |
|
3666
|
}); |
|
3667
|
|
|
3668
|
S2.define('select2/data/tags',[ |
|
3669
|
'jquery' |
|
3670
|
], function ($) { |
|
3671
|
function Tags (decorated, $element, options) { |
|
3672
|
var tags = options.get('tags'); |
|
3673
|
|
|
3674
|
var createTag = options.get('createTag'); |
|
3675
|
|
|
3676
|
if (createTag !== undefined) { |
|
3677
|
this.createTag = createTag; |
|
3678
|
} |
|
3679
|
|
|
3680
|
var insertTag = options.get('insertTag'); |
|
3681
|
|
|
3682
|
if (insertTag !== undefined) { |
|
3683
|
this.insertTag = insertTag; |
|
3684
|
} |
|
3685
|
|
|
3686
|
decorated.call(this, $element, options); |
|
3687
|
|
|
3688
|
if ($.isArray(tags)) { |
|
3689
|
for (var t = 0; t < tags.length; t++) { |
|
3690
|
var tag = tags[t]; |
|
3691
|
var item = this._normalizeItem(tag); |
|
3692
|
|
|
3693
|
var $option = this.option(item); |
|
3694
|
|
|
3695
|
this.$element.append($option); |
|
3696
|
} |
|
3697
|
} |
|
3698
|
} |
|
3699
|
|
|
3700
|
Tags.prototype.query = function (decorated, params, callback) { |
|
3701
|
var self = this; |
|
3702
|
|
|
3703
|
this._removeOldTags(); |
|
3704
|
|
|
3705
|
if (params.term == null || params.page != null) { |
|
3706
|
decorated.call(this, params, callback); |
|
3707
|
return; |
|
3708
|
} |
|
3709
|
|
|
3710
|
function wrapper (obj, child) { |
|
3711
|
var data = obj.results; |
|
3712
|
|
|
3713
|
for (var i = 0; i < data.length; i++) { |
|
3714
|
var option = data[i]; |
|
3715
|
|
|
3716
|
var checkChildren = ( |
|
3717
|
option.children != null && |
|
3718
|
!wrapper({ |
|
3719
|
results: option.children |
|
3720
|
}, true) |
|
3721
|
); |
|
3722
|
|
|
3723
|
var optionText = (option.text || '').toUpperCase(); |
|
3724
|
var paramsTerm = (params.term || '').toUpperCase(); |
|
3725
|
|
|
3726
|
var checkText = optionText === paramsTerm; |
|
3727
|
|
|
3728
|
if (checkText || checkChildren) { |
|
3729
|
if (child) { |
|
3730
|
return false; |
|
3731
|
} |
|
3732
|
|
|
3733
|
obj.data = data; |
|
3734
|
callback(obj); |
|
3735
|
|
|
3736
|
return; |
|
3737
|
} |
|
3738
|
} |
|
3739
|
|
|
3740
|
if (child) { |
|
3741
|
return true; |
|
3742
|
} |
|
3743
|
|
|
3744
|
var tag = self.createTag(params); |
|
3745
|
|
|
3746
|
if (tag != null) { |
|
3747
|
var $option = self.option(tag); |
|
3748
|
$option.attr('data-select2-tag', true); |
|
3749
|
|
|
3750
|
self.addOptions([$option]); |
|
3751
|
|
|
3752
|
self.insertTag(data, tag); |
|
3753
|
} |
|
3754
|
|
|
3755
|
obj.results = data; |
|
3756
|
|
|
3757
|
callback(obj); |
|
3758
|
} |
|
3759
|
|
|
3760
|
decorated.call(this, params, wrapper); |
|
3761
|
}; |
|
3762
|
|
|
3763
|
Tags.prototype.createTag = function (decorated, params) { |
|
3764
|
var term = $.trim(params.term); |
|
3765
|
|
|
3766
|
if (term === '') { |
|
3767
|
return null; |
|
3768
|
} |
|
3769
|
|
|
3770
|
return { |
|
3771
|
id: term, |
|
3772
|
text: term |
|
3773
|
}; |
|
3774
|
}; |
|
3775
|
|
|
3776
|
Tags.prototype.insertTag = function (_, data, tag) { |
|
3777
|
data.unshift(tag); |
|
3778
|
}; |
|
3779
|
|
|
3780
|
Tags.prototype._removeOldTags = function (_) { |
|
3781
|
var $options = this.$element.find('option[data-select2-tag]'); |
|
3782
|
|
|
3783
|
$options.each(function () { |
|
3784
|
if (this.selected) { |
|
3785
|
return; |
|
3786
|
} |
|
3787
|
|
|
3788
|
$(this).remove(); |
|
3789
|
}); |
|
3790
|
}; |
|
3791
|
|
|
3792
|
return Tags; |
|
3793
|
}); |
|
3794
|
|
|
3795
|
S2.define('select2/data/tokenizer',[ |
|
3796
|
'jquery' |
|
3797
|
], function ($) { |
|
3798
|
function Tokenizer (decorated, $element, options) { |
|
3799
|
var tokenizer = options.get('tokenizer'); |
|
3800
|
|
|
3801
|
if (tokenizer !== undefined) { |
|
3802
|
this.tokenizer = tokenizer; |
|
3803
|
} |
|
3804
|
|
|
3805
|
decorated.call(this, $element, options); |
|
3806
|
} |
|
3807
|
|
|
3808
|
Tokenizer.prototype.bind = function (decorated, container, $container) { |
|
3809
|
decorated.call(this, container, $container); |
|
3810
|
|
|
3811
|
this.$search = container.dropdown.$search || container.selection.$search || |
|
3812
|
$container.find('.select2-search__field'); |
|
3813
|
}; |
|
3814
|
|
|
3815
|
Tokenizer.prototype.query = function (decorated, params, callback) { |
|
3816
|
var self = this; |
|
3817
|
|
|
3818
|
function createAndSelect (data) { |
|
3819
|
// Normalize the data object so we can use it for checks |
|
3820
|
var item = self._normalizeItem(data); |
|
3821
|
|
|
3822
|
// Check if the data object already exists as a tag |
|
3823
|
// Select it if it doesn't |
|
3824
|
var $existingOptions = self.$element.find('option').filter(function () { |
|
3825
|
return $(this).val() === item.id; |
|
3826
|
}); |
|
3827
|
|
|
3828
|
// If an existing option wasn't found for it, create the option |
|
3829
|
if (!$existingOptions.length) { |
|
3830
|
var $option = self.option(item); |
|
3831
|
$option.attr('data-select2-tag', true); |
|
3832
|
|
|
3833
|
self._removeOldTags(); |
|
3834
|
self.addOptions([$option]); |
|
3835
|
} |
|
3836
|
|
|
3837
|
// Select the item, now that we know there is an option for it |
|
3838
|
select(item); |
|
3839
|
} |
|
3840
|
|
|
3841
|
function select (data) { |
|
3842
|
self.trigger('select', { |
|
3843
|
data: data |
|
3844
|
}); |
|
3845
|
} |
|
3846
|
|
|
3847
|
params.term = params.term || ''; |
|
3848
|
|
|
3849
|
var tokenData = this.tokenizer(params, this.options, createAndSelect); |
|
3850
|
|
|
3851
|
if (tokenData.term !== params.term) { |
|
3852
|
// Replace the search term if we have the search box |
|
3853
|
if (this.$search.length) { |
|
3854
|
this.$search.val(tokenData.term); |
|
3855
|
this.$search.trigger('focus'); |
|
3856
|
} |
|
3857
|
|
|
3858
|
params.term = tokenData.term; |
|
3859
|
} |
|
3860
|
|
|
3861
|
decorated.call(this, params, callback); |
|
3862
|
}; |
|
3863
|
|
|
3864
|
Tokenizer.prototype.tokenizer = function (_, params, options, callback) { |
|
3865
|
var separators = options.get('tokenSeparators') || []; |
|
3866
|
var term = params.term; |
|
3867
|
var i = 0; |
|
3868
|
|
|
3869
|
var createTag = this.createTag || function (params) { |
|
3870
|
return { |
|
3871
|
id: params.term, |
|
3872
|
text: params.term |
|
3873
|
}; |
|
3874
|
}; |
|
3875
|
|
|
3876
|
while (i < term.length) { |
|
3877
|
var termChar = term[i]; |
|
3878
|
|
|
3879
|
if ($.inArray(termChar, separators) === -1) { |
|
3880
|
i++; |
|
3881
|
|
|
3882
|
continue; |
|
3883
|
} |
|
3884
|
|
|
3885
|
var part = term.substr(0, i); |
|
3886
|
var partParams = $.extend({}, params, { |
|
3887
|
term: part |
|
3888
|
}); |
|
3889
|
|
|
3890
|
var data = createTag(partParams); |
|
3891
|
|
|
3892
|
if (data == null) { |
|
3893
|
i++; |
|
3894
|
continue; |
|
3895
|
} |
|
3896
|
|
|
3897
|
callback(data); |
|
3898
|
|
|
3899
|
// Reset the term to not include the tokenized portion |
|
3900
|
term = term.substr(i + 1) || ''; |
|
3901
|
i = 0; |
|
3902
|
} |
|
3903
|
|
|
3904
|
return { |
|
3905
|
term: term |
|
3906
|
}; |
|
3907
|
}; |
|
3908
|
|
|
3909
|
return Tokenizer; |
|
3910
|
}); |
|
3911
|
|
|
3912
|
S2.define('select2/data/minimumInputLength',[ |
|
3913
|
|
|
3914
|
], function () { |
|
3915
|
function MinimumInputLength (decorated, $e, options) { |
|
3916
|
this.minimumInputLength = options.get('minimumInputLength'); |
|
3917
|
|
|
3918
|
decorated.call(this, $e, options); |
|
3919
|
} |
|
3920
|
|
|
3921
|
MinimumInputLength.prototype.query = function (decorated, params, callback) { |
|
3922
|
params.term = params.term || ''; |
|
3923
|
|
|
3924
|
if (params.term.length < this.minimumInputLength) { |
|
3925
|
this.trigger('results:message', { |
|
3926
|
message: 'inputTooShort', |
|
3927
|
args: { |
|
3928
|
minimum: this.minimumInputLength, |
|
3929
|
input: params.term, |
|
3930
|
params: params |
|
3931
|
} |
|
3932
|
}); |
|
3933
|
|
|
3934
|
return; |
|
3935
|
} |
|
3936
|
|
|
3937
|
decorated.call(this, params, callback); |
|
3938
|
}; |
|
3939
|
|
|
3940
|
return MinimumInputLength; |
|
3941
|
}); |
|
3942
|
|
|
3943
|
S2.define('select2/data/maximumInputLength',[ |
|
3944
|
|
|
3945
|
], function () { |
|
3946
|
function MaximumInputLength (decorated, $e, options) { |
|
3947
|
this.maximumInputLength = options.get('maximumInputLength'); |
|
3948
|
|
|
3949
|
decorated.call(this, $e, options); |
|
3950
|
} |
|
3951
|
|
|
3952
|
MaximumInputLength.prototype.query = function (decorated, params, callback) { |
|
3953
|
params.term = params.term || ''; |
|
3954
|
|
|
3955
|
if (this.maximumInputLength > 0 && |
|
3956
|
params.term.length > this.maximumInputLength) { |
|
3957
|
this.trigger('results:message', { |
|
3958
|
message: 'inputTooLong', |
|
3959
|
args: { |
|
3960
|
maximum: this.maximumInputLength, |
|
3961
|
input: params.term, |
|
3962
|
params: params |
|
3963
|
} |
|
3964
|
}); |
|
3965
|
|
|
3966
|
return; |
|
3967
|
} |
|
3968
|
|
|
3969
|
decorated.call(this, params, callback); |
|
3970
|
}; |
|
3971
|
|
|
3972
|
return MaximumInputLength; |
|
3973
|
}); |
|
3974
|
|
|
3975
|
S2.define('select2/data/maximumSelectionLength',[ |
|
3976
|
|
|
3977
|
], function (){ |
|
3978
|
function MaximumSelectionLength (decorated, $e, options) { |
|
3979
|
this.maximumSelectionLength = options.get('maximumSelectionLength'); |
|
3980
|
|
|
3981
|
decorated.call(this, $e, options); |
|
3982
|
} |
|
3983
|
|
|
3984
|
MaximumSelectionLength.prototype.bind = |
|
3985
|
function (decorated, container, $container) { |
|
3986
|
var self = this; |
|
3987
|
|
|
3988
|
decorated.call(this, container, $container); |
|
3989
|
|
|
3990
|
container.on('select', function () { |
|
3991
|
self._checkIfMaximumSelected(); |
|
3992
|
}); |
|
3993
|
}; |
|
3994
|
|
|
3995
|
MaximumSelectionLength.prototype.query = |
|
3996
|
function (decorated, params, callback) { |
|
3997
|
var self = this; |
|
3998
|
|
|
3999
|
this._checkIfMaximumSelected(function () { |
|
4000
|
decorated.call(self, params, callback); |
|
4001
|
}); |
|
4002
|
}; |
|
4003
|
|
|
4004
|
MaximumSelectionLength.prototype._checkIfMaximumSelected = |
|
4005
|
function (_, successCallback) { |
|
4006
|
var self = this; |
|
4007
|
|
|
4008
|
this.current(function (currentData) { |
|
4009
|
var count = currentData != null ? currentData.length : 0; |
|
4010
|
if (self.maximumSelectionLength > 0 && |
|
4011
|
count >= self.maximumSelectionLength) { |
|
4012
|
self.trigger('results:message', { |
|
4013
|
message: 'maximumSelected', |
|
4014
|
args: { |
|
4015
|
maximum: self.maximumSelectionLength |
|
4016
|
} |
|
4017
|
}); |
|
4018
|
return; |
|
4019
|
} |
|
4020
|
|
|
4021
|
if (successCallback) { |
|
4022
|
successCallback(); |
|
4023
|
} |
|
4024
|
}); |
|
4025
|
}; |
|
4026
|
|
|
4027
|
return MaximumSelectionLength; |
|
4028
|
}); |
|
4029
|
|
|
4030
|
S2.define('select2/dropdown',[ |
|
4031
|
'jquery', |
|
4032
|
'./utils' |
|
4033
|
], function ($, Utils) { |
|
4034
|
function Dropdown ($element, options) { |
|
4035
|
this.$element = $element; |
|
4036
|
this.options = options; |
|
4037
|
|
|
4038
|
Dropdown.__super__.constructor.call(this); |
|
4039
|
} |
|
4040
|
|
|
4041
|
Utils.Extend(Dropdown, Utils.Observable); |
|
4042
|
|
|
4043
|
Dropdown.prototype.render = function () { |
|
4044
|
var $dropdown = $( |
|
4045
|
'<span class="select2-dropdown">' + |
|
4046
|
'<span class="select2-results"></span>' + |
|
4047
|
'</span>' |
|
4048
|
); |
|
4049
|
|
|
4050
|
$dropdown.attr('dir', this.options.get('dir')); |
|
4051
|
|
|
4052
|
this.$dropdown = $dropdown; |
|
4053
|
|
|
4054
|
return $dropdown; |
|
4055
|
}; |
|
4056
|
|
|
4057
|
Dropdown.prototype.bind = function () { |
|
4058
|
// Should be implemented in subclasses |
|
4059
|
}; |
|
4060
|
|
|
4061
|
Dropdown.prototype.position = function ($dropdown, $container) { |
|
4062
|
// Should be implemented in subclasses |
|
4063
|
}; |
|
4064
|
|
|
4065
|
Dropdown.prototype.destroy = function () { |
|
4066
|
// Remove the dropdown from the DOM |
|
4067
|
this.$dropdown.remove(); |
|
4068
|
}; |
|
4069
|
|
|
4070
|
return Dropdown; |
|
4071
|
}); |
|
4072
|
|
|
4073
|
S2.define('select2/dropdown/search',[ |
|
4074
|
'jquery', |
|
4075
|
'../utils' |
|
4076
|
], function ($, Utils) { |
|
4077
|
function Search () { } |
|
4078
|
|
|
4079
|
Search.prototype.render = function (decorated) { |
|
4080
|
var $rendered = decorated.call(this); |
|
4081
|
|
|
4082
|
var $search = $( |
|
4083
|
'<span class="select2-search select2-search--dropdown">' + |
|
4084
|
'<input class="select2-search__field" type="search" tabindex="-1"' + |
|
4085
|
' autocomplete="off" autocorrect="off" autocapitalize="none"' + |
|
4086
|
' spellcheck="false" role="searchbox" aria-autocomplete="list" />' + |
|
4087
|
'</span>' |
|
4088
|
); |
|
4089
|
|
|
4090
|
this.$searchContainer = $search; |
|
4091
|
this.$search = $search.find('input'); |
|
4092
|
|
|
4093
|
$rendered.prepend($search); |
|
4094
|
|
|
4095
|
return $rendered; |
|
4096
|
}; |
|
4097
|
|
|
4098
|
Search.prototype.bind = function (decorated, container, $container) { |
|
4099
|
var self = this; |
|
4100
|
|
|
4101
|
var resultsId = container.id + '-results'; |
|
4102
|
|
|
4103
|
decorated.call(this, container, $container); |
|
4104
|
|
|
4105
|
this.$search.on('keydown', function (evt) { |
|
4106
|
self.trigger('keypress', evt); |
|
4107
|
|
|
4108
|
self._keyUpPrevented = evt.isDefaultPrevented(); |
|
4109
|
}); |
|
4110
|
|
|
4111
|
// Workaround for browsers which do not support the `input` event |
|
4112
|
// This will prevent double-triggering of events for browsers which support |
|
4113
|
// both the `keyup` and `input` events. |
|
4114
|
this.$search.on('input', function (evt) { |
|
4115
|
// Unbind the duplicated `keyup` event |
|
4116
|
$(this).off('keyup'); |
|
4117
|
}); |
|
4118
|
|
|
4119
|
this.$search.on('keyup input', function (evt) { |
|
4120
|
self.handleSearch(evt); |
|
4121
|
}); |
|
4122
|
|
|
4123
|
container.on('open', function () { |
|
4124
|
self.$search.attr('tabindex', 0); |
|
4125
|
self.$search.attr('aria-controls', resultsId); |
|
4126
|
|
|
4127
|
self.$search.trigger('focus'); |
|
4128
|
|
|
4129
|
window.setTimeout(function () { |
|
4130
|
self.$search.trigger('focus'); |
|
4131
|
}, 0); |
|
4132
|
}); |
|
4133
|
|
|
4134
|
container.on('close', function () { |
|
4135
|
self.$search.attr('tabindex', -1); |
|
4136
|
self.$search.removeAttr('aria-controls'); |
|
4137
|
self.$search.removeAttr('aria-activedescendant'); |
|
4138
|
|
|
4139
|
self.$search.val(''); |
|
4140
|
self.$search.trigger('blur'); |
|
4141
|
}); |
|
4142
|
|
|
4143
|
container.on('focus', function () { |
|
4144
|
if (!container.isOpen()) { |
|
4145
|
self.$search.trigger('focus'); |
|
4146
|
} |
|
4147
|
}); |
|
4148
|
|
|
4149
|
container.on('results:all', function (params) { |
|
4150
|
if (params.query.term == null || params.query.term === '') { |
|
4151
|
var showSearch = self.showSearch(params); |
|
4152
|
|
|
4153
|
if (showSearch) { |
|
4154
|
self.$searchContainer.removeClass('select2-search--hide'); |
|
4155
|
} else { |
|
4156
|
self.$searchContainer.addClass('select2-search--hide'); |
|
4157
|
} |
|
4158
|
} |
|
4159
|
}); |
|
4160
|
|
|
4161
|
container.on('results:focus', function (params) { |
|
4162
|
if (params.data._resultId) { |
|
4163
|
self.$search.attr('aria-activedescendant', params.data._resultId); |
|
4164
|
} else { |
|
4165
|
self.$search.removeAttr('aria-activedescendant'); |
|
4166
|
} |
|
4167
|
}); |
|
4168
|
}; |
|
4169
|
|
|
4170
|
Search.prototype.handleSearch = function (evt) { |
|
4171
|
if (!this._keyUpPrevented) { |
|
4172
|
var input = this.$search.val(); |
|
4173
|
|
|
4174
|
this.trigger('query', { |
|
4175
|
term: input |
|
4176
|
}); |
|
4177
|
} |
|
4178
|
|
|
4179
|
this._keyUpPrevented = false; |
|
4180
|
}; |
|
4181
|
|
|
4182
|
Search.prototype.showSearch = function (_, params) { |
|
4183
|
return true; |
|
4184
|
}; |
|
4185
|
|
|
4186
|
return Search; |
|
4187
|
}); |
|
4188
|
|
|
4189
|
S2.define('select2/dropdown/hidePlaceholder',[ |
|
4190
|
|
|
4191
|
], function () { |
|
4192
|
function HidePlaceholder (decorated, $element, options, dataAdapter) { |
|
4193
|
this.placeholder = this.normalizePlaceholder(options.get('placeholder')); |
|
4194
|
|
|
4195
|
decorated.call(this, $element, options, dataAdapter); |
|
4196
|
} |
|
4197
|
|
|
4198
|
HidePlaceholder.prototype.append = function (decorated, data) { |
|
4199
|
data.results = this.removePlaceholder(data.results); |
|
4200
|
|
|
4201
|
decorated.call(this, data); |
|
4202
|
}; |
|
4203
|
|
|
4204
|
HidePlaceholder.prototype.normalizePlaceholder = function (_, placeholder) { |
|
4205
|
if (typeof placeholder === 'string') { |
|
4206
|
placeholder = { |
|
4207
|
id: '', |
|
4208
|
text: placeholder |
|
4209
|
}; |
|
4210
|
} |
|
4211
|
|
|
4212
|
return placeholder; |
|
4213
|
}; |
|
4214
|
|
|
4215
|
HidePlaceholder.prototype.removePlaceholder = function (_, data) { |
|
4216
|
var modifiedData = data.slice(0); |
|
4217
|
|
|
4218
|
for (var d = data.length - 1; d >= 0; d--) { |
|
4219
|
var item = data[d]; |
|
4220
|
|
|
4221
|
if (this.placeholder.id === item.id) { |
|
4222
|
modifiedData.splice(d, 1); |
|
4223
|
} |
|
4224
|
} |
|
4225
|
|
|
4226
|
return modifiedData; |
|
4227
|
}; |
|
4228
|
|
|
4229
|
return HidePlaceholder; |
|
4230
|
}); |
|
4231
|
|
|
4232
|
S2.define('select2/dropdown/infiniteScroll',[ |
|
4233
|
'jquery' |
|
4234
|
], function ($) { |
|
4235
|
function InfiniteScroll (decorated, $element, options, dataAdapter) { |
|
4236
|
this.lastParams = {}; |
|
4237
|
|
|
4238
|
decorated.call(this, $element, options, dataAdapter); |
|
4239
|
|
|
4240
|
this.$loadingMore = this.createLoadingMore(); |
|
4241
|
this.loading = false; |
|
4242
|
} |
|
4243
|
|
|
4244
|
InfiniteScroll.prototype.append = function (decorated, data) { |
|
4245
|
this.$loadingMore.remove(); |
|
4246
|
this.loading = false; |
|
4247
|
|
|
4248
|
decorated.call(this, data); |
|
4249
|
|
|
4250
|
if (this.showLoadingMore(data)) { |
|
4251
|
this.$results.append(this.$loadingMore); |
|
4252
|
this.loadMoreIfNeeded(); |
|
4253
|
} |
|
4254
|
}; |
|
4255
|
|
|
4256
|
InfiniteScroll.prototype.bind = function (decorated, container, $container) { |
|
4257
|
var self = this; |
|
4258
|
|
|
4259
|
decorated.call(this, container, $container); |
|
4260
|
|
|
4261
|
container.on('query', function (params) { |
|
4262
|
self.lastParams = params; |
|
4263
|
self.loading = true; |
|
4264
|
}); |
|
4265
|
|
|
4266
|
container.on('query:append', function (params) { |
|
4267
|
self.lastParams = params; |
|
4268
|
self.loading = true; |
|
4269
|
}); |
|
4270
|
|
|
4271
|
this.$results.on('scroll', this.loadMoreIfNeeded.bind(this)); |
|
4272
|
}; |
|
4273
|
|
|
4274
|
InfiniteScroll.prototype.loadMoreIfNeeded = function () { |
|
4275
|
var isLoadMoreVisible = $.contains( |
|
4276
|
document.documentElement, |
|
4277
|
this.$loadingMore[0] |
|
4278
|
); |
|
4279
|
|
|
4280
|
if (this.loading || !isLoadMoreVisible) { |
|
4281
|
return; |
|
4282
|
} |
|
4283
|
|
|
4284
|
var currentOffset = this.$results.offset().top + |
|
4285
|
this.$results.outerHeight(false); |
|
4286
|
var loadingMoreOffset = this.$loadingMore.offset().top + |
|
4287
|
this.$loadingMore.outerHeight(false); |
|
4288
|
|
|
4289
|
if (currentOffset + 50 >= loadingMoreOffset) { |
|
4290
|
this.loadMore(); |
|
4291
|
} |
|
4292
|
}; |
|
4293
|
|
|
4294
|
InfiniteScroll.prototype.loadMore = function () { |
|
4295
|
this.loading = true; |
|
4296
|
|
|
4297
|
var params = $.extend({}, {page: 1}, this.lastParams); |
|
4298
|
|
|
4299
|
params.page++; |
|
4300
|
|
|
4301
|
this.trigger('query:append', params); |
|
4302
|
}; |
|
4303
|
|
|
4304
|
InfiniteScroll.prototype.showLoadingMore = function (_, data) { |
|
4305
|
return data.pagination && data.pagination.more; |
|
4306
|
}; |
|
4307
|
|
|
4308
|
InfiniteScroll.prototype.createLoadingMore = function () { |
|
4309
|
var $option = $( |
|
4310
|
'<li ' + |
|
4311
|
'class="select2-results__option select2-results__option--load-more"' + |
|
4312
|
'role="option" aria-disabled="true"></li>' |
|
4313
|
); |
|
4314
|
|
|
4315
|
var message = this.options.get('translations').get('loadingMore'); |
|
4316
|
|
|
4317
|
$option.html(message(this.lastParams)); |
|
4318
|
|
|
4319
|
return $option; |
|
4320
|
}; |
|
4321
|
|
|
4322
|
return InfiniteScroll; |
|
4323
|
}); |
|
4324
|
|
|
4325
|
S2.define('select2/dropdown/attachBody',[ |
|
4326
|
'jquery', |
|
4327
|
'../utils' |
|
4328
|
], function ($, Utils) { |
|
4329
|
function AttachBody (decorated, $element, options) { |
|
4330
|
this.$dropdownParent = $(options.get('dropdownParent') || document.body); |
|
4331
|
|
|
4332
|
decorated.call(this, $element, options); |
|
4333
|
} |
|
4334
|
|
|
4335
|
AttachBody.prototype.bind = function (decorated, container, $container) { |
|
4336
|
var self = this; |
|
4337
|
|
|
4338
|
decorated.call(this, container, $container); |
|
4339
|
|
|
4340
|
container.on('open', function () { |
|
4341
|
self._showDropdown(); |
|
4342
|
self._attachPositioningHandler(container); |
|
4343
|
|
|
4344
|
// Must bind after the results handlers to ensure correct sizing |
|
4345
|
self._bindContainerResultHandlers(container); |
|
4346
|
}); |
|
4347
|
|
|
4348
|
container.on('close', function () { |
|
4349
|
self._hideDropdown(); |
|
4350
|
self._detachPositioningHandler(container); |
|
4351
|
}); |
|
4352
|
|
|
4353
|
this.$dropdownContainer.on('mousedown', function (evt) { |
|
4354
|
evt.stopPropagation(); |
|
4355
|
}); |
|
4356
|
}; |
|
4357
|
|
|
4358
|
AttachBody.prototype.destroy = function (decorated) { |
|
4359
|
decorated.call(this); |
|
4360
|
|
|
4361
|
this.$dropdownContainer.remove(); |
|
4362
|
}; |
|
4363
|
|
|
4364
|
AttachBody.prototype.position = function (decorated, $dropdown, $container) { |
|
4365
|
// Clone all of the container classes |
|
4366
|
$dropdown.attr('class', $container.attr('class')); |
|
4367
|
|
|
4368
|
$dropdown.removeClass('select2'); |
|
4369
|
$dropdown.addClass('select2-container--open'); |
|
4370
|
|
|
4371
|
$dropdown.css({ |
|
4372
|
position: 'absolute', |
|
4373
|
top: -999999 |
|
4374
|
}); |
|
4375
|
|
|
4376
|
this.$container = $container; |
|
4377
|
}; |
|
4378
|
|
|
4379
|
AttachBody.prototype.render = function (decorated) { |
|
4380
|
var $container = $('<span></span>'); |
|
4381
|
|
|
4382
|
var $dropdown = decorated.call(this); |
|
4383
|
$container.append($dropdown); |
|
4384
|
|
|
4385
|
this.$dropdownContainer = $container; |
|
4386
|
|
|
4387
|
return $container; |
|
4388
|
}; |
|
4389
|
|
|
4390
|
AttachBody.prototype._hideDropdown = function (decorated) { |
|
4391
|
this.$dropdownContainer.detach(); |
|
4392
|
}; |
|
4393
|
|
|
4394
|
AttachBody.prototype._bindContainerResultHandlers = |
|
4395
|
function (decorated, container) { |
|
4396
|
|
|
4397
|
// These should only be bound once |
|
4398
|
if (this._containerResultsHandlersBound) { |
|
4399
|
return; |
|
4400
|
} |
|
4401
|
|
|
4402
|
var self = this; |
|
4403
|
|
|
4404
|
container.on('results:all', function () { |
|
4405
|
self._positionDropdown(); |
|
4406
|
self._resizeDropdown(); |
|
4407
|
}); |
|
4408
|
|
|
4409
|
container.on('results:append', function () { |
|
4410
|
self._positionDropdown(); |
|
4411
|
self._resizeDropdown(); |
|
4412
|
}); |
|
4413
|
|
|
4414
|
container.on('results:message', function () { |
|
4415
|
self._positionDropdown(); |
|
4416
|
self._resizeDropdown(); |
|
4417
|
}); |
|
4418
|
|
|
4419
|
container.on('select', function () { |
|
4420
|
self._positionDropdown(); |
|
4421
|
self._resizeDropdown(); |
|
4422
|
}); |
|
4423
|
|
|
4424
|
container.on('unselect', function () { |
|
4425
|
self._positionDropdown(); |
|
4426
|
self._resizeDropdown(); |
|
4427
|
}); |
|
4428
|
|
|
4429
|
this._containerResultsHandlersBound = true; |
|
4430
|
}; |
|
4431
|
|
|
4432
|
AttachBody.prototype._attachPositioningHandler = |
|
4433
|
function (decorated, container) { |
|
4434
|
var self = this; |
|
4435
|
|
|
4436
|
var scrollEvent = 'scroll.select2.' + container.id; |
|
4437
|
var resizeEvent = 'resize.select2.' + container.id; |
|
4438
|
var orientationEvent = 'orientationchange.select2.' + container.id; |
|
4439
|
|
|
4440
|
var $watchers = this.$container.parents().filter(Utils.hasScroll); |
|
4441
|
$watchers.each(function () { |
|
4442
|
Utils.StoreData(this, 'select2-scroll-position', { |
|
4443
|
x: $(this).scrollLeft(), |
|
4444
|
y: $(this).scrollTop() |
|
4445
|
}); |
|
4446
|
}); |
|
4447
|
|
|
4448
|
$watchers.on(scrollEvent, function (ev) { |
|
4449
|
var position = Utils.GetData(this, 'select2-scroll-position'); |
|
4450
|
$(this).scrollTop(position.y); |
|
4451
|
}); |
|
4452
|
|
|
4453
|
$(window).on(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent, |
|
4454
|
function (e) { |
|
4455
|
self._positionDropdown(); |
|
4456
|
self._resizeDropdown(); |
|
4457
|
}); |
|
4458
|
}; |
|
4459
|
|
|
4460
|
AttachBody.prototype._detachPositioningHandler = |
|
4461
|
function (decorated, container) { |
|
4462
|
var scrollEvent = 'scroll.select2.' + container.id; |
|
4463
|
var resizeEvent = 'resize.select2.' + container.id; |
|
4464
|
var orientationEvent = 'orientationchange.select2.' + container.id; |
|
4465
|
|
|
4466
|
var $watchers = this.$container.parents().filter(Utils.hasScroll); |
|
4467
|
$watchers.off(scrollEvent); |
|
4468
|
|
|
4469
|
$(window).off(scrollEvent + ' ' + resizeEvent + ' ' + orientationEvent); |
|
4470
|
}; |
|
4471
|
|
|
4472
|
AttachBody.prototype._positionDropdown = function () { |
|
4473
|
var $window = $(window); |
|
4474
|
|
|
4475
|
var isCurrentlyAbove = this.$dropdown.hasClass('select2-dropdown--above'); |
|
4476
|
var isCurrentlyBelow = this.$dropdown.hasClass('select2-dropdown--below'); |
|
4477
|
|
|
4478
|
var newDirection = null; |
|
4479
|
|
|
4480
|
var offset = this.$container.offset(); |
|
4481
|
|
|
4482
|
offset.bottom = offset.top + this.$container.outerHeight(false); |
|
4483
|
|
|
4484
|
var container = { |
|
4485
|
height: this.$container.outerHeight(false) |
|
4486
|
}; |
|
4487
|
|
|
4488
|
container.top = offset.top; |
|
4489
|
container.bottom = offset.top + container.height; |
|
4490
|
|
|
4491
|
var dropdown = { |
|
4492
|
height: this.$dropdown.outerHeight(false) |
|
4493
|
}; |
|
4494
|
|
|
4495
|
var viewport = { |
|
4496
|
top: $window.scrollTop(), |
|
4497
|
bottom: $window.scrollTop() + $window.height() |
|
4498
|
}; |
|
4499
|
|
|
4500
|
var enoughRoomAbove = viewport.top < (offset.top - dropdown.height); |
|
4501
|
var enoughRoomBelow = viewport.bottom > (offset.bottom + dropdown.height); |
|
4502
|
|
|
4503
|
var css = { |
|
4504
|
left: offset.left, |
|
4505
|
top: container.bottom |
|
4506
|
}; |
|
4507
|
|
|
4508
|
// Determine what the parent element is to use for calculating the offset |
|
4509
|
var $offsetParent = this.$dropdownParent; |
|
4510
|
|
|
4511
|
// For statically positioned elements, we need to get the element |
|
4512
|
// that is determining the offset |
|
4513
|
if ($offsetParent.css('position') === 'static') { |
|
4514
|
$offsetParent = $offsetParent.offsetParent(); |
|
4515
|
} |
|
4516
|
|
|
4517
|
var parentOffset = { |
|
4518
|
top: 0, |
|
4519
|
left: 0 |
|
4520
|
}; |
|
4521
|
|
|
4522
|
if ( |
|
4523
|
$.contains(document.body, $offsetParent[0]) || |
|
4524
|
$offsetParent[0].isConnected |
|
4525
|
) { |
|
4526
|
parentOffset = $offsetParent.offset(); |
|
4527
|
} |
|
4528
|
|
|
4529
|
css.top -= parentOffset.top; |
|
4530
|
css.left -= parentOffset.left; |
|
4531
|
|
|
4532
|
if (!isCurrentlyAbove && !isCurrentlyBelow) { |
|
4533
|
newDirection = 'below'; |
|
4534
|
} |
|
4535
|
|
|
4536
|
if (!enoughRoomBelow && enoughRoomAbove && !isCurrentlyAbove) { |
|
4537
|
newDirection = 'above'; |
|
4538
|
} else if (!enoughRoomAbove && enoughRoomBelow && isCurrentlyAbove) { |
|
4539
|
newDirection = 'below'; |
|
4540
|
} |
|
4541
|
|
|
4542
|
if (newDirection == 'above' || |
|
4543
|
(isCurrentlyAbove && newDirection !== 'below')) { |
|
4544
|
css.top = container.top - parentOffset.top - dropdown.height; |
|
4545
|
} |
|
4546
|
|
|
4547
|
if (newDirection != null) { |
|
4548
|
this.$dropdown |
|
4549
|
.removeClass('select2-dropdown--below select2-dropdown--above') |
|
4550
|
.addClass('select2-dropdown--' + newDirection); |
|
4551
|
this.$container |
|
4552
|
.removeClass('select2-container--below select2-container--above') |
|
4553
|
.addClass('select2-container--' + newDirection); |
|
4554
|
} |
|
4555
|
|
|
4556
|
this.$dropdownContainer.css(css); |
|
4557
|
}; |
|
4558
|
|
|
4559
|
AttachBody.prototype._resizeDropdown = function () { |
|
4560
|
var css = { |
|
4561
|
width: this.$container.outerWidth(false) + 'px' |
|
4562
|
}; |
|
4563
|
|
|
4564
|
if (this.options.get('dropdownAutoWidth')) { |
|
4565
|
css.minWidth = css.width; |
|
4566
|
css.position = 'relative'; |
|
4567
|
css.width = 'auto'; |
|
4568
|
} |
|
4569
|
|
|
4570
|
this.$dropdown.css(css); |
|
4571
|
}; |
|
4572
|
|
|
4573
|
AttachBody.prototype._showDropdown = function (decorated) { |
|
4574
|
this.$dropdownContainer.appendTo(this.$dropdownParent); |
|
4575
|
|
|
4576
|
this._positionDropdown(); |
|
4577
|
this._resizeDropdown(); |
|
4578
|
}; |
|
4579
|
|
|
4580
|
return AttachBody; |
|
4581
|
}); |
|
4582
|
|
|
4583
|
S2.define('select2/dropdown/minimumResultsForSearch',[ |
|
4584
|
|
|
4585
|
], function () { |
|
4586
|
function countResults (data) { |
|
4587
|
var count = 0; |
|
4588
|
|
|
4589
|
for (var d = 0; d < data.length; d++) { |
|
4590
|
var item = data[d]; |
|
4591
|
|
|
4592
|
if (item.children) { |
|
4593
|
count += countResults(item.children); |
|
4594
|
} else { |
|
4595
|
count++; |
|
4596
|
} |
|
4597
|
} |
|
4598
|
|
|
4599
|
return count; |
|
4600
|
} |
|
4601
|
|
|
4602
|
function MinimumResultsForSearch (decorated, $element, options, dataAdapter) { |
|
4603
|
this.minimumResultsForSearch = options.get('minimumResultsForSearch'); |
|
4604
|
|
|
4605
|
if (this.minimumResultsForSearch < 0) { |
|
4606
|
this.minimumResultsForSearch = Infinity; |
|
4607
|
} |
|
4608
|
|
|
4609
|
decorated.call(this, $element, options, dataAdapter); |
|
4610
|
} |
|
4611
|
|
|
4612
|
MinimumResultsForSearch.prototype.showSearch = function (decorated, params) { |
|
4613
|
if (countResults(params.data.results) < this.minimumResultsForSearch) { |
|
4614
|
return false; |
|
4615
|
} |
|
4616
|
|
|
4617
|
return decorated.call(this, params); |
|
4618
|
}; |
|
4619
|
|
|
4620
|
return MinimumResultsForSearch; |
|
4621
|
}); |
|
4622
|
|
|
4623
|
S2.define('select2/dropdown/selectOnClose',[ |
|
4624
|
'../utils' |
|
4625
|
], function (Utils) { |
|
4626
|
function SelectOnClose () { } |
|
4627
|
|
|
4628
|
SelectOnClose.prototype.bind = function (decorated, container, $container) { |
|
4629
|
var self = this; |
|
4630
|
|
|
4631
|
decorated.call(this, container, $container); |
|
4632
|
|
|
4633
|
container.on('close', function (params) { |
|
4634
|
self._handleSelectOnClose(params); |
|
4635
|
}); |
|
4636
|
}; |
|
4637
|
|
|
4638
|
SelectOnClose.prototype._handleSelectOnClose = function (_, params) { |
|
4639
|
if (params && params.originalSelect2Event != null) { |
|
4640
|
var event = params.originalSelect2Event; |
|
4641
|
|
|
4642
|
// Don't select an item if the close event was triggered from a select or |
|
4643
|
// unselect event |
|
4644
|
if (event._type === 'select' || event._type === 'unselect') { |
|
4645
|
return; |
|
4646
|
} |
|
4647
|
} |
|
4648
|
|
|
4649
|
var $highlightedResults = this.getHighlightedResults(); |
|
4650
|
|
|
4651
|
// Only select highlighted results |
|
4652
|
if ($highlightedResults.length < 1) { |
|
4653
|
return; |
|
4654
|
} |
|
4655
|
|
|
4656
|
var data = Utils.GetData($highlightedResults[0], 'data'); |
|
4657
|
|
|
4658
|
// Don't re-select already selected resulte |
|
4659
|
if ( |
|
4660
|
(data.element != null && data.element.selected) || |
|
4661
|
(data.element == null && data.selected) |
|
4662
|
) { |
|
4663
|
return; |
|
4664
|
} |
|
4665
|
|
|
4666
|
this.trigger('select', { |
|
4667
|
data: data |
|
4668
|
}); |
|
4669
|
}; |
|
4670
|
|
|
4671
|
return SelectOnClose; |
|
4672
|
}); |
|
4673
|
|
|
4674
|
S2.define('select2/dropdown/closeOnSelect',[ |
|
4675
|
|
|
4676
|
], function () { |
|
4677
|
function CloseOnSelect () { } |
|
4678
|
|
|
4679
|
CloseOnSelect.prototype.bind = function (decorated, container, $container) { |
|
4680
|
var self = this; |
|
4681
|
|
|
4682
|
decorated.call(this, container, $container); |
|
4683
|
|
|
4684
|
container.on('select', function (evt) { |
|
4685
|
self._selectTriggered(evt); |
|
4686
|
}); |
|
4687
|
|
|
4688
|
container.on('unselect', function (evt) { |
|
4689
|
self._selectTriggered(evt); |
|
4690
|
}); |
|
4691
|
}; |
|
4692
|
|
|
4693
|
CloseOnSelect.prototype._selectTriggered = function (_, evt) { |
|
4694
|
var originalEvent = evt.originalEvent; |
|
4695
|
|
|
4696
|
// Don't close if the control key is being held |
|
4697
|
if (originalEvent && (originalEvent.ctrlKey || originalEvent.metaKey)) { |
|
4698
|
return; |
|
4699
|
} |
|
4700
|
|
|
4701
|
this.trigger('close', { |
|
4702
|
originalEvent: originalEvent, |
|
4703
|
originalSelect2Event: evt |
|
4704
|
}); |
|
4705
|
}; |
|
4706
|
|
|
4707
|
return CloseOnSelect; |
|
4708
|
}); |
|
4709
|
|
|
4710
|
S2.define('select2/i18n/en',[],function () { |
|
4711
|
// English |
|
4712
|
return { |
|
4713
|
errorLoading: function () { |
|
4714
|
return 'The results could not be loaded.'; |
|
4715
|
}, |
|
4716
|
inputTooLong: function (args) { |
|
4717
|
var overChars = args.input.length - args.maximum; |
|
4718
|
|
|
4719
|
var message = 'Please delete ' + overChars + ' character'; |
|
4720
|
|
|
4721
|
if (overChars != 1) { |
|
4722
|
message += 's'; |
|
4723
|
} |
|
4724
|
|
|
4725
|
return message; |
|
4726
|
}, |
|
4727
|
inputTooShort: function (args) { |
|
4728
|
var remainingChars = args.minimum - args.input.length; |
|
4729
|
|
|
4730
|
var message = 'Please enter ' + remainingChars + ' or more characters'; |
|
4731
|
|
|
4732
|
return message; |
|
4733
|
}, |
|
4734
|
loadingMore: function () { |
|
4735
|
return 'Loading more results…'; |
|
4736
|
}, |
|
4737
|
maximumSelected: function (args) { |
|
4738
|
var message = 'You can only select ' + args.maximum + ' item'; |
|
4739
|
|
|
4740
|
if (args.maximum != 1) { |
|
4741
|
message += 's'; |
|
4742
|
} |
|
4743
|
|
|
4744
|
return message; |
|
4745
|
}, |
|
4746
|
noResults: function () { |
|
4747
|
return 'No results found'; |
|
4748
|
}, |
|
4749
|
searching: function () { |
|
4750
|
return 'Searching…'; |
|
4751
|
}, |
|
4752
|
removeAllItems: function () { |
|
4753
|
return 'Remove all items'; |
|
4754
|
} |
|
4755
|
}; |
|
4756
|
}); |
|
4757
|
|
|
4758
|
S2.define('select2/defaults',[ |
|
4759
|
'jquery', |
|
4760
|
'require', |
|
4761
|
|
|
4762
|
'./results', |
|
4763
|
|
|
4764
|
'./selection/single', |
|
4765
|
'./selection/multiple', |
|
4766
|
'./selection/placeholder', |
|
4767
|
'./selection/allowClear', |
|
4768
|
'./selection/search', |
|
4769
|
'./selection/eventRelay', |
|
4770
|
|
|
4771
|
'./utils', |
|
4772
|
'./translation', |
|
4773
|
'./diacritics', |
|
4774
|
|
|
4775
|
'./data/select', |
|
4776
|
'./data/array', |
|
4777
|
'./data/ajax', |
|
4778
|
'./data/tags', |
|
4779
|
'./data/tokenizer', |
|
4780
|
'./data/minimumInputLength', |
|
4781
|
'./data/maximumInputLength', |
|
4782
|
'./data/maximumSelectionLength', |
|
4783
|
|
|
4784
|
'./dropdown', |
|
4785
|
'./dropdown/search', |
|
4786
|
'./dropdown/hidePlaceholder', |
|
4787
|
'./dropdown/infiniteScroll', |
|
4788
|
'./dropdown/attachBody', |
|
4789
|
'./dropdown/minimumResultsForSearch', |
|
4790
|
'./dropdown/selectOnClose', |
|
4791
|
'./dropdown/closeOnSelect', |
|
4792
|
|
|
4793
|
'./i18n/en' |
|
4794
|
], function ($, require, |
|
4795
|
|
|
4796
|
ResultsList, |
|
4797
|
|
|
4798
|
SingleSelection, MultipleSelection, Placeholder, AllowClear, |
|
4799
|
SelectionSearch, EventRelay, |
|
4800
|
|
|
4801
|
Utils, Translation, DIACRITICS, |
|
4802
|
|
|
4803
|
SelectData, ArrayData, AjaxData, Tags, Tokenizer, |
|
4804
|
MinimumInputLength, MaximumInputLength, MaximumSelectionLength, |
|
4805
|
|
|
4806
|
Dropdown, DropdownSearch, HidePlaceholder, InfiniteScroll, |
|
4807
|
AttachBody, MinimumResultsForSearch, SelectOnClose, CloseOnSelect, |
|
4808
|
|
|
4809
|
EnglishTranslation) { |
|
4810
|
function Defaults () { |
|
4811
|
this.reset(); |
|
4812
|
} |
|
4813
|
|
|
4814
|
Defaults.prototype.apply = function (options) { |
|
4815
|
options = $.extend(true, {}, this.defaults, options); |
|
4816
|
|
|
4817
|
if (options.dataAdapter == null) { |
|
4818
|
if (options.ajax != null) { |
|
4819
|
options.dataAdapter = AjaxData; |
|
4820
|
} else if (options.data != null) { |
|
4821
|
options.dataAdapter = ArrayData; |
|
4822
|
} else { |
|
4823
|
options.dataAdapter = SelectData; |
|
4824
|
} |
|
4825
|
|
|
4826
|
if (options.minimumInputLength > 0) { |
|
4827
|
options.dataAdapter = Utils.Decorate( |
|
4828
|
options.dataAdapter, |
|
4829
|
MinimumInputLength |
|
4830
|
); |
|
4831
|
} |
|
4832
|
|
|
4833
|
if (options.maximumInputLength > 0) { |
|
4834
|
options.dataAdapter = Utils.Decorate( |
|
4835
|
options.dataAdapter, |
|
4836
|
MaximumInputLength |
|
4837
|
); |
|
4838
|
} |
|
4839
|
|
|
4840
|
if (options.maximumSelectionLength > 0) { |
|
4841
|
options.dataAdapter = Utils.Decorate( |
|
4842
|
options.dataAdapter, |
|
4843
|
MaximumSelectionLength |
|
4844
|
); |
|
4845
|
} |
|
4846
|
|
|
4847
|
if (options.tags) { |
|
4848
|
options.dataAdapter = Utils.Decorate(options.dataAdapter, Tags); |
|
4849
|
} |
|
4850
|
|
|
4851
|
if (options.tokenSeparators != null || options.tokenizer != null) { |
|
4852
|
options.dataAdapter = Utils.Decorate( |
|
4853
|
options.dataAdapter, |
|
4854
|
Tokenizer |
|
4855
|
); |
|
4856
|
} |
|
4857
|
|
|
4858
|
if (options.query != null) { |
|
4859
|
var Query = require(options.amdBase + 'compat/query'); |
|
4860
|
|
|
4861
|
options.dataAdapter = Utils.Decorate( |
|
4862
|
options.dataAdapter, |
|
4863
|
Query |
|
4864
|
); |
|
4865
|
} |
|
4866
|
|
|
4867
|
if (options.initSelection != null) { |
|
4868
|
var InitSelection = require(options.amdBase + 'compat/initSelection'); |
|
4869
|
|
|
4870
|
options.dataAdapter = Utils.Decorate( |
|
4871
|
options.dataAdapter, |
|
4872
|
InitSelection |
|
4873
|
); |
|
4874
|
} |
|
4875
|
} |
|
4876
|
|
|
4877
|
if (options.resultsAdapter == null) { |
|
4878
|
options.resultsAdapter = ResultsList; |
|
4879
|
|
|
4880
|
if (options.ajax != null) { |
|
4881
|
options.resultsAdapter = Utils.Decorate( |
|
4882
|
options.resultsAdapter, |
|
4883
|
InfiniteScroll |
|
4884
|
); |
|
4885
|
} |
|
4886
|
|
|
4887
|
if (options.placeholder != null) { |
|
4888
|
options.resultsAdapter = Utils.Decorate( |
|
4889
|
options.resultsAdapter, |
|
4890
|
HidePlaceholder |
|
4891
|
); |
|
4892
|
} |
|
4893
|
|
|
4894
|
if (options.selectOnClose) { |
|
4895
|
options.resultsAdapter = Utils.Decorate( |
|
4896
|
options.resultsAdapter, |
|
4897
|
SelectOnClose |
|
4898
|
); |
|
4899
|
} |
|
4900
|
} |
|
4901
|
|
|
4902
|
if (options.dropdownAdapter == null) { |
|
4903
|
if (options.multiple) { |
|
4904
|
options.dropdownAdapter = Dropdown; |
|
4905
|
} else { |
|
4906
|
var SearchableDropdown = Utils.Decorate(Dropdown, DropdownSearch); |
|
4907
|
|
|
4908
|
options.dropdownAdapter = SearchableDropdown; |
|
4909
|
} |
|
4910
|
|
|
4911
|
if (options.minimumResultsForSearch !== 0) { |
|
4912
|
options.dropdownAdapter = Utils.Decorate( |
|
4913
|
options.dropdownAdapter, |
|
4914
|
MinimumResultsForSearch |
|
4915
|
); |
|
4916
|
} |
|
4917
|
|
|
4918
|
if (options.closeOnSelect) { |
|
4919
|
options.dropdownAdapter = Utils.Decorate( |
|
4920
|
options.dropdownAdapter, |
|
4921
|
CloseOnSelect |
|
4922
|
); |
|
4923
|
} |
|
4924
|
|
|
4925
|
if ( |
|
4926
|
options.dropdownCssClass != null || |
|
4927
|
options.dropdownCss != null || |
|
4928
|
options.adaptDropdownCssClass != null |
|
4929
|
) { |
|
4930
|
var DropdownCSS = require(options.amdBase + 'compat/dropdownCss'); |
|
4931
|
|
|
4932
|
options.dropdownAdapter = Utils.Decorate( |
|
4933
|
options.dropdownAdapter, |
|
4934
|
DropdownCSS |
|
4935
|
); |
|
4936
|
} |
|
4937
|
|
|
4938
|
options.dropdownAdapter = Utils.Decorate( |
|
4939
|
options.dropdownAdapter, |
|
4940
|
AttachBody |
|
4941
|
); |
|
4942
|
} |
|
4943
|
|
|
4944
|
if (options.selectionAdapter == null) { |
|
4945
|
if (options.multiple) { |
|
4946
|
options.selectionAdapter = MultipleSelection; |
|
4947
|
} else { |
|
4948
|
options.selectionAdapter = SingleSelection; |
|
4949
|
} |
|
4950
|
|
|
4951
|
// Add the placeholder mixin if a placeholder was specified |
|
4952
|
if (options.placeholder != null) { |
|
4953
|
options.selectionAdapter = Utils.Decorate( |
|
4954
|
options.selectionAdapter, |
|
4955
|
Placeholder |
|
4956
|
); |
|
4957
|
} |
|
4958
|
|
|
4959
|
if (options.allowClear) { |
|
4960
|
options.selectionAdapter = Utils.Decorate( |
|
4961
|
options.selectionAdapter, |
|
4962
|
AllowClear |
|
4963
|
); |
|
4964
|
} |
|
4965
|
|
|
4966
|
if (options.multiple) { |
|
4967
|
options.selectionAdapter = Utils.Decorate( |
|
4968
|
options.selectionAdapter, |
|
4969
|
SelectionSearch |
|
4970
|
); |
|
4971
|
} |
|
4972
|
|
|
4973
|
if ( |
|
4974
|
options.containerCssClass != null || |
|
4975
|
options.containerCss != null || |
|
4976
|
options.adaptContainerCssClass != null |
|
4977
|
) { |
|
4978
|
var ContainerCSS = require(options.amdBase + 'compat/containerCss'); |
|
4979
|
|
|
4980
|
options.selectionAdapter = Utils.Decorate( |
|
4981
|
options.selectionAdapter, |
|
4982
|
ContainerCSS |
|
4983
|
); |
|
4984
|
} |
|
4985
|
|
|
4986
|
options.selectionAdapter = Utils.Decorate( |
|
4987
|
options.selectionAdapter, |
|
4988
|
EventRelay |
|
4989
|
); |
|
4990
|
} |
|
4991
|
|
|
4992
|
// If the defaults were not previously applied from an element, it is |
|
4993
|
// possible for the language option to have not been resolved |
|
4994
|
options.language = this._resolveLanguage(options.language); |
|
4995
|
|
|
4996
|
// Always fall back to English since it will always be complete |
|
4997
|
options.language.push('en'); |
|
4998
|
|
|
4999
|
var uniqueLanguages = []; |
|
5000
|
|
|
5001
|
for (var l = 0; l < options.language.length; l++) { |
|
5002
|
var language = options.language[l]; |
|
5003
|
|
|
5004
|
if (uniqueLanguages.indexOf(language) === -1) { |
|
5005
|
uniqueLanguages.push(language); |
|
5006
|
} |
|
5007
|
} |
|
5008
|
|
|
5009
|
options.language = uniqueLanguages; |
|
5010
|
|
|
5011
|
options.translations = this._processTranslations( |
|
5012
|
options.language, |
|
5013
|
options.debug |
|
5014
|
); |
|
5015
|
|
|
5016
|
return options; |
|
5017
|
}; |
|
5018
|
|
|
5019
|
Defaults.prototype.reset = function () { |
|
5020
|
function stripDiacritics (text) { |
|
5021
|
// Used 'uni range + named function' from http://jsperf.com/diacritics/18 |
|
5022
|
function match(a) { |
|
5023
|
return DIACRITICS[a] || a; |
|
5024
|
} |
|
5025
|
|
|
5026
|
return text.replace(/[^\u0000-\u007E]/g, match); |
|
5027
|
} |
|
5028
|
|
|
5029
|
function matcher (params, data) { |
|
5030
|
// Always return the object if there is nothing to compare |
|
5031
|
if ($.trim(params.term) === '') { |
|
5032
|
return data; |
|
5033
|
} |
|
5034
|
|
|
5035
|
// Do a recursive check for options with children |
|
5036
|
if (data.children && data.children.length > 0) { |
|
5037
|
// Clone the data object if there are children |
|
5038
|
// This is required as we modify the object to remove any non-matches |
|
5039
|
var match = $.extend(true, {}, data); |
|
5040
|
|
|
5041
|
// Check each child of the option |
|
5042
|
for (var c = data.children.length - 1; c >= 0; c--) { |
|
5043
|
var child = data.children[c]; |
|
5044
|
|
|
5045
|
var matches = matcher(params, child); |
|
5046
|
|
|
5047
|
// If there wasn't a match, remove the object in the array |
|
5048
|
if (matches == null) { |
|
5049
|
match.children.splice(c, 1); |
|
5050
|
} |
|
5051
|
} |
|
5052
|
|
|
5053
|
// If any children matched, return the new object |
|
5054
|
if (match.children.length > 0) { |
|
5055
|
return match; |
|
5056
|
} |
|
5057
|
|
|
5058
|
// If there were no matching children, check just the plain object |
|
5059
|
return matcher(params, match); |
|
5060
|
} |
|
5061
|
|
|
5062
|
var original = stripDiacritics(data.text).toUpperCase(); |
|
5063
|
var term = stripDiacritics(params.term).toUpperCase(); |
|
5064
|
|
|
5065
|
// Check if the text contains the term |
|
5066
|
if (original.indexOf(term) > -1) { |
|
5067
|
return data; |
|
5068
|
} |
|
5069
|
|
|
5070
|
// If it doesn't contain the term, don't return anything |
|
5071
|
return null; |
|
5072
|
} |
|
5073
|
|
|
5074
|
this.defaults = { |
|
5075
|
amdBase: './', |
|
5076
|
amdLanguageBase: './i18n/', |
|
5077
|
closeOnSelect: true, |
|
5078
|
debug: false, |
|
5079
|
dropdownAutoWidth: false, |
|
5080
|
escapeMarkup: Utils.escapeMarkup, |
|
5081
|
language: {}, |
|
5082
|
matcher: matcher, |
|
5083
|
minimumInputLength: 0, |
|
5084
|
maximumInputLength: 0, |
|
5085
|
maximumSelectionLength: 0, |
|
5086
|
minimumResultsForSearch: 0, |
|
5087
|
selectOnClose: false, |
|
5088
|
scrollAfterSelect: false, |
|
5089
|
sorter: function (data) { |
|
5090
|
return data; |
|
5091
|
}, |
|
5092
|
templateResult: function (result) { |
|
5093
|
return result.text; |
|
5094
|
}, |
|
5095
|
templateSelection: function (selection) { |
|
5096
|
return selection.text; |
|
5097
|
}, |
|
5098
|
theme: 'default', |
|
5099
|
width: 'resolve' |
|
5100
|
}; |
|
5101
|
}; |
|
5102
|
|
|
5103
|
Defaults.prototype.applyFromElement = function (options, $element) { |
|
5104
|
var optionLanguage = options.language; |
|
5105
|
var defaultLanguage = this.defaults.language; |
|
5106
|
var elementLanguage = $element.prop('lang'); |
|
5107
|
var parentLanguage = $element.closest('[lang]').prop('lang'); |
|
5108
|
|
|
5109
|
var languages = Array.prototype.concat.call( |
|
5110
|
this._resolveLanguage(elementLanguage), |
|
5111
|
this._resolveLanguage(optionLanguage), |
|
5112
|
this._resolveLanguage(defaultLanguage), |
|
5113
|
this._resolveLanguage(parentLanguage) |
|
5114
|
); |
|
5115
|
|
|
5116
|
options.language = languages; |
|
5117
|
|
|
5118
|
return options; |
|
5119
|
}; |
|
5120
|
|
|
5121
|
Defaults.prototype._resolveLanguage = function (language) { |
|
5122
|
if (!language) { |
|
5123
|
return []; |
|
5124
|
} |
|
5125
|
|
|
5126
|
if ($.isEmptyObject(language)) { |
|
5127
|
return []; |
|
5128
|
} |
|
5129
|
|
|
5130
|
if ($.isPlainObject(language)) { |
|
5131
|
return [language]; |
|
5132
|
} |
|
5133
|
|
|
5134
|
var languages; |
|
5135
|
|
|
5136
|
if (!$.isArray(language)) { |
|
5137
|
languages = [language]; |
|
5138
|
} else { |
|
5139
|
languages = language; |
|
5140
|
} |
|
5141
|
|
|
5142
|
var resolvedLanguages = []; |
|
5143
|
|
|
5144
|
for (var l = 0; l < languages.length; l++) { |
|
5145
|
resolvedLanguages.push(languages[l]); |
|
5146
|
|
|
5147
|
if (typeof languages[l] === 'string' && languages[l].indexOf('-') > 0) { |
|
5148
|
// Extract the region information if it is included |
|
5149
|
var languageParts = languages[l].split('-'); |
|
5150
|
var baseLanguage = languageParts[0]; |
|
5151
|
|
|
5152
|
resolvedLanguages.push(baseLanguage); |
|
5153
|
} |
|
5154
|
} |
|
5155
|
|
|
5156
|
return resolvedLanguages; |
|
5157
|
}; |
|
5158
|
|
|
5159
|
Defaults.prototype._processTranslations = function (languages, debug) { |
|
5160
|
var translations = new Translation(); |
|
5161
|
|
|
5162
|
for (var l = 0; l < languages.length; l++) { |
|
5163
|
var languageData = new Translation(); |
|
5164
|
|
|
5165
|
var language = languages[l]; |
|
5166
|
|
|
5167
|
if (typeof language === 'string') { |
|
5168
|
try { |
|
5169
|
// Try to load it with the original name |
|
5170
|
languageData = Translation.loadPath(language); |
|
5171
|
} catch (e) { |
|
5172
|
try { |
|
5173
|
// If we couldn't load it, check if it wasn't the full path |
|
5174
|
language = this.defaults.amdLanguageBase + language; |
|
5175
|
languageData = Translation.loadPath(language); |
|
5176
|
} catch (ex) { |
|
5177
|
// The translation could not be loaded at all. Sometimes this is |
|
5178
|
// because of a configuration problem, other times this can be |
|
5179
|
// because of how Select2 helps load all possible translation files |
|
5180
|
if (debug && window.console && console.warn) { |
|
5181
|
console.warn( |
|
5182
|
'Select2: The language file for "' + language + '" could ' + |
|
5183
|
'not be automatically loaded. A fallback will be used instead.' |
|
5184
|
); |
|
5185
|
} |
|
5186
|
} |
|
5187
|
} |
|
5188
|
} else if ($.isPlainObject(language)) { |
|
5189
|
languageData = new Translation(language); |
|
5190
|
} else { |
|
5191
|
languageData = language; |
|
5192
|
} |
|
5193
|
|
|
5194
|
translations.extend(languageData); |
|
5195
|
} |
|
5196
|
|
|
5197
|
return translations; |
|
5198
|
}; |
|
5199
|
|
|
5200
|
Defaults.prototype.set = function (key, value) { |
|
5201
|
var camelKey = $.camelCase(key); |
|
5202
|
|
|
5203
|
var data = {}; |
|
5204
|
data[camelKey] = value; |
|
5205
|
|
|
5206
|
var convertedData = Utils._convertData(data); |
|
5207
|
|
|
5208
|
$.extend(true, this.defaults, convertedData); |
|
5209
|
}; |
|
5210
|
|
|
5211
|
var defaults = new Defaults(); |
|
5212
|
|
|
5213
|
return defaults; |
|
5214
|
}); |
|
5215
|
|
|
5216
|
S2.define('select2/options',[ |
|
5217
|
'require', |
|
5218
|
'jquery', |
|
5219
|
'./defaults', |
|
5220
|
'./utils' |
|
5221
|
], function (require, $, Defaults, Utils) { |
|
5222
|
function Options (options, $element) { |
|
5223
|
this.options = options; |
|
5224
|
|
|
5225
|
if ($element != null) { |
|
5226
|
this.fromElement($element); |
|
5227
|
} |
|
5228
|
|
|
5229
|
if ($element != null) { |
|
5230
|
this.options = Defaults.applyFromElement(this.options, $element); |
|
5231
|
} |
|
5232
|
|
|
5233
|
this.options = Defaults.apply(this.options); |
|
5234
|
|
|
5235
|
if ($element && $element.is('input')) { |
|
5236
|
var InputCompat = require(this.get('amdBase') + 'compat/inputData'); |
|
5237
|
|
|
5238
|
this.options.dataAdapter = Utils.Decorate( |
|
5239
|
this.options.dataAdapter, |
|
5240
|
InputCompat |
|
5241
|
); |
|
5242
|
} |
|
5243
|
} |
|
5244
|
|
|
5245
|
Options.prototype.fromElement = function ($e) { |
|
5246
|
var excludedData = ['select2']; |
|
5247
|
|
|
5248
|
if (this.options.multiple == null) { |
|
5249
|
this.options.multiple = $e.prop('multiple'); |
|
5250
|
} |
|
5251
|
|
|
5252
|
if (this.options.disabled == null) { |
|
5253
|
this.options.disabled = $e.prop('disabled'); |
|
5254
|
} |
|
5255
|
|
|
5256
|
if (this.options.dir == null) { |
|
5257
|
if ($e.prop('dir')) { |
|
5258
|
this.options.dir = $e.prop('dir'); |
|
5259
|
} else if ($e.closest('[dir]').prop('dir')) { |
|
5260
|
this.options.dir = $e.closest('[dir]').prop('dir'); |
|
5261
|
} else { |
|
5262
|
this.options.dir = 'ltr'; |
|
5263
|
} |
|
5264
|
} |
|
5265
|
|
|
5266
|
$e.prop('disabled', this.options.disabled); |
|
5267
|
$e.prop('multiple', this.options.multiple); |
|
5268
|
|
|
5269
|
if (Utils.GetData($e[0], 'select2Tags')) { |
|
5270
|
if (this.options.debug && window.console && console.warn) { |
|
5271
|
console.warn( |
|
5272
|
'Select2: The `data-select2-tags` attribute has been changed to ' + |
|
5273
|
'use the `data-data` and `data-tags="true"` attributes and will be ' + |
|
5274
|
'removed in future versions of Select2.' |
|
5275
|
); |
|
5276
|
} |
|
5277
|
|
|
5278
|
Utils.StoreData($e[0], 'data', Utils.GetData($e[0], 'select2Tags')); |
|
5279
|
Utils.StoreData($e[0], 'tags', true); |
|
5280
|
} |
|
5281
|
|
|
5282
|
if (Utils.GetData($e[0], 'ajaxUrl')) { |
|
5283
|
if (this.options.debug && window.console && console.warn) { |
|
5284
|
console.warn( |
|
5285
|
'Select2: The `data-ajax-url` attribute has been changed to ' + |
|
5286
|
'`data-ajax--url` and support for the old attribute will be removed' + |
|
5287
|
' in future versions of Select2.' |
|
5288
|
); |
|
5289
|
} |
|
5290
|
|
|
5291
|
$e.attr('ajax--url', Utils.GetData($e[0], 'ajaxUrl')); |
|
5292
|
Utils.StoreData($e[0], 'ajax-Url', Utils.GetData($e[0], 'ajaxUrl')); |
|
5293
|
} |
|
5294
|
|
|
5295
|
var dataset = {}; |
|
5296
|
|
|
5297
|
function upperCaseLetter(_, letter) { |
|
5298
|
return letter.toUpperCase(); |
|
5299
|
} |
|
5300
|
|
|
5301
|
// Pre-load all of the attributes which are prefixed with `data-` |
|
5302
|
for (var attr = 0; attr < $e[0].attributes.length; attr++) { |
|
5303
|
var attributeName = $e[0].attributes[attr].name; |
|
5304
|
var prefix = 'data-'; |
|
5305
|
|
|
5306
|
if (attributeName.substr(0, prefix.length) == prefix) { |
|
5307
|
// Get the contents of the attribute after `data-` |
|
5308
|
var dataName = attributeName.substring(prefix.length); |
|
5309
|
|
|
5310
|
// Get the data contents from the consistent source |
|
5311
|
// This is more than likely the jQuery data helper |
|
5312
|
var dataValue = Utils.GetData($e[0], dataName); |
|
5313
|
|
|
5314
|
// camelCase the attribute name to match the spec |
|
5315
|
var camelDataName = dataName.replace(/-([a-z])/g, upperCaseLetter); |
|
5316
|
|
|
5317
|
// Store the data attribute contents into the dataset since |
|
5318
|
dataset[camelDataName] = dataValue; |
|
5319
|
} |
|
5320
|
} |
|
5321
|
|
|
5322
|
// Prefer the element's `dataset` attribute if it exists |
|
5323
|
// jQuery 1.x does not correctly handle data attributes with multiple dashes |
|
5324
|
if ($.fn.jquery && $.fn.jquery.substr(0, 2) == '1.' && $e[0].dataset) { |
|
5325
|
dataset = $.extend(true, {}, $e[0].dataset, dataset); |
|
5326
|
} |
|
5327
|
|
|
5328
|
// Prefer our internal data cache if it exists |
|
5329
|
var data = $.extend(true, {}, Utils.GetData($e[0]), dataset); |
|
5330
|
|
|
5331
|
data = Utils._convertData(data); |
|
5332
|
|
|
5333
|
for (var key in data) { |
|
5334
|
if ($.inArray(key, excludedData) > -1) { |
|
5335
|
continue; |
|
5336
|
} |
|
5337
|
|
|
5338
|
if ($.isPlainObject(this.options[key])) { |
|
5339
|
$.extend(this.options[key], data[key]); |
|
5340
|
} else { |
|
5341
|
this.options[key] = data[key]; |
|
5342
|
} |
|
5343
|
} |
|
5344
|
|
|
5345
|
return this; |
|
5346
|
}; |
|
5347
|
|
|
5348
|
Options.prototype.get = function (key) { |
|
5349
|
return this.options[key]; |
|
5350
|
}; |
|
5351
|
|
|
5352
|
Options.prototype.set = function (key, val) { |
|
5353
|
this.options[key] = val; |
|
5354
|
}; |
|
5355
|
|
|
5356
|
return Options; |
|
5357
|
}); |
|
5358
|
|
|
5359
|
S2.define('select2/core',[ |
|
5360
|
'jquery', |
|
5361
|
'./options', |
|
5362
|
'./utils', |
|
5363
|
'./keys' |
|
5364
|
], function ($, Options, Utils, KEYS) { |
|
5365
|
var Select2 = function ($element, options) { |
|
5366
|
if (Utils.GetData($element[0], 'select2') != null) { |
|
5367
|
Utils.GetData($element[0], 'select2').destroy(); |
|
5368
|
} |
|
5369
|
|
|
5370
|
this.$element = $element; |
|
5371
|
|
|
5372
|
this.id = this._generateId($element); |
|
5373
|
|
|
5374
|
options = options || {}; |
|
5375
|
|
|
5376
|
this.options = new Options(options, $element); |
|
5377
|
|
|
5378
|
Select2.__super__.constructor.call(this); |
|
5379
|
|
|
5380
|
// Set up the tabindex |
|
5381
|
|
|
5382
|
var tabindex = $element.attr('tabindex') || 0; |
|
5383
|
Utils.StoreData($element[0], 'old-tabindex', tabindex); |
|
5384
|
$element.attr('tabindex', '-1'); |
|
5385
|
|
|
5386
|
// Set up containers and adapters |
|
5387
|
|
|
5388
|
var DataAdapter = this.options.get('dataAdapter'); |
|
5389
|
this.dataAdapter = new DataAdapter($element, this.options); |
|
5390
|
|
|
5391
|
var $container = this.render(); |
|
5392
|
|
|
5393
|
this._placeContainer($container); |
|
5394
|
|
|
5395
|
var SelectionAdapter = this.options.get('selectionAdapter'); |
|
5396
|
this.selection = new SelectionAdapter($element, this.options); |
|
5397
|
this.$selection = this.selection.render(); |
|
5398
|
|
|
5399
|
this.selection.position(this.$selection, $container); |
|
5400
|
|
|
5401
|
var DropdownAdapter = this.options.get('dropdownAdapter'); |
|
5402
|
this.dropdown = new DropdownAdapter($element, this.options); |
|
5403
|
this.$dropdown = this.dropdown.render(); |
|
5404
|
|
|
5405
|
this.dropdown.position(this.$dropdown, $container); |
|
5406
|
|
|
5407
|
var ResultsAdapter = this.options.get('resultsAdapter'); |
|
5408
|
this.results = new ResultsAdapter($element, this.options, this.dataAdapter); |
|
5409
|
this.$results = this.results.render(); |
|
5410
|
|
|
5411
|
this.results.position(this.$results, this.$dropdown); |
|
5412
|
|
|
5413
|
// Bind events |
|
5414
|
|
|
5415
|
var self = this; |
|
5416
|
|
|
5417
|
// Bind the container to all of the adapters |
|
5418
|
this._bindAdapters(); |
|
5419
|
|
|
5420
|
// Register any DOM event handlers |
|
5421
|
this._registerDomEvents(); |
|
5422
|
|
|
5423
|
// Register any internal event handlers |
|
5424
|
this._registerDataEvents(); |
|
5425
|
this._registerSelectionEvents(); |
|
5426
|
this._registerDropdownEvents(); |
|
5427
|
this._registerResultsEvents(); |
|
5428
|
this._registerEvents(); |
|
5429
|
|
|
5430
|
// Set the initial state |
|
5431
|
this.dataAdapter.current(function (initialData) { |
|
5432
|
self.trigger('selection:update', { |
|
5433
|
data: initialData |
|
5434
|
}); |
|
5435
|
}); |
|
5436
|
|
|
5437
|
// Hide the original select |
|
5438
|
$element.addClass('select2-hidden-accessible'); |
|
5439
|
$element.attr('aria-hidden', 'true'); |
|
5440
|
|
|
5441
|
// Synchronize any monitored attributes |
|
5442
|
this._syncAttributes(); |
|
5443
|
|
|
5444
|
Utils.StoreData($element[0], 'select2', this); |
|
5445
|
|
|
5446
|
// Ensure backwards compatibility with $element.data('select2'). |
|
5447
|
$element.data('select2', this); |
|
5448
|
}; |
|
5449
|
|
|
5450
|
Utils.Extend(Select2, Utils.Observable); |
|
5451
|
|
|
5452
|
Select2.prototype._generateId = function ($element) { |
|
5453
|
var id = ''; |
|
5454
|
|
|
5455
|
if ($element.attr('id') != null) { |
|
5456
|
id = $element.attr('id'); |
|
5457
|
} else if ($element.attr('name') != null) { |
|
5458
|
id = $element.attr('name') + '-' + Utils.generateChars(2); |
|
5459
|
} else { |
|
5460
|
id = Utils.generateChars(4); |
|
5461
|
} |
|
5462
|
|
|
5463
|
id = id.replace(/(:|\.|\[|\]|,)/g, ''); |
|
5464
|
id = 'select2-' + id; |
|
5465
|
|
|
5466
|
return id; |
|
5467
|
}; |
|
5468
|
|
|
5469
|
Select2.prototype._placeContainer = function ($container) { |
|
5470
|
$container.insertAfter(this.$element); |
|
5471
|
|
|
5472
|
var width = this._resolveWidth(this.$element, this.options.get('width')); |
|
5473
|
|
|
5474
|
if (width != null) { |
|
5475
|
$container.css('width', width); |
|
5476
|
} |
|
5477
|
}; |
|
5478
|
|
|
5479
|
Select2.prototype._resolveWidth = function ($element, method) { |
|
5480
|
var WIDTH = /^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i; |
|
5481
|
|
|
5482
|
if (method == 'resolve') { |
|
5483
|
var styleWidth = this._resolveWidth($element, 'style'); |
|
5484
|
|
|
5485
|
if (styleWidth != null) { |
|
5486
|
return styleWidth; |
|
5487
|
} |
|
5488
|
|
|
5489
|
return this._resolveWidth($element, 'element'); |
|
5490
|
} |
|
5491
|
|
|
5492
|
if (method == 'element') { |
|
5493
|
var elementWidth = $element.outerWidth(false); |
|
5494
|
|
|
5495
|
if (elementWidth <= 0) { |
|
5496
|
return 'auto'; |
|
5497
|
} |
|
5498
|
|
|
5499
|
return elementWidth + 'px'; |
|
5500
|
} |
|
5501
|
|
|
5502
|
if (method == 'style') { |
|
5503
|
var style = $element.attr('style'); |
|
5504
|
|
|
5505
|
if (typeof(style) !== 'string') { |
|
5506
|
return null; |
|
5507
|
} |
|
5508
|
|
|
5509
|
var attrs = style.split(';'); |
|
5510
|
|
|
5511
|
for (var i = 0, l = attrs.length; i < l; i = i + 1) { |
|
5512
|
var attr = attrs[i].replace(/\s/g, ''); |
|
5513
|
var matches = attr.match(WIDTH); |
|
5514
|
|
|
5515
|
if (matches !== null && matches.length >= 1) { |
|
5516
|
return matches[1]; |
|
5517
|
} |
|
5518
|
} |
|
5519
|
|
|
5520
|
return null; |
|
5521
|
} |
|
5522
|
|
|
5523
|
if (method == 'computedstyle') { |
|
5524
|
var computedStyle = window.getComputedStyle($element[0]); |
|
5525
|
|
|
5526
|
return computedStyle.width; |
|
5527
|
} |
|
5528
|
|
|
5529
|
return method; |
|
5530
|
}; |
|
5531
|
|
|
5532
|
Select2.prototype._bindAdapters = function () { |
|
5533
|
this.dataAdapter.bind(this, this.$container); |
|
5534
|
this.selection.bind(this, this.$container); |
|
5535
|
|
|
5536
|
this.dropdown.bind(this, this.$container); |
|
5537
|
this.results.bind(this, this.$container); |
|
5538
|
}; |
|
5539
|
|
|
5540
|
Select2.prototype._registerDomEvents = function () { |
|
5541
|
var self = this; |
|
5542
|
|
|
5543
|
this.$element.on('change.select2', function () { |
|
5544
|
self.dataAdapter.current(function (data) { |
|
5545
|
self.trigger('selection:update', { |
|
5546
|
data: data |
|
5547
|
}); |
|
5548
|
}); |
|
5549
|
}); |
|
5550
|
|
|
5551
|
this.$element.on('focus.select2', function (evt) { |
|
5552
|
self.trigger('focus', evt); |
|
5553
|
}); |
|
5554
|
|
|
5555
|
this._syncA = Utils.bind(this._syncAttributes, this); |
|
5556
|
this._syncS = Utils.bind(this._syncSubtree, this); |
|
5557
|
|
|
5558
|
if (this.$element[0].attachEvent) { |
|
5559
|
this.$element[0].attachEvent('onpropertychange', this._syncA); |
|
5560
|
} |
|
5561
|
|
|
5562
|
var observer = window.MutationObserver || |
|
5563
|
window.WebKitMutationObserver || |
|
5564
|
window.MozMutationObserver |
|
5565
|
; |
|
5566
|
|
|
5567
|
if (observer != null) { |
|
5568
|
this._observer = new observer(function (mutations) { |
|
5569
|
self._syncA(); |
|
5570
|
self._syncS(null, mutations); |
|
5571
|
}); |
|
5572
|
this._observer.observe(this.$element[0], { |
|
5573
|
attributes: true, |
|
5574
|
childList: true, |
|
5575
|
subtree: false |
|
5576
|
}); |
|
5577
|
} else if (this.$element[0].addEventListener) { |
|
5578
|
this.$element[0].addEventListener( |
|
5579
|
'DOMAttrModified', |
|
5580
|
self._syncA, |
|
5581
|
false |
|
5582
|
); |
|
5583
|
this.$element[0].addEventListener( |
|
5584
|
'DOMNodeInserted', |
|
5585
|
self._syncS, |
|
5586
|
false |
|
5587
|
); |
|
5588
|
this.$element[0].addEventListener( |
|
5589
|
'DOMNodeRemoved', |
|
5590
|
self._syncS, |
|
5591
|
false |
|
5592
|
); |
|
5593
|
} |
|
5594
|
}; |
|
5595
|
|
|
5596
|
Select2.prototype._registerDataEvents = function () { |
|
5597
|
var self = this; |
|
5598
|
|
|
5599
|
this.dataAdapter.on('*', function (name, params) { |
|
5600
|
self.trigger(name, params); |
|
5601
|
}); |
|
5602
|
}; |
|
5603
|
|
|
5604
|
Select2.prototype._registerSelectionEvents = function () { |
|
5605
|
var self = this; |
|
5606
|
var nonRelayEvents = ['toggle', 'focus']; |
|
5607
|
|
|
5608
|
this.selection.on('toggle', function () { |
|
5609
|
self.toggleDropdown(); |
|
5610
|
}); |
|
5611
|
|
|
5612
|
this.selection.on('focus', function (params) { |
|
5613
|
self.focus(params); |
|
5614
|
}); |
|
5615
|
|
|
5616
|
this.selection.on('*', function (name, params) { |
|
5617
|
if ($.inArray(name, nonRelayEvents) !== -1) { |
|
5618
|
return; |
|
5619
|
} |
|
5620
|
|
|
5621
|
self.trigger(name, params); |
|
5622
|
}); |
|
5623
|
}; |
|
5624
|
|
|
5625
|
Select2.prototype._registerDropdownEvents = function () { |
|
5626
|
var self = this; |
|
5627
|
|
|
5628
|
this.dropdown.on('*', function (name, params) { |
|
5629
|
self.trigger(name, params); |
|
5630
|
}); |
|
5631
|
}; |
|
5632
|
|
|
5633
|
Select2.prototype._registerResultsEvents = function () { |
|
5634
|
var self = this; |
|
5635
|
|
|
5636
|
this.results.on('*', function (name, params) { |
|
5637
|
self.trigger(name, params); |
|
5638
|
}); |
|
5639
|
}; |
|
5640
|
|
|
5641
|
Select2.prototype._registerEvents = function () { |
|
5642
|
var self = this; |
|
5643
|
|
|
5644
|
this.on('open', function () { |
|
5645
|
self.$container.addClass('select2-container--open'); |
|
5646
|
}); |
|
5647
|
|
|
5648
|
this.on('close', function () { |
|
5649
|
self.$container.removeClass('select2-container--open'); |
|
5650
|
}); |
|
5651
|
|
|
5652
|
this.on('enable', function () { |
|
5653
|
self.$container.removeClass('select2-container--disabled'); |
|
5654
|
}); |
|
5655
|
|
|
5656
|
this.on('disable', function () { |
|
5657
|
self.$container.addClass('select2-container--disabled'); |
|
5658
|
}); |
|
5659
|
|
|
5660
|
this.on('blur', function () { |
|
5661
|
self.$container.removeClass('select2-container--focus'); |
|
5662
|
}); |
|
5663
|
|
|
5664
|
this.on('query', function (params) { |
|
5665
|
if (!self.isOpen()) { |
|
5666
|
self.trigger('open', {}); |
|
5667
|
} |
|
5668
|
|
|
5669
|
this.dataAdapter.query(params, function (data) { |
|
5670
|
self.trigger('results:all', { |
|
5671
|
data: data, |
|
5672
|
query: params |
|
5673
|
}); |
|
5674
|
}); |
|
5675
|
}); |
|
5676
|
|
|
5677
|
this.on('query:append', function (params) { |
|
5678
|
this.dataAdapter.query(params, function (data) { |
|
5679
|
self.trigger('results:append', { |
|
5680
|
data: data, |
|
5681
|
query: params |
|
5682
|
}); |
|
5683
|
}); |
|
5684
|
}); |
|
5685
|
|
|
5686
|
this.on('keypress', function (evt) { |
|
5687
|
var key = evt.which; |
|
5688
|
|
|
5689
|
if (self.isOpen()) { |
|
5690
|
if (key === KEYS.ESC || key === KEYS.TAB || |
|
5691
|
(key === KEYS.UP && evt.altKey)) { |
|
5692
|
self.close(evt); |
|
5693
|
|
|
5694
|
evt.preventDefault(); |
|
5695
|
} else if (key === KEYS.ENTER) { |
|
5696
|
self.trigger('results:select', {}); |
|
5697
|
|
|
5698
|
evt.preventDefault(); |
|
5699
|
} else if ((key === KEYS.SPACE && evt.ctrlKey)) { |
|
5700
|
self.trigger('results:toggle', {}); |
|
5701
|
|
|
5702
|
evt.preventDefault(); |
|
5703
|
} else if (key === KEYS.UP) { |
|
5704
|
self.trigger('results:previous', {}); |
|
5705
|
|
|
5706
|
evt.preventDefault(); |
|
5707
|
} else if (key === KEYS.DOWN) { |
|
5708
|
self.trigger('results:next', {}); |
|
5709
|
|
|
5710
|
evt.preventDefault(); |
|
5711
|
} |
|
5712
|
} else { |
|
5713
|
if (key === KEYS.ENTER || key === KEYS.SPACE || |
|
5714
|
(key === KEYS.DOWN && evt.altKey)) { |
|
5715
|
self.open(); |
|
5716
|
|
|
5717
|
evt.preventDefault(); |
|
5718
|
} |
|
5719
|
} |
|
5720
|
}); |
|
5721
|
}; |
|
5722
|
|
|
5723
|
Select2.prototype._syncAttributes = function () { |
|
5724
|
this.options.set('disabled', this.$element.prop('disabled')); |
|
5725
|
|
|
5726
|
if (this.isDisabled()) { |
|
5727
|
if (this.isOpen()) { |
|
5728
|
this.close(); |
|
5729
|
} |
|
5730
|
|
|
5731
|
this.trigger('disable', {}); |
|
5732
|
} else { |
|
5733
|
this.trigger('enable', {}); |
|
5734
|
} |
|
5735
|
}; |
|
5736
|
|
|
5737
|
Select2.prototype._isChangeMutation = function (evt, mutations) { |
|
5738
|
var changed = false; |
|
5739
|
var self = this; |
|
5740
|
|
|
5741
|
// Ignore any mutation events raised for elements that aren't options or |
|
5742
|
// optgroups. This handles the case when the select element is destroyed |
|
5743
|
if ( |
|
5744
|
evt && evt.target && ( |
|
5745
|
evt.target.nodeName !== 'OPTION' && evt.target.nodeName !== 'OPTGROUP' |
|
5746
|
) |
|
5747
|
) { |
|
5748
|
return; |
|
5749
|
} |
|
5750
|
|
|
5751
|
if (!mutations) { |
|
5752
|
// If mutation events aren't supported, then we can only assume that the |
|
5753
|
// change affected the selections |
|
5754
|
changed = true; |
|
5755
|
} else if (mutations.addedNodes && mutations.addedNodes.length > 0) { |
|
5756
|
for (var n = 0; n < mutations.addedNodes.length; n++) { |
|
5757
|
var node = mutations.addedNodes[n]; |
|
5758
|
|
|
5759
|
if (node.selected) { |
|
5760
|
changed = true; |
|
5761
|
} |
|
5762
|
} |
|
5763
|
} else if (mutations.removedNodes && mutations.removedNodes.length > 0) { |
|
5764
|
changed = true; |
|
5765
|
} else if ($.isArray(mutations)) { |
|
5766
|
$.each(mutations, function(evt, mutation) { |
|
5767
|
if (self._isChangeMutation(evt, mutation)) { |
|
5768
|
// We've found a change mutation. |
|
5769
|
// Let's escape from the loop and continue |
|
5770
|
changed = true; |
|
5771
|
return false; |
|
5772
|
} |
|
5773
|
}); |
|
5774
|
} |
|
5775
|
return changed; |
|
5776
|
}; |
|
5777
|
|
|
5778
|
Select2.prototype._syncSubtree = function (evt, mutations) { |
|
5779
|
var changed = this._isChangeMutation(evt, mutations); |
|
5780
|
var self = this; |
|
5781
|
|
|
5782
|
// Only re-pull the data if we think there is a change |
|
5783
|
if (changed) { |
|
5784
|
this.dataAdapter.current(function (currentData) { |
|
5785
|
self.trigger('selection:update', { |
|
5786
|
data: currentData |
|
5787
|
}); |
|
5788
|
}); |
|
5789
|
} |
|
5790
|
}; |
|
5791
|
|
|
5792
|
/** |
|
5793
|
* Override the trigger method to automatically trigger pre-events when |
|
5794
|
* there are events that can be prevented. |
|
5795
|
*/ |
|
5796
|
Select2.prototype.trigger = function (name, args) { |
|
5797
|
var actualTrigger = Select2.__super__.trigger; |
|
5798
|
var preTriggerMap = { |
|
5799
|
'open': 'opening', |
|
5800
|
'close': 'closing', |
|
5801
|
'select': 'selecting', |
|
5802
|
'unselect': 'unselecting', |
|
5803
|
'clear': 'clearing' |
|
5804
|
}; |
|
5805
|
|
|
5806
|
if (args === undefined) { |
|
5807
|
args = {}; |
|
5808
|
} |
|
5809
|
|
|
5810
|
if (name in preTriggerMap) { |
|
5811
|
var preTriggerName = preTriggerMap[name]; |
|
5812
|
var preTriggerArgs = { |
|
5813
|
prevented: false, |
|
5814
|
name: name, |
|
5815
|
args: args |
|
5816
|
}; |
|
5817
|
|
|
5818
|
actualTrigger.call(this, preTriggerName, preTriggerArgs); |
|
5819
|
|
|
5820
|
if (preTriggerArgs.prevented) { |
|
5821
|
args.prevented = true; |
|
5822
|
|
|
5823
|
return; |
|
5824
|
} |
|
5825
|
} |
|
5826
|
|
|
5827
|
actualTrigger.call(this, name, args); |
|
5828
|
}; |
|
5829
|
|
|
5830
|
Select2.prototype.toggleDropdown = function () { |
|
5831
|
if (this.isDisabled()) { |
|
5832
|
return; |
|
5833
|
} |
|
5834
|
|
|
5835
|
if (this.isOpen()) { |
|
5836
|
this.close(); |
|
5837
|
} else { |
|
5838
|
this.open(); |
|
5839
|
} |
|
5840
|
}; |
|
5841
|
|
|
5842
|
Select2.prototype.open = function () { |
|
5843
|
if (this.isOpen()) { |
|
5844
|
return; |
|
5845
|
} |
|
5846
|
|
|
5847
|
if (this.isDisabled()) { |
|
5848
|
return; |
|
5849
|
} |
|
5850
|
|
|
5851
|
this.trigger('query', {}); |
|
5852
|
}; |
|
5853
|
|
|
5854
|
Select2.prototype.close = function (evt) { |
|
5855
|
if (!this.isOpen()) { |
|
5856
|
return; |
|
5857
|
} |
|
5858
|
|
|
5859
|
this.trigger('close', { originalEvent : evt }); |
|
5860
|
}; |
|
5861
|
|
|
5862
|
/** |
|
5863
|
* Helper method to abstract the "enabled" (not "disabled") state of this |
|
5864
|
* object. |
|
5865
|
* |
|
5866
|
* @return {true} if the instance is not disabled. |
|
5867
|
* @return {false} if the instance is disabled. |
|
5868
|
*/ |
|
5869
|
Select2.prototype.isEnabled = function () { |
|
5870
|
return !this.isDisabled(); |
|
5871
|
}; |
|
5872
|
|
|
5873
|
/** |
|
5874
|
* Helper method to abstract the "disabled" state of this object. |
|
5875
|
* |
|
5876
|
* @return {true} if the disabled option is true. |
|
5877
|
* @return {false} if the disabled option is false. |
|
5878
|
*/ |
|
5879
|
Select2.prototype.isDisabled = function () { |
|
5880
|
return this.options.get('disabled'); |
|
5881
|
}; |
|
5882
|
|
|
5883
|
Select2.prototype.isOpen = function () { |
|
5884
|
return this.$container.hasClass('select2-container--open'); |
|
5885
|
}; |
|
5886
|
|
|
5887
|
Select2.prototype.hasFocus = function () { |
|
5888
|
return this.$container.hasClass('select2-container--focus'); |
|
5889
|
}; |
|
5890
|
|
|
5891
|
Select2.prototype.focus = function (data) { |
|
5892
|
// No need to re-trigger focus events if we are already focused |
|
5893
|
if (this.hasFocus()) { |
|
5894
|
return; |
|
5895
|
} |
|
5896
|
|
|
5897
|
this.$container.addClass('select2-container--focus'); |
|
5898
|
this.trigger('focus', {}); |
|
5899
|
}; |
|
5900
|
|
|
5901
|
Select2.prototype.enable = function (args) { |
|
5902
|
if (this.options.get('debug') && window.console && console.warn) { |
|
5903
|
console.warn( |
|
5904
|
'Select2: The `select2("enable")` method has been deprecated and will' + |
|
5905
|
' be removed in later Select2 versions. Use $element.prop("disabled")' + |
|
5906
|
' instead.' |
|
5907
|
); |
|
5908
|
} |
|
5909
|
|
|
5910
|
if (args == null || args.length === 0) { |
|
5911
|
args = [true]; |
|
5912
|
} |
|
5913
|
|
|
5914
|
var disabled = !args[0]; |
|
5915
|
|
|
5916
|
this.$element.prop('disabled', disabled); |
|
5917
|
}; |
|
5918
|
|
|
5919
|
Select2.prototype.data = function () { |
|
5920
|
if (this.options.get('debug') && |
|
5921
|
arguments.length > 0 && window.console && console.warn) { |
|
5922
|
console.warn( |
|
5923
|
'Select2: Data can no longer be set using `select2("data")`. You ' + |
|
5924
|
'should consider setting the value instead using `$element.val()`.' |
|
5925
|
); |
|
5926
|
} |
|
5927
|
|
|
5928
|
var data = []; |
|
5929
|
|
|
5930
|
this.dataAdapter.current(function (currentData) { |
|
5931
|
data = currentData; |
|
5932
|
}); |
|
5933
|
|
|
5934
|
return data; |
|
5935
|
}; |
|
5936
|
|
|
5937
|
Select2.prototype.val = function (args) { |
|
5938
|
if (this.options.get('debug') && window.console && console.warn) { |
|
5939
|
console.warn( |
|
5940
|
'Select2: The `select2("val")` method has been deprecated and will be' + |
|
5941
|
' removed in later Select2 versions. Use $element.val() instead.' |
|
5942
|
); |
|
5943
|
} |
|
5944
|
|
|
5945
|
if (args == null || args.length === 0) { |
|
5946
|
return this.$element.val(); |
|
5947
|
} |
|
5948
|
|
|
5949
|
var newVal = args[0]; |
|
5950
|
|
|
5951
|
if ($.isArray(newVal)) { |
|
5952
|
newVal = $.map(newVal, function (obj) { |
|
5953
|
return obj.toString(); |
|
5954
|
}); |
|
5955
|
} |
|
5956
|
|
|
5957
|
this.$element.val(newVal).trigger('input').trigger('change'); |
|
5958
|
}; |
|
5959
|
|
|
5960
|
Select2.prototype.destroy = function () { |
|
5961
|
this.$container.remove(); |
|
5962
|
|
|
5963
|
if (this.$element[0].detachEvent) { |
|
5964
|
this.$element[0].detachEvent('onpropertychange', this._syncA); |
|
5965
|
} |
|
5966
|
|
|
5967
|
if (this._observer != null) { |
|
5968
|
this._observer.disconnect(); |
|
5969
|
this._observer = null; |
|
5970
|
} else if (this.$element[0].removeEventListener) { |
|
5971
|
this.$element[0] |
|
5972
|
.removeEventListener('DOMAttrModified', this._syncA, false); |
|
5973
|
this.$element[0] |
|
5974
|
.removeEventListener('DOMNodeInserted', this._syncS, false); |
|
5975
|
this.$element[0] |
|
5976
|
.removeEventListener('DOMNodeRemoved', this._syncS, false); |
|
5977
|
} |
|
5978
|
|
|
5979
|
this._syncA = null; |
|
5980
|
this._syncS = null; |
|
5981
|
|
|
5982
|
this.$element.off('.select2'); |
|
5983
|
this.$element.attr('tabindex', |
|
5984
|
Utils.GetData(this.$element[0], 'old-tabindex')); |
|
5985
|
|
|
5986
|
this.$element.removeClass('select2-hidden-accessible'); |
|
5987
|
this.$element.attr('aria-hidden', 'false'); |
|
5988
|
Utils.RemoveData(this.$element[0]); |
|
5989
|
this.$element.removeData('select2'); |
|
5990
|
|
|
5991
|
this.dataAdapter.destroy(); |
|
5992
|
this.selection.destroy(); |
|
5993
|
this.dropdown.destroy(); |
|
5994
|
this.results.destroy(); |
|
5995
|
|
|
5996
|
this.dataAdapter = null; |
|
5997
|
this.selection = null; |
|
5998
|
this.dropdown = null; |
|
5999
|
this.results = null; |
|
6000
|
}; |
|
6001
|
|
|
6002
|
Select2.prototype.render = function () { |
|
6003
|
var $container = $( |
|
6004
|
'<span class="select2 select2-container">' + |
|
6005
|
'<span class="selection"></span>' + |
|
6006
|
'<span class="dropdown-wrapper" aria-hidden="true"></span>' + |
|
6007
|
'</span>' |
|
6008
|
); |
|
6009
|
|
|
6010
|
$container.attr('dir', this.options.get('dir')); |
|
6011
|
|
|
6012
|
this.$container = $container; |
|
6013
|
|
|
6014
|
this.$container.addClass('select2-container--' + this.options.get('theme')); |
|
6015
|
|
|
6016
|
Utils.StoreData($container[0], 'element', this.$element); |
|
6017
|
|
|
6018
|
return $container; |
|
6019
|
}; |
|
6020
|
|
|
6021
|
return Select2; |
|
6022
|
}); |
|
6023
|
|
|
6024
|
S2.define('select2/compat/utils',[ |
|
6025
|
'jquery' |
|
6026
|
], function ($) { |
|
6027
|
function syncCssClasses ($dest, $src, adapter) { |
|
6028
|
var classes, replacements = [], adapted; |
|
6029
|
|
|
6030
|
classes = $.trim($dest.attr('class')); |
|
6031
|
|
|
6032
|
if (classes) { |
|
6033
|
classes = '' + classes; // for IE which returns object |
|
6034
|
|
|
6035
|
$(classes.split(/\s+/)).each(function () { |
|
6036
|
// Save all Select2 classes |
|
6037
|
if (this.indexOf('select2-') === 0) { |
|
6038
|
replacements.push(this); |
|
6039
|
} |
|
6040
|
}); |
|
6041
|
} |
|
6042
|
|
|
6043
|
classes = $.trim($src.attr('class')); |
|
6044
|
|
|
6045
|
if (classes) { |
|
6046
|
classes = '' + classes; // for IE which returns object |
|
6047
|
|
|
6048
|
$(classes.split(/\s+/)).each(function () { |
|
6049
|
// Only adapt non-Select2 classes |
|
6050
|
if (this.indexOf('select2-') !== 0) { |
|
6051
|
adapted = adapter(this); |
|
6052
|
|
|
6053
|
if (adapted != null) { |
|
6054
|
replacements.push(adapted); |
|
6055
|
} |
|
6056
|
} |
|
6057
|
}); |
|
6058
|
} |
|
6059
|
|
|
6060
|
$dest.attr('class', replacements.join(' ')); |
|
6061
|
} |
|
6062
|
|
|
6063
|
return { |
|
6064
|
syncCssClasses: syncCssClasses |
|
6065
|
}; |
|
6066
|
}); |
|
6067
|
|
|
6068
|
S2.define('select2/compat/containerCss',[ |
|
6069
|
'jquery', |
|
6070
|
'./utils' |
|
6071
|
], function ($, CompatUtils) { |
|
6072
|
// No-op CSS adapter that discards all classes by default |
|
6073
|
function _containerAdapter (clazz) { |
|
6074
|
return null; |
|
6075
|
} |
|
6076
|
|
|
6077
|
function ContainerCSS () { } |
|
6078
|
|
|
6079
|
ContainerCSS.prototype.render = function (decorated) { |
|
6080
|
var $container = decorated.call(this); |
|
6081
|
|
|
6082
|
var containerCssClass = this.options.get('containerCssClass') || ''; |
|
6083
|
|
|
6084
|
if ($.isFunction(containerCssClass)) { |
|
6085
|
containerCssClass = containerCssClass(this.$element); |
|
6086
|
} |
|
6087
|
|
|
6088
|
var containerCssAdapter = this.options.get('adaptContainerCssClass'); |
|
6089
|
containerCssAdapter = containerCssAdapter || _containerAdapter; |
|
6090
|
|
|
6091
|
if (containerCssClass.indexOf(':all:') !== -1) { |
|
6092
|
containerCssClass = containerCssClass.replace(':all:', ''); |
|
6093
|
|
|
6094
|
var _cssAdapter = containerCssAdapter; |
|
6095
|
|
|
6096
|
containerCssAdapter = function (clazz) { |
|
6097
|
var adapted = _cssAdapter(clazz); |
|
6098
|
|
|
6099
|
if (adapted != null) { |
|
6100
|
// Append the old one along with the adapted one |
|
6101
|
return adapted + ' ' + clazz; |
|
6102
|
} |
|
6103
|
|
|
6104
|
return clazz; |
|
6105
|
}; |
|
6106
|
} |
|
6107
|
|
|
6108
|
var containerCss = this.options.get('containerCss') || {}; |
|
6109
|
|
|
6110
|
if ($.isFunction(containerCss)) { |
|
6111
|
containerCss = containerCss(this.$element); |
|
6112
|
} |
|
6113
|
|
|
6114
|
CompatUtils.syncCssClasses($container, this.$element, containerCssAdapter); |
|
6115
|
|
|
6116
|
$container.css(containerCss); |
|
6117
|
$container.addClass(containerCssClass); |
|
6118
|
|
|
6119
|
return $container; |
|
6120
|
}; |
|
6121
|
|
|
6122
|
return ContainerCSS; |
|
6123
|
}); |
|
6124
|
|
|
6125
|
S2.define('select2/compat/dropdownCss',[ |
|
6126
|
'jquery', |
|
6127
|
'./utils' |
|
6128
|
], function ($, CompatUtils) { |
|
6129
|
// No-op CSS adapter that discards all classes by default |
|
6130
|
function _dropdownAdapter (clazz) { |
|
6131
|
return null; |
|
6132
|
} |
|
6133
|
|
|
6134
|
function DropdownCSS () { } |
|
6135
|
|
|
6136
|
DropdownCSS.prototype.render = function (decorated) { |
|
6137
|
var $dropdown = decorated.call(this); |
|
6138
|
|
|
6139
|
var dropdownCssClass = this.options.get('dropdownCssClass') || ''; |
|
6140
|
|
|
6141
|
if ($.isFunction(dropdownCssClass)) { |
|
6142
|
dropdownCssClass = dropdownCssClass(this.$element); |
|
6143
|
} |
|
6144
|
|
|
6145
|
var dropdownCssAdapter = this.options.get('adaptDropdownCssClass'); |
|
6146
|
dropdownCssAdapter = dropdownCssAdapter || _dropdownAdapter; |
|
6147
|
|
|
6148
|
if (dropdownCssClass.indexOf(':all:') !== -1) { |
|
6149
|
dropdownCssClass = dropdownCssClass.replace(':all:', ''); |
|
6150
|
|
|
6151
|
var _cssAdapter = dropdownCssAdapter; |
|
6152
|
|
|
6153
|
dropdownCssAdapter = function (clazz) { |
|
6154
|
var adapted = _cssAdapter(clazz); |
|
6155
|
|
|
6156
|
if (adapted != null) { |
|
6157
|
// Append the old one along with the adapted one |
|
6158
|
return adapted + ' ' + clazz; |
|
6159
|
} |
|
6160
|
|
|
6161
|
return clazz; |
|
6162
|
}; |
|
6163
|
} |
|
6164
|
|
|
6165
|
var dropdownCss = this.options.get('dropdownCss') || {}; |
|
6166
|
|
|
6167
|
if ($.isFunction(dropdownCss)) { |
|
6168
|
dropdownCss = dropdownCss(this.$element); |
|
6169
|
} |
|
6170
|
|
|
6171
|
CompatUtils.syncCssClasses($dropdown, this.$element, dropdownCssAdapter); |
|
6172
|
|
|
6173
|
$dropdown.css(dropdownCss); |
|
6174
|
$dropdown.addClass(dropdownCssClass); |
|
6175
|
|
|
6176
|
return $dropdown; |
|
6177
|
}; |
|
6178
|
|
|
6179
|
return DropdownCSS; |
|
6180
|
}); |
|
6181
|
|
|
6182
|
S2.define('select2/compat/initSelection',[ |
|
6183
|
'jquery' |
|
6184
|
], function ($) { |
|
6185
|
function InitSelection (decorated, $element, options) { |
|
6186
|
if (options.get('debug') && window.console && console.warn) { |
|
6187
|
console.warn( |
|
6188
|
'Select2: The `initSelection` option has been deprecated in favor' + |
|
6189
|
' of a custom data adapter that overrides the `current` method. ' + |
|
6190
|
'This method is now called multiple times instead of a single ' + |
|
6191
|
'time when the instance is initialized. Support will be removed ' + |
|
6192
|
'for the `initSelection` option in future versions of Select2' |
|
6193
|
); |
|
6194
|
} |
|
6195
|
|
|
6196
|
this.initSelection = options.get('initSelection'); |
|
6197
|
this._isInitialized = false; |
|
6198
|
|
|
6199
|
decorated.call(this, $element, options); |
|
6200
|
} |
|
6201
|
|
|
6202
|
InitSelection.prototype.current = function (decorated, callback) { |
|
6203
|
var self = this; |
|
6204
|
|
|
6205
|
if (this._isInitialized) { |
|
6206
|
decorated.call(this, callback); |
|
6207
|
|
|
6208
|
return; |
|
6209
|
} |
|
6210
|
|
|
6211
|
this.initSelection.call(null, this.$element, function (data) { |
|
6212
|
self._isInitialized = true; |
|
6213
|
|
|
6214
|
if (!$.isArray(data)) { |
|
6215
|
data = [data]; |
|
6216
|
} |
|
6217
|
|
|
6218
|
callback(data); |
|
6219
|
}); |
|
6220
|
}; |
|
6221
|
|
|
6222
|
return InitSelection; |
|
6223
|
}); |
|
6224
|
|
|
6225
|
S2.define('select2/compat/inputData',[ |
|
6226
|
'jquery', |
|
6227
|
'../utils' |
|
6228
|
], function ($, Utils) { |
|
6229
|
function InputData (decorated, $element, options) { |
|
6230
|
this._currentData = []; |
|
6231
|
this._valueSeparator = options.get('valueSeparator') || ','; |
|
6232
|
|
|
6233
|
if ($element.prop('type') === 'hidden') { |
|
6234
|
if (options.get('debug') && console && console.warn) { |
|
6235
|
console.warn( |
|
6236
|
'Select2: Using a hidden input with Select2 is no longer ' + |
|
6237
|
'supported and may stop working in the future. It is recommended ' + |
|
6238
|
'to use a `<select>` element instead.' |
|
6239
|
); |
|
6240
|
} |
|
6241
|
} |
|
6242
|
|
|
6243
|
decorated.call(this, $element, options); |
|
6244
|
} |
|
6245
|
|
|
6246
|
InputData.prototype.current = function (_, callback) { |
|
6247
|
function getSelected (data, selectedIds) { |
|
6248
|
var selected = []; |
|
6249
|
|
|
6250
|
if (data.selected || $.inArray(data.id, selectedIds) !== -1) { |
|
6251
|
data.selected = true; |
|
6252
|
selected.push(data); |
|
6253
|
} else { |
|
6254
|
data.selected = false; |
|
6255
|
} |
|
6256
|
|
|
6257
|
if (data.children) { |
|
6258
|
selected.push.apply(selected, getSelected(data.children, selectedIds)); |
|
6259
|
} |
|
6260
|
|
|
6261
|
return selected; |
|
6262
|
} |
|
6263
|
|
|
6264
|
var selected = []; |
|
6265
|
|
|
6266
|
for (var d = 0; d < this._currentData.length; d++) { |
|
6267
|
var data = this._currentData[d]; |
|
6268
|
|
|
6269
|
selected.push.apply( |
|
6270
|
selected, |
|
6271
|
getSelected( |
|
6272
|
data, |
|
6273
|
this.$element.val().split( |
|
6274
|
this._valueSeparator |
|
6275
|
) |
|
6276
|
) |
|
6277
|
); |
|
6278
|
} |
|
6279
|
|
|
6280
|
callback(selected); |
|
6281
|
}; |
|
6282
|
|
|
6283
|
InputData.prototype.select = function (_, data) { |
|
6284
|
if (!this.options.get('multiple')) { |
|
6285
|
this.current(function (allData) { |
|
6286
|
$.map(allData, function (data) { |
|
6287
|
data.selected = false; |
|
6288
|
}); |
|
6289
|
}); |
|
6290
|
|
|
6291
|
this.$element.val(data.id); |
|
6292
|
this.$element.trigger('input').trigger('change'); |
|
6293
|
} else { |
|
6294
|
var value = this.$element.val(); |
|
6295
|
value += this._valueSeparator + data.id; |
|
6296
|
|
|
6297
|
this.$element.val(value); |
|
6298
|
this.$element.trigger('input').trigger('change'); |
|
6299
|
} |
|
6300
|
}; |
|
6301
|
|
|
6302
|
InputData.prototype.unselect = function (_, data) { |
|
6303
|
var self = this; |
|
6304
|
|
|
6305
|
data.selected = false; |
|
6306
|
|
|
6307
|
this.current(function (allData) { |
|
6308
|
var values = []; |
|
6309
|
|
|
6310
|
for (var d = 0; d < allData.length; d++) { |
|
6311
|
var item = allData[d]; |
|
6312
|
|
|
6313
|
if (data.id == item.id) { |
|
6314
|
continue; |
|
6315
|
} |
|
6316
|
|
|
6317
|
values.push(item.id); |
|
6318
|
} |
|
6319
|
|
|
6320
|
self.$element.val(values.join(self._valueSeparator)); |
|
6321
|
self.$element.trigger('input').trigger('change'); |
|
6322
|
}); |
|
6323
|
}; |
|
6324
|
|
|
6325
|
InputData.prototype.query = function (_, params, callback) { |
|
6326
|
var results = []; |
|
6327
|
|
|
6328
|
for (var d = 0; d < this._currentData.length; d++) { |
|
6329
|
var data = this._currentData[d]; |
|
6330
|
|
|
6331
|
var matches = this.matches(params, data); |
|
6332
|
|
|
6333
|
if (matches !== null) { |
|
6334
|
results.push(matches); |
|
6335
|
} |
|
6336
|
} |
|
6337
|
|
|
6338
|
callback({ |
|
6339
|
results: results |
|
6340
|
}); |
|
6341
|
}; |
|
6342
|
|
|
6343
|
InputData.prototype.addOptions = function (_, $options) { |
|
6344
|
var options = $.map($options, function ($option) { |
|
6345
|
return Utils.GetData($option[0], 'data'); |
|
6346
|
}); |
|
6347
|
|
|
6348
|
this._currentData.push.apply(this._currentData, options); |
|
6349
|
}; |
|
6350
|
|
|
6351
|
return InputData; |
|
6352
|
}); |
|
6353
|
|
|
6354
|
S2.define('select2/compat/matcher',[ |
|
6355
|
'jquery' |
|
6356
|
], function ($) { |
|
6357
|
function oldMatcher (matcher) { |
|
6358
|
function wrappedMatcher (params, data) { |
|
6359
|
var match = $.extend(true, {}, data); |
|
6360
|
|
|
6361
|
if (params.term == null || $.trim(params.term) === '') { |
|
6362
|
return match; |
|
6363
|
} |
|
6364
|
|
|
6365
|
if (data.children) { |
|
6366
|
for (var c = data.children.length - 1; c >= 0; c--) { |
|
6367
|
var child = data.children[c]; |
|
6368
|
|
|
6369
|
// Check if the child object matches |
|
6370
|
// The old matcher returned a boolean true or false |
|
6371
|
var doesMatch = matcher(params.term, child.text, child); |
|
6372
|
|
|
6373
|
// If the child didn't match, pop it off |
|
6374
|
if (!doesMatch) { |
|
6375
|
match.children.splice(c, 1); |
|
6376
|
} |
|
6377
|
} |
|
6378
|
|
|
6379
|
if (match.children.length > 0) { |
|
6380
|
return match; |
|
6381
|
} |
|
6382
|
} |
|
6383
|
|
|
6384
|
if (matcher(params.term, data.text, data)) { |
|
6385
|
return match; |
|
6386
|
} |
|
6387
|
|
|
6388
|
return null; |
|
6389
|
} |
|
6390
|
|
|
6391
|
return wrappedMatcher; |
|
6392
|
} |
|
6393
|
|
|
6394
|
return oldMatcher; |
|
6395
|
}); |
|
6396
|
|
|
6397
|
S2.define('select2/compat/query',[ |
|
6398
|
|
|
6399
|
], function () { |
|
6400
|
function Query (decorated, $element, options) { |
|
6401
|
if (options.get('debug') && window.console && console.warn) { |
|
6402
|
console.warn( |
|
6403
|
'Select2: The `query` option has been deprecated in favor of a ' + |
|
6404
|
'custom data adapter that overrides the `query` method. Support ' + |
|
6405
|
'will be removed for the `query` option in future versions of ' + |
|
6406
|
'Select2.' |
|
6407
|
); |
|
6408
|
} |
|
6409
|
|
|
6410
|
decorated.call(this, $element, options); |
|
6411
|
} |
|
6412
|
|
|
6413
|
Query.prototype.query = function (_, params, callback) { |
|
6414
|
params.callback = callback; |
|
6415
|
|
|
6416
|
var query = this.options.get('query'); |
|
6417
|
|
|
6418
|
query.call(null, params); |
|
6419
|
}; |
|
6420
|
|
|
6421
|
return Query; |
|
6422
|
}); |
|
6423
|
|
|
6424
|
S2.define('select2/dropdown/attachContainer',[ |
|
6425
|
|
|
6426
|
], function () { |
|
6427
|
function AttachContainer (decorated, $element, options) { |
|
6428
|
decorated.call(this, $element, options); |
|
6429
|
} |
|
6430
|
|
|
6431
|
AttachContainer.prototype.position = |
|
6432
|
function (decorated, $dropdown, $container) { |
|
6433
|
var $dropdownContainer = $container.find('.dropdown-wrapper'); |
|
6434
|
$dropdownContainer.append($dropdown); |
|
6435
|
|
|
6436
|
$dropdown.addClass('select2-dropdown--below'); |
|
6437
|
$container.addClass('select2-container--below'); |
|
6438
|
}; |
|
6439
|
|
|
6440
|
return AttachContainer; |
|
6441
|
}); |
|
6442
|
|
|
6443
|
S2.define('select2/dropdown/stopPropagation',[ |
|
6444
|
|
|
6445
|
], function () { |
|
6446
|
function StopPropagation () { } |
|
6447
|
|
|
6448
|
StopPropagation.prototype.bind = function (decorated, container, $container) { |
|
6449
|
decorated.call(this, container, $container); |
|
6450
|
|
|
6451
|
var stoppedEvents = [ |
|
6452
|
'blur', |
|
6453
|
'change', |
|
6454
|
'click', |
|
6455
|
'dblclick', |
|
6456
|
'focus', |
|
6457
|
'focusin', |
|
6458
|
'focusout', |
|
6459
|
'input', |
|
6460
|
'keydown', |
|
6461
|
'keyup', |
|
6462
|
'keypress', |
|
6463
|
'mousedown', |
|
6464
|
'mouseenter', |
|
6465
|
'mouseleave', |
|
6466
|
'mousemove', |
|
6467
|
'mouseover', |
|
6468
|
'mouseup', |
|
6469
|
'search', |
|
6470
|
'touchend', |
|
6471
|
'touchstart' |
|
6472
|
]; |
|
6473
|
|
|
6474
|
this.$dropdown.on(stoppedEvents.join(' '), function (evt) { |
|
6475
|
evt.stopPropagation(); |
|
6476
|
}); |
|
6477
|
}; |
|
6478
|
|
|
6479
|
return StopPropagation; |
|
6480
|
}); |
|
6481
|
|
|
6482
|
S2.define('select2/selection/stopPropagation',[ |
|
6483
|
|
|
6484
|
], function () { |
|
6485
|
function StopPropagation () { } |
|
6486
|
|
|
6487
|
StopPropagation.prototype.bind = function (decorated, container, $container) { |
|
6488
|
decorated.call(this, container, $container); |
|
6489
|
|
|
6490
|
var stoppedEvents = [ |
|
6491
|
'blur', |
|
6492
|
'change', |
|
6493
|
'click', |
|
6494
|
'dblclick', |
|
6495
|
'focus', |
|
6496
|
'focusin', |
|
6497
|
'focusout', |
|
6498
|
'input', |
|
6499
|
'keydown', |
|
6500
|
'keyup', |
|
6501
|
'keypress', |
|
6502
|
'mousedown', |
|
6503
|
'mouseenter', |
|
6504
|
'mouseleave', |
|
6505
|
'mousemove', |
|
6506
|
'mouseover', |
|
6507
|
'mouseup', |
|
6508
|
'search', |
|
6509
|
'touchend', |
|
6510
|
'touchstart' |
|
6511
|
]; |
|
6512
|
|
|
6513
|
this.$selection.on(stoppedEvents.join(' '), function (evt) { |
|
6514
|
evt.stopPropagation(); |
|
6515
|
}); |
|
6516
|
}; |
|
6517
|
|
|
6518
|
return StopPropagation; |
|
6519
|
}); |
|
6520
|
|
|
6521
|
/*! |
|
6522
|
* jQuery Mousewheel 3.1.13 |
|
6523
|
* |
|
6524
|
* Copyright jQuery Foundation and other contributors |
|
6525
|
* Released under the MIT license |
|
6526
|
* http://jquery.org/license |
|
6527
|
*/ |
|
6528
|
|
|
6529
|
(function (factory) { |
|
6530
|
if ( typeof S2.define === 'function' && S2.define.amd ) { |
|
6531
|
// AMD. Register as an anonymous module. |
|
6532
|
S2.define('jquery-mousewheel',['jquery'], factory); |
|
6533
|
} else if (typeof exports === 'object') { |
|
6534
|
// Node/CommonJS style for Browserify |
|
6535
|
module.exports = factory; |
|
6536
|
} else { |
|
6537
|
// Browser globals |
|
6538
|
factory(jQuery); |
|
6539
|
} |
|
6540
|
}(function ($) { |
|
6541
|
|
|
6542
|
var toFix = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'], |
|
6543
|
toBind = ( 'onwheel' in document || document.documentMode >= 9 ) ? |
|
6544
|
['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'], |
|
6545
|
slice = Array.prototype.slice, |
|
6546
|
nullLowestDeltaTimeout, lowestDelta; |
|
6547
|
|
|
6548
|
if ( $.event.fixHooks ) { |
|
6549
|
for ( var i = toFix.length; i; ) { |
|
6550
|
$.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks; |
|
6551
|
} |
|
6552
|
} |
|
6553
|
|
|
6554
|
var special = $.event.special.mousewheel = { |
|
6555
|
version: '3.1.12', |
|
6556
|
|
|
6557
|
setup: function() { |
|
6558
|
if ( this.addEventListener ) { |
|
6559
|
for ( var i = toBind.length; i; ) { |
|
6560
|
this.addEventListener( toBind[--i], handler, false ); |
|
6561
|
} |
|
6562
|
} else { |
|
6563
|
this.onmousewheel = handler; |
|
6564
|
} |
|
6565
|
// Store the line height and page height for this particular element |
|
6566
|
$.data(this, 'mousewheel-line-height', special.getLineHeight(this)); |
|
6567
|
$.data(this, 'mousewheel-page-height', special.getPageHeight(this)); |
|
6568
|
}, |
|
6569
|
|
|
6570
|
teardown: function() { |
|
6571
|
if ( this.removeEventListener ) { |
|
6572
|
for ( var i = toBind.length; i; ) { |
|
6573
|
this.removeEventListener( toBind[--i], handler, false ); |
|
6574
|
} |
|
6575
|
} else { |
|
6576
|
this.onmousewheel = null; |
|
6577
|
} |
|
6578
|
// Clean up the data we added to the element |
|
6579
|
$.removeData(this, 'mousewheel-line-height'); |
|
6580
|
$.removeData(this, 'mousewheel-page-height'); |
|
6581
|
}, |
|
6582
|
|
|
6583
|
getLineHeight: function(elem) { |
|
6584
|
var $elem = $(elem), |
|
6585
|
$parent = $elem['offsetParent' in $.fn ? 'offsetParent' : 'parent'](); |
|
6586
|
if (!$parent.length) { |
|
6587
|
$parent = $('body'); |
|
6588
|
} |
|
6589
|
return parseInt($parent.css('fontSize'), 10) || parseInt($elem.css('fontSize'), 10) || 16; |
|
6590
|
}, |
|
6591
|
|
|
6592
|
getPageHeight: function(elem) { |
|
6593
|
return $(elem).height(); |
|
6594
|
}, |
|
6595
|
|
|
6596
|
settings: { |
|
6597
|
adjustOldDeltas: true, // see shouldAdjustOldDeltas() below |
|
6598
|
normalizeOffset: true // calls getBoundingClientRect for each event |
|
6599
|
} |
|
6600
|
}; |
|
6601
|
|
|
6602
|
$.fn.extend({ |
|
6603
|
mousewheel: function(fn) { |
|
6604
|
return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel'); |
|
6605
|
}, |
|
6606
|
|
|
6607
|
unmousewheel: function(fn) { |
|
6608
|
return this.unbind('mousewheel', fn); |
|
6609
|
} |
|
6610
|
}); |
|
6611
|
|
|
6612
|
|
|
6613
|
function handler(event) { |
|
6614
|
var orgEvent = event || window.event, |
|
6615
|
args = slice.call(arguments, 1), |
|
6616
|
delta = 0, |
|
6617
|
deltaX = 0, |
|
6618
|
deltaY = 0, |
|
6619
|
absDelta = 0, |
|
6620
|
offsetX = 0, |
|
6621
|
offsetY = 0; |
|
6622
|
event = $.event.fix(orgEvent); |
|
6623
|
event.type = 'mousewheel'; |
|
6624
|
|
|
6625
|
// Old school scrollwheel delta |
|
6626
|
if ( 'detail' in orgEvent ) { deltaY = orgEvent.detail * -1; } |
|
6627
|
if ( 'wheelDelta' in orgEvent ) { deltaY = orgEvent.wheelDelta; } |
|
6628
|
if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY; } |
|
6629
|
if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; } |
|
6630
|
|
|
6631
|
// Firefox < 17 horizontal scrolling related to DOMMouseScroll event |
|
6632
|
if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) { |
|
6633
|
deltaX = deltaY * -1; |
|
6634
|
deltaY = 0; |
|
6635
|
} |
|
6636
|
|
|
6637
|
// Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy |
|
6638
|
delta = deltaY === 0 ? deltaX : deltaY; |
|
6639
|
|
|
6640
|
// New school wheel delta (wheel event) |
|
6641
|
if ( 'deltaY' in orgEvent ) { |
|
6642
|
deltaY = orgEvent.deltaY * -1; |
|
6643
|
delta = deltaY; |
|
6644
|
} |
|
6645
|
if ( 'deltaX' in orgEvent ) { |
|
6646
|
deltaX = orgEvent.deltaX; |
|
6647
|
if ( deltaY === 0 ) { delta = deltaX * -1; } |
|
6648
|
} |
|
6649
|
|
|
6650
|
// No change actually happened, no reason to go any further |
|
6651
|
if ( deltaY === 0 && deltaX === 0 ) { return; } |
|
6652
|
|
|
6653
|
// Need to convert lines and pages to pixels if we aren't already in pixels |
|
6654
|
// There are three delta modes: |
|
6655
|
// * deltaMode 0 is by pixels, nothing to do |
|
6656
|
// * deltaMode 1 is by lines |
|
6657
|
// * deltaMode 2 is by pages |
|
6658
|
if ( orgEvent.deltaMode === 1 ) { |
|
6659
|
var lineHeight = $.data(this, 'mousewheel-line-height'); |
|
6660
|
delta *= lineHeight; |
|
6661
|
deltaY *= lineHeight; |
|
6662
|
deltaX *= lineHeight; |
|
6663
|
} else if ( orgEvent.deltaMode === 2 ) { |
|
6664
|
var pageHeight = $.data(this, 'mousewheel-page-height'); |
|
6665
|
delta *= pageHeight; |
|
6666
|
deltaY *= pageHeight; |
|
6667
|
deltaX *= pageHeight; |
|
6668
|
} |
|
6669
|
|
|
6670
|
// Store lowest absolute delta to normalize the delta values |
|
6671
|
absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) ); |
|
6672
|
|
|
6673
|
if ( !lowestDelta || absDelta < lowestDelta ) { |
|
6674
|
lowestDelta = absDelta; |
|
6675
|
|
|
6676
|
// Adjust older deltas if necessary |
|
6677
|
if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) { |
|
6678
|
lowestDelta /= 40; |
|
6679
|
} |
|
6680
|
} |
|
6681
|
|
|
6682
|
// Adjust older deltas if necessary |
|
6683
|
if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) { |
|
6684
|
// Divide all the things by 40! |
|
6685
|
delta /= 40; |
|
6686
|
deltaX /= 40; |
|
6687
|
deltaY /= 40; |
|
6688
|
} |
|
6689
|
|
|
6690
|
// Get a whole, normalized value for the deltas |
|
6691
|
delta = Math[ delta >= 1 ? 'floor' : 'ceil' ](delta / lowestDelta); |
|
6692
|
deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta); |
|
6693
|
deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta); |
|
6694
|
|
|
6695
|
// Normalise offsetX and offsetY properties |
|
6696
|
if ( special.settings.normalizeOffset && this.getBoundingClientRect ) { |
|
6697
|
var boundingRect = this.getBoundingClientRect(); |
|
6698
|
offsetX = event.clientX - boundingRect.left; |
|
6699
|
offsetY = event.clientY - boundingRect.top; |
|
6700
|
} |
|
6701
|
|
|
6702
|
// Add information to the event object |
|
6703
|
event.deltaX = deltaX; |
|
6704
|
event.deltaY = deltaY; |
|
6705
|
event.deltaFactor = lowestDelta; |
|
6706
|
event.offsetX = offsetX; |
|
6707
|
event.offsetY = offsetY; |
|
6708
|
// Go ahead and set deltaMode to 0 since we converted to pixels |
|
6709
|
// Although this is a little odd since we overwrite the deltaX/Y |
|
6710
|
// properties with normalized deltas. |
|
6711
|
event.deltaMode = 0; |
|
6712
|
|
|
6713
|
// Add event and delta to the front of the arguments |
|
6714
|
args.unshift(event, delta, deltaX, deltaY); |
|
6715
|
|
|
6716
|
// Clearout lowestDelta after sometime to better |
|
6717
|
// handle multiple device types that give different |
|
6718
|
// a different lowestDelta |
|
6719
|
// Ex: trackpad = 3 and mouse wheel = 120 |
|
6720
|
if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); } |
|
6721
|
nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200); |
|
6722
|
|
|
6723
|
return ($.event.dispatch || $.event.handle).apply(this, args); |
|
6724
|
} |
|
6725
|
|
|
6726
|
function nullLowestDelta() { |
|
6727
|
lowestDelta = null; |
|
6728
|
} |
|
6729
|
|
|
6730
|
function shouldAdjustOldDeltas(orgEvent, absDelta) { |
|
6731
|
// If this is an older event and the delta is divisable by 120, |
|
6732
|
// then we are assuming that the browser is treating this as an |
|
6733
|
// older mouse wheel event and that we should divide the deltas |
|
6734
|
// by 40 to try and get a more usable deltaFactor. |
|
6735
|
// Side note, this actually impacts the reported scroll distance |
|
6736
|
// in older browsers and can cause scrolling to be slower than native. |
|
6737
|
// Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false. |
|
6738
|
return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0; |
|
6739
|
} |
|
6740
|
|
|
6741
|
})); |
|
6742
|
|
|
6743
|
S2.define('jquery.select2',[ |
|
6744
|
'jquery', |
|
6745
|
'jquery-mousewheel', |
|
6746
|
|
|
6747
|
'./select2/core', |
|
6748
|
'./select2/defaults', |
|
6749
|
'./select2/utils' |
|
6750
|
], function ($, _, Select2, Defaults, Utils) { |
|
6751
|
if ($.fn.select2 == null) { |
|
6752
|
// All methods that should return the element |
|
6753
|
var thisMethods = ['open', 'close', 'destroy']; |
|
6754
|
|
|
6755
|
$.fn.select2 = function (options) { |
|
6756
|
options = options || {}; |
|
6757
|
|
|
6758
|
if (typeof options === 'object') { |
|
6759
|
this.each(function () { |
|
6760
|
var instanceOptions = $.extend(true, {}, options); |
|
6761
|
|
|
6762
|
var instance = new Select2($(this), instanceOptions); |
|
6763
|
}); |
|
6764
|
|
|
6765
|
return this; |
|
6766
|
} else if (typeof options === 'string') { |
|
6767
|
var ret; |
|
6768
|
var args = Array.prototype.slice.call(arguments, 1); |
|
6769
|
|
|
6770
|
this.each(function () { |
|
6771
|
var instance = Utils.GetData(this, 'select2'); |
|
6772
|
|
|
6773
|
if (instance == null && window.console && console.error) { |
|
6774
|
console.error( |
|
6775
|
'The select2(\'' + options + '\') method was called on an ' + |
|
6776
|
'element that is not using Select2.' |
|
6777
|
); |
|
6778
|
} |
|
6779
|
|
|
6780
|
ret = instance[options].apply(instance, args); |
|
6781
|
}); |
|
6782
|
|
|
6783
|
// Check if we should be returning `this` |
|
6784
|
if ($.inArray(options, thisMethods) > -1) { |
|
6785
|
return this; |
|
6786
|
} |
|
6787
|
|
|
6788
|
return ret; |
|
6789
|
} else { |
|
6790
|
throw new Error('Invalid arguments for Select2: ' + options); |
|
6791
|
} |
|
6792
|
}; |
|
6793
|
} |
|
6794
|
|
|
6795
|
if ($.fn.select2.defaults == null) { |
|
6796
|
$.fn.select2.defaults = Defaults; |
|
6797
|
} |
|
6798
|
|
|
6799
|
return Select2; |
|
6800
|
}); |
|
6801
|
|
|
6802
|
// Return the AMD loader configuration so it can be used outside of this file |
|
6803
|
return { |
|
6804
|
define: S2.define, |
|
6805
|
require: S2.require |
|
6806
|
}; |
|
6807
|
}()); |
|
6808
|
|
|
6809
|
// Autoload the jQuery bindings |
|
6810
|
// We know that all of the modules exist above this, so we're safe |
|
6811
|
var select2 = S2.require('jquery.select2'); |
|
6812
|
|
|
6813
|
// Hold the AMD module references on the jQuery function that was just loaded |
|
6814
|
// This allows Select2 to use the internal loader outside of this file, such |
|
6815
|
// as in the language files. |
|
6816
|
jQuery.fn.select2.amd = S2; |
|
6817
|
|
|
6818
|
// Return the Select2 instance for anyone who is importing it. |
|
6819
|
return select2; |
|
6820
|
})); |
|
6821
|
|