select2.js 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747
  1. /**
  2. * @license almond 0.2.9 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
  3. * Available via the MIT or new BSD license.
  4. * see: http://github.com/jrburke/almond for details
  5. */
  6. //Going sloppy to avoid 'use strict' string cost, but strict practices should
  7. //be followed.
  8. /*jslint sloppy: true */
  9. /*global setTimeout: false */
  10. var requirejs, require, define;
  11. (function (undef) {
  12. var main, req, makeMap, handlers,
  13. defined = {},
  14. waiting = {},
  15. config = {},
  16. defining = {},
  17. hasOwn = Object.prototype.hasOwnProperty,
  18. aps = [].slice,
  19. jsSuffixRegExp = /\.js$/;
  20. function hasProp(obj, prop) {
  21. return hasOwn.call(obj, prop);
  22. }
  23. /**
  24. * Given a relative module name, like ./something, normalize it to
  25. * a real name that can be mapped to a path.
  26. * @param {String} name the relative name
  27. * @param {String} baseName a real name that the name arg is relative
  28. * to.
  29. * @returns {String} normalized name
  30. */
  31. function normalize(name, baseName) {
  32. var nameParts, nameSegment, mapValue, foundMap, lastIndex,
  33. foundI, foundStarMap, starI, i, j, part,
  34. baseParts = baseName && baseName.split("/"),
  35. map = config.map,
  36. starMap = (map && map['*']) || {};
  37. //Adjust any relative paths.
  38. if (name && name.charAt(0) === ".") {
  39. //If have a base name, try to normalize against it,
  40. //otherwise, assume it is a top-level require that will
  41. //be relative to baseUrl in the end.
  42. if (baseName) {
  43. //Convert baseName to array, and lop off the last part,
  44. //so that . matches that "directory" and not name of the baseName's
  45. //module. For instance, baseName of "one/two/three", maps to
  46. //"one/two/three.js", but we want the directory, "one/two" for
  47. //this normalization.
  48. baseParts = baseParts.slice(0, baseParts.length - 1);
  49. name = name.split('/');
  50. lastIndex = name.length - 1;
  51. // Node .js allowance:
  52. if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
  53. name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
  54. }
  55. name = baseParts.concat(name);
  56. //start trimDots
  57. for (i = 0; i < name.length; i += 1) {
  58. part = name[i];
  59. if (part === ".") {
  60. name.splice(i, 1);
  61. i -= 1;
  62. } else if (part === "..") {
  63. if (i === 1 && (name[2] === '..' || name[0] === '..')) {
  64. //End of the line. Keep at least one non-dot
  65. //path segment at the front so it can be mapped
  66. //correctly to disk. Otherwise, there is likely
  67. //no path mapping for a path starting with '..'.
  68. //This can still fail, but catches the most reasonable
  69. //uses of ..
  70. break;
  71. } else if (i > 0) {
  72. name.splice(i - 1, 2);
  73. i -= 2;
  74. }
  75. }
  76. }
  77. //end trimDots
  78. name = name.join("/");
  79. } else if (name.indexOf('./') === 0) {
  80. // No baseName, so this is ID is resolved relative
  81. // to baseUrl, pull off the leading dot.
  82. name = name.substring(2);
  83. }
  84. }
  85. //Apply map config if available.
  86. if ((baseParts || starMap) && map) {
  87. nameParts = name.split('/');
  88. for (i = nameParts.length; i > 0; i -= 1) {
  89. nameSegment = nameParts.slice(0, i).join("/");
  90. if (baseParts) {
  91. //Find the longest baseName segment match in the config.
  92. //So, do joins on the biggest to smallest lengths of baseParts.
  93. for (j = baseParts.length; j > 0; j -= 1) {
  94. mapValue = map[baseParts.slice(0, j).join('/')];
  95. //baseName segment has config, find if it has one for
  96. //this name.
  97. if (mapValue) {
  98. mapValue = mapValue[nameSegment];
  99. if (mapValue) {
  100. //Match, update name to the new value.
  101. foundMap = mapValue;
  102. foundI = i;
  103. break;
  104. }
  105. }
  106. }
  107. }
  108. if (foundMap) {
  109. break;
  110. }
  111. //Check for a star map match, but just hold on to it,
  112. //if there is a shorter segment match later in a matching
  113. //config, then favor over this star map.
  114. if (!foundStarMap && starMap && starMap[nameSegment]) {
  115. foundStarMap = starMap[nameSegment];
  116. starI = i;
  117. }
  118. }
  119. if (!foundMap && foundStarMap) {
  120. foundMap = foundStarMap;
  121. foundI = starI;
  122. }
  123. if (foundMap) {
  124. nameParts.splice(0, foundI, foundMap);
  125. name = nameParts.join('/');
  126. }
  127. }
  128. return name;
  129. }
  130. function makeRequire(relName, forceSync) {
  131. return function () {
  132. //A version of a require function that passes a moduleName
  133. //value for items that may need to
  134. //look up paths relative to the moduleName
  135. return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
  136. };
  137. }
  138. function makeNormalize(relName) {
  139. return function (name) {
  140. return normalize(name, relName);
  141. };
  142. }
  143. function makeLoad(depName) {
  144. return function (value) {
  145. defined[depName] = value;
  146. };
  147. }
  148. function callDep(name) {
  149. if (hasProp(waiting, name)) {
  150. var args = waiting[name];
  151. delete waiting[name];
  152. defining[name] = true;
  153. main.apply(undef, args);
  154. }
  155. if (!hasProp(defined, name) && !hasProp(defining, name)) {
  156. throw new Error('No ' + name);
  157. }
  158. return defined[name];
  159. }
  160. //Turns a plugin!resource to [plugin, resource]
  161. //with the plugin being undefined if the name
  162. //did not have a plugin prefix.
  163. function splitPrefix(name) {
  164. var prefix,
  165. index = name ? name.indexOf('!') : -1;
  166. if (index > -1) {
  167. prefix = name.substring(0, index);
  168. name = name.substring(index + 1, name.length);
  169. }
  170. return [prefix, name];
  171. }
  172. /**
  173. * Makes a name map, normalizing the name, and using a plugin
  174. * for normalization if necessary. Grabs a ref to plugin
  175. * too, as an optimization.
  176. */
  177. makeMap = function (name, relName) {
  178. var plugin,
  179. parts = splitPrefix(name),
  180. prefix = parts[0];
  181. name = parts[1];
  182. if (prefix) {
  183. prefix = normalize(prefix, relName);
  184. plugin = callDep(prefix);
  185. }
  186. //Normalize according
  187. if (prefix) {
  188. if (plugin && plugin.normalize) {
  189. name = plugin.normalize(name, makeNormalize(relName));
  190. } else {
  191. name = normalize(name, relName);
  192. }
  193. } else {
  194. name = normalize(name, relName);
  195. parts = splitPrefix(name);
  196. prefix = parts[0];
  197. name = parts[1];
  198. if (prefix) {
  199. plugin = callDep(prefix);
  200. }
  201. }
  202. //Using ridiculous property names for space reasons
  203. return {
  204. f: prefix ? prefix + '!' + name : name, //fullName
  205. n: name,
  206. pr: prefix,
  207. p: plugin
  208. };
  209. };
  210. function makeConfig(name) {
  211. return function () {
  212. return (config && config.config && config.config[name]) || {};
  213. };
  214. }
  215. handlers = {
  216. require: function (name) {
  217. return makeRequire(name);
  218. },
  219. exports: function (name) {
  220. var e = defined[name];
  221. if (typeof e !== 'undefined') {
  222. return e;
  223. } else {
  224. return (defined[name] = {});
  225. }
  226. },
  227. module: function (name) {
  228. return {
  229. id: name,
  230. uri: '',
  231. exports: defined[name],
  232. config: makeConfig(name)
  233. };
  234. }
  235. };
  236. main = function (name, deps, callback, relName) {
  237. var cjsModule, depName, ret, map, i,
  238. args = [],
  239. callbackType = typeof callback,
  240. usingExports;
  241. //Use name if no relName
  242. relName = relName || name;
  243. //Call the callback to define the module, if necessary.
  244. if (callbackType === 'undefined' || callbackType === 'function') {
  245. //Pull out the defined dependencies and pass the ordered
  246. //values to the callback.
  247. //Default to [require, exports, module] if no deps
  248. deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
  249. for (i = 0; i < deps.length; i += 1) {
  250. map = makeMap(deps[i], relName);
  251. depName = map.f;
  252. //Fast path CommonJS standard dependencies.
  253. if (depName === "require") {
  254. args[i] = handlers.require(name);
  255. } else if (depName === "exports") {
  256. //CommonJS module spec 1.1
  257. args[i] = handlers.exports(name);
  258. usingExports = true;
  259. } else if (depName === "module") {
  260. //CommonJS module spec 1.1
  261. cjsModule = args[i] = handlers.module(name);
  262. } else if (hasProp(defined, depName) ||
  263. hasProp(waiting, depName) ||
  264. hasProp(defining, depName)) {
  265. args[i] = callDep(depName);
  266. } else if (map.p) {
  267. map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
  268. args[i] = defined[depName];
  269. } else {
  270. throw new Error(name + ' missing ' + depName);
  271. }
  272. }
  273. ret = callback ? callback.apply(defined[name], args) : undefined;
  274. if (name) {
  275. //If setting exports via "module" is in play,
  276. //favor that over return value and exports. After that,
  277. //favor a non-undefined return value over exports use.
  278. if (cjsModule && cjsModule.exports !== undef &&
  279. cjsModule.exports !== defined[name]) {
  280. defined[name] = cjsModule.exports;
  281. } else if (ret !== undef || !usingExports) {
  282. //Use the return value from the function.
  283. defined[name] = ret;
  284. }
  285. }
  286. } else if (name) {
  287. //May just be an object definition for the module. Only
  288. //worry about defining if have a module name.
  289. defined[name] = callback;
  290. }
  291. };
  292. requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
  293. if (typeof deps === "string") {
  294. if (handlers[deps]) {
  295. //callback in this case is really relName
  296. return handlers[deps](callback);
  297. }
  298. //Just return the module wanted. In this scenario, the
  299. //deps arg is the module name, and second arg (if passed)
  300. //is just the relName.
  301. //Normalize module name, if it contains . or ..
  302. return callDep(makeMap(deps, callback).f);
  303. } else if (!deps.splice) {
  304. //deps is a config object, not an array.
  305. config = deps;
  306. if (config.deps) {
  307. req(config.deps, config.callback);
  308. }
  309. if (!callback) {
  310. return;
  311. }
  312. if (callback.splice) {
  313. //callback is an array, which means it is a dependency list.
  314. //Adjust args if there are dependencies
  315. deps = callback;
  316. callback = relName;
  317. relName = null;
  318. } else {
  319. deps = undef;
  320. }
  321. }
  322. //Support require(['a'])
  323. callback = callback || function () {};
  324. //If relName is a function, it is an errback handler,
  325. //so remove it.
  326. if (typeof relName === 'function') {
  327. relName = forceSync;
  328. forceSync = alt;
  329. }
  330. //Simulate async callback;
  331. if (forceSync) {
  332. main(undef, deps, callback, relName);
  333. } else {
  334. //Using a non-zero value because of concern for what old browsers
  335. //do, and latest browsers "upgrade" to 4 if lower value is used:
  336. //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
  337. //If want a value immediately, use require('id') instead -- something
  338. //that works in almond on the global level, but not guaranteed and
  339. //unlikely to work in other AMD implementations.
  340. setTimeout(function () {
  341. main(undef, deps, callback, relName);
  342. }, 4);
  343. }
  344. return req;
  345. };
  346. /**
  347. * Just drops the config on the floor, but returns req in case
  348. * the config return value is used.
  349. */
  350. req.config = function (cfg) {
  351. return req(cfg);
  352. };
  353. /**
  354. * Expose module registry for debugging and tooling
  355. */
  356. requirejs._defined = defined;
  357. define = function (name, deps, callback) {
  358. //This module may not have dependencies
  359. if (!deps.splice) {
  360. //deps is not an array, so probably means
  361. //an object literal or factory function for
  362. //the value. Adjust args.
  363. callback = deps;
  364. deps = [];
  365. }
  366. if (!hasProp(defined, name) && !hasProp(waiting, name)) {
  367. waiting[name] = [name, deps, callback];
  368. }
  369. };
  370. define.amd = {
  371. jQuery: true
  372. };
  373. }());
  374. define("almond", function(){});
  375. define('jquery',[],function () {
  376. return jQuery;
  377. })
  378. ;
  379. define('select2/utils',[], function () {
  380. var Utils = {};
  381. Utils.Extend = function (ChildClass, SuperClass) {
  382. var __hasProp = {}.hasOwnProperty
  383. function BaseConstructor () {
  384. this.constructor = ChildClass;
  385. }
  386. for (var key in SuperClass) {
  387. if (__hasProp.call(SuperClass, key)) {
  388. ChildClass[key] = SuperClass[key];
  389. }
  390. }
  391. BaseConstructor.prototype = SuperClass.prototype;
  392. ChildClass.prototype = new BaseConstructor();
  393. ChildClass.__super__ = SuperClass.prototype;
  394. return ChildClass;
  395. };
  396. var Observable = function () {
  397. this.listeners = {};
  398. };
  399. Observable.prototype.on = function (event, callback) {
  400. if (event in this.listeners) {
  401. this.listeners[event].push(callback);
  402. } else {
  403. this.listeners[event] = [callback];
  404. }
  405. };
  406. Observable.prototype.trigger = function (event) {
  407. var slice = Array.prototype.slice;
  408. if (event in this.listeners) {
  409. this.invoke(this.listeners[event], slice.call(arguments, 1));
  410. }
  411. if ("*" in this.listeners) {
  412. this.invoke(this.listeners["*"], arguments);
  413. }
  414. };
  415. Observable.prototype.invoke = function (listeners, params) {
  416. for (var i = 0, len = listeners.length; i < len; i++) {
  417. listeners[i].apply(this, params);
  418. }
  419. };
  420. Utils.Observable = Observable;
  421. return Utils;
  422. });
  423. define('select2/data/select',[
  424. '../utils'
  425. ], function (Utils) {
  426. function SelectAdapter ($element, options) {
  427. this.$element = $element;
  428. }
  429. Utils.Extend(SelectAdapter, Utils.Observable);
  430. SelectAdapter.prototype.current = function (callback) {
  431. var data = [];
  432. var self = this;
  433. this.$element.find(":selected").each(function () {
  434. var $option = $(this);
  435. var option = self.item($option);
  436. data.push(option);
  437. });
  438. callback(data);
  439. };
  440. SelectAdapter.prototype.query = function (params, callback) {
  441. var data = [];
  442. var self = this;
  443. this.$element.find("option").each(function () {
  444. var $option = $(this);
  445. var option = self.item($option);
  446. if (self.matches(params, option)) {
  447. data.push(option);
  448. }
  449. });
  450. callback(data);
  451. };
  452. SelectAdapter.prototype.item = function ($option) {
  453. var data = {
  454. id: $option.val(),
  455. text: $option.html()
  456. };
  457. return data;
  458. };
  459. SelectAdapter.prototype.matches = function (params, data) {
  460. if (data.text.indexOf(params.term) > -1) {
  461. return true;
  462. }
  463. return false;
  464. }
  465. return SelectAdapter;
  466. });
  467. define('select2/results',[
  468. './utils'
  469. ], function (Utils) {
  470. function Results ($element, dataAdapter) {
  471. this.$element = $element;
  472. this.dataAdapter = dataAdapter;
  473. }
  474. Utils.Extend(Results, Utils.Observable);
  475. Results.prototype.render = function () {
  476. var $results = $(
  477. '<ul class="options"></ul>'
  478. );
  479. return $results;
  480. }
  481. return Results;
  482. })
  483. ;
  484. define('select2/dropdown',[
  485. './utils'
  486. ], function (Utils) {
  487. function Dropdown ($element, options) {
  488. this.$element = $element;
  489. }
  490. Utils.Extend(Dropdown, Utils.Observable);
  491. Dropdown.prototype.render = function () {
  492. var $dropdown = $(
  493. '<span class="">' +
  494. '<span class="results"></span>' +
  495. '</span>'
  496. );
  497. return $dropdown;
  498. }
  499. return Dropdown;
  500. })
  501. ;
  502. define('select2/selection',[
  503. './utils'
  504. ], function (Utils) {
  505. function Selection ($element, options) {
  506. this.$element = $element;
  507. this.options = options;
  508. Selection.__super__.constructor.call(this);
  509. }
  510. Utils.Extend(Selection, Utils.Observable);
  511. Selection.prototype.render = function () {
  512. var $selection = $(
  513. '<span class="single-select">' +
  514. '<span class="rendered-selection"></span>' +
  515. '</span>'
  516. );
  517. this.$selection = $selection;
  518. return $selection;
  519. }
  520. Selection.prototype.bind = function ($container) {
  521. var self = this;
  522. this.$selection.on('click', function (evt) {
  523. self.trigger("toggle", {
  524. originalEvent: evt
  525. });
  526. });
  527. }
  528. Selection.prototype.clear = function () {
  529. this.$selection.find(".rendered-selection").text("");
  530. }
  531. Selection.prototype.display = function (data) {
  532. return data.text;
  533. }
  534. Selection.prototype.update = function (data) {
  535. if (data.length == 0) {
  536. this.clear();
  537. return;
  538. }
  539. var selection = data[0];
  540. var formatted = this.display(selection);
  541. this.$selection.find(".rendered-selection").html(formatted);
  542. }
  543. return Selection;
  544. });
  545. define('select2/options',[
  546. './data/select',
  547. './results',
  548. './dropdown',
  549. './selection'
  550. ], function (SelectData, ResultsList, Dropdown, Selection) {
  551. function Options (options) {
  552. this.options = options;
  553. this.dataAdapter = SelectData;
  554. this.resultsAdapter = ResultsList;
  555. this.dropdownAdapter = Dropdown;
  556. this.selectionAdapter = Selection;
  557. }
  558. return Options;
  559. })
  560. ;
  561. define('select2/core',[
  562. 'jquery',
  563. './options',
  564. './utils'
  565. ], function ($, Options, Utils) {
  566. var Select2 = function ($element, options) {
  567. this.$element = $element;
  568. this.options = new Options(options);
  569. Select2.__super__.constructor.call(this);
  570. // Set up containers and adapters
  571. this.data = new this.options.dataAdapter($element, options);
  572. var $container = this.render();
  573. $container.insertAfter(this.$element);
  574. $container.width($element.width());
  575. this.selection = new this.options.selectionAdapter($element, options);
  576. var $selectionContainer = $container.find(".selection");
  577. var $selection = this.selection.render();
  578. $selectionContainer.append($selection);
  579. this.dropdown = new this.options.dropdownAdapter($element, options);
  580. var $dropdownContainer = $container.find(".dropdown");
  581. var $dropdown = this.dropdown.render();
  582. $dropdownContainer.append($dropdown);
  583. this.results = new this.options.resultsAdapter($element, options);
  584. var $resultsContainer = $dropdown.find(".results");
  585. var $results = this.results.render();
  586. $resultsContainer.append($results);
  587. // Bind events
  588. this.selection.bind($container);
  589. // Set the initial state
  590. var self = this;
  591. this.data.current(function (initialData) {
  592. self.selection.update(initialData);
  593. });
  594. this.$element.on("change", function () {
  595. self.data.current(function (data) {
  596. self.selection.update(data);
  597. });
  598. });
  599. this.selection.on("toggle", function () {
  600. $container.toggleClass("open");
  601. });
  602. };
  603. Utils.Extend(Select2, Utils.Observable);
  604. Select2.prototype.render = function () {
  605. var $container = $(
  606. '<span class="select2 select2-container">' +
  607. '<span class="selection"></span>' +
  608. '<span class="dropdown"></span>' +
  609. '</span>'
  610. );
  611. return $container;
  612. };
  613. return Select2;
  614. });