Select2 is a jQuery based replacement for select boxes. It supports searching, remote data sets, and infinite scrolling of results.
4afa7f88a4
* Made the test suite for translations more complete There were previously tests for translations within the test suite, but they only covered a select few problem cases that had previously been fixed. They did not cover the majority of cases, which makes changes to how the translation mechanism for Select2 works a bit more challenging. So this adds tests for the majority of edge cases around translations, including how one would expect the fallback chains to work and also around how defaults interact with the language options. This should not be considered an exhaustive list of all of the edge cases, but it should be good enough to refactor the internals and not have to worry as much. The one change of note to this test file is that we are now properly resetting the defaults in between tests. This should fix any issues that we may have seen where the defaults were not being reset, and thus tests were not properly isolated and would start to interfere with each other. This required pulling the module definition down below the imports, since we need to reference the defaults within the module definition. Many of these tests will fail because the translation system is broken in many small, unrealized ways. The next few commits should make these pass and fix the issues that we are seeing. * Consistently resolve the language option This fixes an issue that we have had for a while where we did not have a way to consistently take the `language` option from a string, array, object, or whatever else is specified and resolve it into `Translation`-compatible objects or strings. Now there is a new internal `_resolveLanguage` function which is able to take any of the supported ways of specifying a language and resolve it down into the supported language chain. This now means that we can properly resolve the following cases, and we can do it in a consistent manner. * When the language is specified as just a string (for example: "en") * When the language is specified as a string containing a region (for example: "en-US") * When the langugae chian is specified as a list of strings (for example: ["es", "en"]) * When the language is specifid as an object containing messages (for example, when a user overrides only a subset of messages) * When the language is specified as a list of strings and objects (for example, when a user wants to use a language other than English and also wants to ovverride some default messages) * When the language is not specified at all (the most common case) * When the language is specified as an empty object (an edge case that allows us to skip processing it) This allows us to consistently produce the language fallback chain based on the given `language` option, something which we could not actually do before because we didn't have a consistent chain. This also means that now the `language` option will consistently be an array after going through this process, instead of being any number of types before. The translation generation currently does not support having objects and strings mixed as a part of the fallback chain, despite that being how the default chain has always worked, and as such there are still failing tests around this. * Move English to always be at the end of the language chain This was technically true in most cases in the past, because if a language chain was manually specified then it would have English injected into the end of it anyway. This is needed because not all translations are complete, but we know the English one is, and Select2 relies on the translation that it uses being complete. This will result in cases where a user specifies a language but still receives English translation for some things, which is what users have historically seen when using partial translations anyway. This just ensures that there will always be a complete translation that is being used, so they won't get unexpected errors and will instead get unexpected English translations. * Filter out repeated languages in fallback chain This is mostly being done for performance reasons, since Select2 will not behave any differently when there are duplicates, but it makes things cleaner when you ask for the fallback chain and it only contains unique values. This cannot distinguish between languages specified by name (string) and languages specified by the contents of their language file (such as the default, English), but this should generally not be an issue. * Convert the language chain into a finalized translation This extracts the logic for converting parts of the language chain into the finalized `Translation` objects out into its own method, with some small fixes for edge cases. This can now properly convert a language chain containing both strings and objects into a translation object that contains them both. We no longer need to special case the `language` option being an array since we know that it will be an array once the language resolution process is completed. * Switch default translation to be empty This should have no external effects, but it fixes an interesting bug where resetting the defaults would not always reset custom translations. This was because it was possible to modify the included English translation when you were setting a default for the language option. This should not cause any issues because the English translation is now appended to the end of the language chain when the defaults are applied, which means that English will continue to exist as the final fallback. * Inherited `lang` attribute should be below the default in the chain It was pointed out in #5468 that the `lang` attribute, when inherited from a parent element, was above the option set in the global default within the inheritance chain. While this makes sense because of how we inherit other properties, it does not make sense for the `lang` attribute. The inheritance chain for the `language` option has been adjusted to be the following: 1. The `lang` attribute on the original `<select>` element 2. The `data-language` attribute on the original `<select>` element (because of how `data-*` attribute resolution affects options) 3. The `language` option specified when initiailizing Select2 4. The `language` Select2 default 5. The `lang` attribute on a parent of the `<select>` element While this is a breaking change, we believe that this change will have minimal to no impact on real-world usage of Select2, because of how the `lang` attribute is generally used within documents. We believe this will now make setting the default language through JavaScript easier and more reliable, bringing it in line with how we recommend it is done within the documentation. This was implemented through a new method `Defaults.applyFromElement` instead of within the old `Options.fromElement` method because it relies on the global defaults object. While we could have reached in to the internals in order to apply it appropriately, it made more sense to handle the proper resolution through a single consistent place. This was not implemented in the `Defaults.apply` method because that method is not typically passed in a reference to the original `<select>` element that it is applying the options for. Closes #5468 * Properly resolve language chains with dictionaries It is possible for a language chain to be specified that includes both a dictionary and the string translation as a part of the same chain, but we would previously throw an error because we assumed that the list could only contain strings and that dictionaries would never be included in lists. This fixes the issue so language region normalization only occurs when a string is specified in the language chain, which is what we were previously assuming was the case but was not actually. This also now resolves the entire language option during the `Defaults.apply` method. This should be a no-op except for internal tests, because the `Defaults.applyFromElement` method should almost always be called in real-world scenarios. |
||
|---|---|---|
| .github | ||
| dist | ||
| docs | ||
| src | ||
| tests | ||
| .editorconfig | ||
| .gitignore | ||
| .jshintignore | ||
| .jshintrc | ||
| .travis.yml | ||
| bower.json | ||
| CHANGELOG.md | ||
| component.json | ||
| composer.json | ||
| Gruntfile.js | ||
| LICENSE.md | ||
| package.json | ||
| README.md | ||
Select2
Select2 is a jQuery-based replacement for select boxes. It supports searching, remote data sets, and pagination of results.
To get started, checkout examples and documentation at https://select2.org/
Use cases
- Enhancing native selects with search.
- Enhancing native selects with a better multi-select interface.
- Loading data from JavaScript: easily load items via AJAX and have them searchable.
- Nesting optgroups: native selects only support one level of nesting. Select2 does not have this restriction.
- Tagging: ability to add new items on the fly.
- Working with large, remote datasets: ability to partially load a dataset based on the search term.
- Paging of large datasets: easy support for loading more pages when the results are scrolled to the end.
- Templating: support for custom rendering of results and selections.
Browser compatibility
- IE 8+
- Chrome 8+
- Firefox 10+
- Safari 3+
- Opera 10.6+
Usage
You can source Select2 directly from a CDN like JSDliver or CDNJS, download it from this GitHub repo, or use one of the integrations below.
Integrations
Third party developers have created plugins for platforms which allow Select2 to be integrated more natively and quickly. For many platforms, additional plugins are not required because Select2 acts as a standard <select> box.
Plugins
- Django
- Drupal - drupal-select2
- Meteor - meteor-select2
- Ruby on Rails - select2-rails
- Wicket - wicketstuff-select2
- Yii 2 - yii2-widget-select2
- Angularjs - mdr-angular-select2
Themes
- Bootstrap 3 - select2-bootstrap-theme
- Bootstrap 4 - select2-bootstrap4-theme
- Flat UI - select2-flat-theme
- Metro UI - select2-metro
Missing an integration? Modify this README and make a pull request back here to Select2 on GitHub.
Internationalization (i18n)
Select2 supports multiple languages by simply including the right language JS
file (dist/js/i18n/it.js, dist/js/i18n/nl.js, etc.) after
dist/js/select2.js.
Missing a language? Just copy src/js/select2/i18n/en.js, translate it, and
make a pull request back to Select2 here on GitHub.
Documentation
The documentation for Select2 is available
through GitHub Pages and is located within the separate select2/docs repository.
Community
You can find out about the different ways to get in touch with the Select2 community at the Select2 community page.
Copyright and license
The license is available within the repository in the LICENSE file.