choices.js
Version:
A vanilla JS customisable text input/select box plugin
1,303 lines (1,274 loc) • 190 kB
JavaScript
/*! choices.js v11.1.0 | © 2025 Josh Johnson | https://github.com/jshjohnson/Choices#readme */
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Choices = factory());
})(this, (function () { 'use strict';
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf || {
__proto__: []
} instanceof Array && function (d, b) {
d.__proto__ = b;
} || function (d, b) {
for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
};
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
var ActionType = {
ADD_CHOICE: 'ADD_CHOICE',
REMOVE_CHOICE: 'REMOVE_CHOICE',
FILTER_CHOICES: 'FILTER_CHOICES',
ACTIVATE_CHOICES: 'ACTIVATE_CHOICES',
CLEAR_CHOICES: 'CLEAR_CHOICES',
ADD_GROUP: 'ADD_GROUP',
ADD_ITEM: 'ADD_ITEM',
REMOVE_ITEM: 'REMOVE_ITEM',
HIGHLIGHT_ITEM: 'HIGHLIGHT_ITEM',
};
var EventType = {
showDropdown: 'showDropdown',
hideDropdown: 'hideDropdown',
change: 'change',
choice: 'choice',
search: 'search',
addItem: 'addItem',
removeItem: 'removeItem',
highlightItem: 'highlightItem',
highlightChoice: 'highlightChoice',
unhighlightItem: 'unhighlightItem',
};
var KeyCodeMap = {
TAB_KEY: 9,
SHIFT_KEY: 16,
BACK_KEY: 46,
DELETE_KEY: 8,
ENTER_KEY: 13,
A_KEY: 65,
ESC_KEY: 27,
UP_KEY: 38,
DOWN_KEY: 40,
PAGE_UP_KEY: 33,
PAGE_DOWN_KEY: 34,
};
var ObjectsInConfig = ['fuseOptions', 'classNames'];
var PassedElementTypes = {
Text: 'text',
SelectOne: 'select-one',
SelectMultiple: 'select-multiple',
};
var addChoice = function (choice) { return ({
type: ActionType.ADD_CHOICE,
choice: choice,
}); };
var removeChoice = function (choice) { return ({
type: ActionType.REMOVE_CHOICE,
choice: choice,
}); };
var filterChoices = function (results) { return ({
type: ActionType.FILTER_CHOICES,
results: results,
}); };
var activateChoices = function (active) {
return ({
type: ActionType.ACTIVATE_CHOICES,
active: active,
});
};
var addGroup = function (group) { return ({
type: ActionType.ADD_GROUP,
group: group,
}); };
var addItem = function (item) { return ({
type: ActionType.ADD_ITEM,
item: item,
}); };
var removeItem$1 = function (item) { return ({
type: ActionType.REMOVE_ITEM,
item: item,
}); };
var highlightItem = function (item, highlighted) { return ({
type: ActionType.HIGHLIGHT_ITEM,
item: item,
highlighted: highlighted,
}); };
var getRandomNumber = function (min, max) { return Math.floor(Math.random() * (max - min) + min); };
var generateChars = function (length) {
return Array.from({ length: length }, function () { return getRandomNumber(0, 36).toString(36); }).join('');
};
var generateId = function (element, prefix) {
var id = element.id || (element.name && "".concat(element.name, "-").concat(generateChars(2))) || generateChars(4);
id = id.replace(/(:|\.|\[|\]|,)/g, '');
id = "".concat(prefix, "-").concat(id);
return id;
};
var getAdjacentEl = function (startEl, selector, direction) {
if (direction === void 0) { direction = 1; }
var prop = "".concat(direction > 0 ? 'next' : 'previous', "ElementSibling");
var sibling = startEl[prop];
while (sibling) {
if (sibling.matches(selector)) {
return sibling;
}
sibling = sibling[prop];
}
return null;
};
var isScrolledIntoView = function (element, parent, direction) {
if (direction === void 0) { direction = 1; }
var isVisible;
if (direction > 0) {
// In view from bottom
isVisible = parent.scrollTop + parent.offsetHeight >= element.offsetTop + element.offsetHeight;
}
else {
// In view from top
isVisible = element.offsetTop >= parent.scrollTop;
}
return isVisible;
};
var sanitise = function (value) {
if (typeof value !== 'string') {
if (value === null || value === undefined) {
return '';
}
if (typeof value === 'object') {
if ('raw' in value) {
return sanitise(value.raw);
}
if ('trusted' in value) {
return value.trusted;
}
}
return value;
}
return value
.replace(/&/g, '&')
.replace(/>/g, '>')
.replace(/</g, '<')
.replace(/'/g, ''')
.replace(/"/g, '"');
};
var strToEl = (function () {
var tmpEl = document.createElement('div');
return function (str) {
tmpEl.innerHTML = str.trim();
var firstChild = tmpEl.children[0];
while (tmpEl.firstChild) {
tmpEl.removeChild(tmpEl.firstChild);
}
return firstChild;
};
})();
var resolveNoticeFunction = function (fn, value) {
return typeof fn === 'function' ? fn(sanitise(value), value) : fn;
};
var resolveStringFunction = function (fn) {
return typeof fn === 'function' ? fn() : fn;
};
var unwrapStringForRaw = function (s) {
if (typeof s === 'string') {
return s;
}
if (typeof s === 'object') {
if ('trusted' in s) {
return s.trusted;
}
if ('raw' in s) {
return s.raw;
}
}
return '';
};
var unwrapStringForEscaped = function (s) {
if (typeof s === 'string') {
return s;
}
if (typeof s === 'object') {
if ('escaped' in s) {
return s.escaped;
}
if ('trusted' in s) {
return s.trusted;
}
}
return '';
};
var escapeForTemplate = function (allowHTML, s) {
return allowHTML ? unwrapStringForEscaped(s) : sanitise(s);
};
var setElementHtml = function (el, allowHtml, html) {
el.innerHTML = escapeForTemplate(allowHtml, html);
};
var sortByAlpha = function (_a, _b) {
var value = _a.value, _c = _a.label, label = _c === void 0 ? value : _c;
var value2 = _b.value, _d = _b.label, label2 = _d === void 0 ? value2 : _d;
return unwrapStringForRaw(label).localeCompare(unwrapStringForRaw(label2), [], {
sensitivity: 'base',
ignorePunctuation: true,
numeric: true,
});
};
var sortByRank = function (a, b) {
return a.rank - b.rank;
};
var dispatchEvent = function (element, type, customArgs) {
if (customArgs === void 0) { customArgs = null; }
var event = new CustomEvent(type, {
detail: customArgs,
bubbles: true,
cancelable: true,
});
return element.dispatchEvent(event);
};
/**
* Returns an array of keys present on the first but missing on the second object
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
var diff = function (a, b) {
var aKeys = Object.keys(a).sort();
var bKeys = Object.keys(b).sort();
return aKeys.filter(function (i) { return bKeys.indexOf(i) < 0; });
};
var getClassNames = function (ClassNames) {
return Array.isArray(ClassNames) ? ClassNames : [ClassNames];
};
var getClassNamesSelector = function (option) {
if (option && Array.isArray(option)) {
return option
.map(function (item) {
return ".".concat(item);
})
.join('');
}
return ".".concat(option);
};
var addClassesToElement = function (element, className) {
var _a;
(_a = element.classList).add.apply(_a, getClassNames(className));
};
var removeClassesFromElement = function (element, className) {
var _a;
(_a = element.classList).remove.apply(_a, getClassNames(className));
};
var parseCustomProperties = function (customProperties) {
if (typeof customProperties !== 'undefined') {
try {
return JSON.parse(customProperties);
}
catch (e) {
return customProperties;
}
}
return {};
};
var updateClassList = function (item, add, remove) {
var itemEl = item.itemEl;
if (itemEl) {
removeClassesFromElement(itemEl, remove);
addClassesToElement(itemEl, add);
}
};
var Dropdown = /** @class */ (function () {
function Dropdown(_a) {
var element = _a.element, type = _a.type, classNames = _a.classNames;
this.element = element;
this.classNames = classNames;
this.type = type;
this.isActive = false;
}
/**
* Show dropdown to user by adding active state class
*/
Dropdown.prototype.show = function () {
addClassesToElement(this.element, this.classNames.activeState);
this.element.setAttribute('aria-expanded', 'true');
this.isActive = true;
return this;
};
/**
* Hide dropdown from user
*/
Dropdown.prototype.hide = function () {
removeClassesFromElement(this.element, this.classNames.activeState);
this.element.setAttribute('aria-expanded', 'false');
this.isActive = false;
return this;
};
return Dropdown;
}());
var Container = /** @class */ (function () {
function Container(_a) {
var element = _a.element, type = _a.type, classNames = _a.classNames, position = _a.position;
this.element = element;
this.classNames = classNames;
this.type = type;
this.position = position;
this.isOpen = false;
this.isFlipped = false;
this.isDisabled = false;
this.isLoading = false;
}
/**
* Determine whether container should be flipped based on passed
* dropdown position
*/
Container.prototype.shouldFlip = function (dropdownPos, dropdownHeight) {
// If flip is enabled and the dropdown bottom position is
// greater than the window height flip the dropdown.
var shouldFlip = false;
if (this.position === 'auto') {
shouldFlip =
this.element.getBoundingClientRect().top - dropdownHeight >= 0 &&
!window.matchMedia("(min-height: ".concat(dropdownPos + 1, "px)")).matches;
}
else if (this.position === 'top') {
shouldFlip = true;
}
return shouldFlip;
};
Container.prototype.setActiveDescendant = function (activeDescendantID) {
this.element.setAttribute('aria-activedescendant', activeDescendantID);
};
Container.prototype.removeActiveDescendant = function () {
this.element.removeAttribute('aria-activedescendant');
};
Container.prototype.open = function (dropdownPos, dropdownHeight) {
addClassesToElement(this.element, this.classNames.openState);
this.element.setAttribute('aria-expanded', 'true');
this.isOpen = true;
if (this.shouldFlip(dropdownPos, dropdownHeight)) {
addClassesToElement(this.element, this.classNames.flippedState);
this.isFlipped = true;
}
};
Container.prototype.close = function () {
removeClassesFromElement(this.element, this.classNames.openState);
this.element.setAttribute('aria-expanded', 'false');
this.removeActiveDescendant();
this.isOpen = false;
// A dropdown flips if it does not have space within the page
if (this.isFlipped) {
removeClassesFromElement(this.element, this.classNames.flippedState);
this.isFlipped = false;
}
};
Container.prototype.addFocusState = function () {
addClassesToElement(this.element, this.classNames.focusState);
};
Container.prototype.removeFocusState = function () {
removeClassesFromElement(this.element, this.classNames.focusState);
};
Container.prototype.enable = function () {
removeClassesFromElement(this.element, this.classNames.disabledState);
this.element.removeAttribute('aria-disabled');
if (this.type === PassedElementTypes.SelectOne) {
this.element.setAttribute('tabindex', '0');
}
this.isDisabled = false;
};
Container.prototype.disable = function () {
addClassesToElement(this.element, this.classNames.disabledState);
this.element.setAttribute('aria-disabled', 'true');
if (this.type === PassedElementTypes.SelectOne) {
this.element.setAttribute('tabindex', '-1');
}
this.isDisabled = true;
};
Container.prototype.wrap = function (element) {
var el = this.element;
var parentNode = element.parentNode;
if (parentNode) {
if (element.nextSibling) {
parentNode.insertBefore(el, element.nextSibling);
}
else {
parentNode.appendChild(el);
}
}
el.appendChild(element);
};
Container.prototype.unwrap = function (element) {
var el = this.element;
var parentNode = el.parentNode;
if (parentNode) {
// Move passed element outside this element
parentNode.insertBefore(element, el);
// Remove this element
parentNode.removeChild(el);
}
};
Container.prototype.addLoadingState = function () {
addClassesToElement(this.element, this.classNames.loadingState);
this.element.setAttribute('aria-busy', 'true');
this.isLoading = true;
};
Container.prototype.removeLoadingState = function () {
removeClassesFromElement(this.element, this.classNames.loadingState);
this.element.removeAttribute('aria-busy');
this.isLoading = false;
};
return Container;
}());
var Input = /** @class */ (function () {
function Input(_a) {
var element = _a.element, type = _a.type, classNames = _a.classNames, preventPaste = _a.preventPaste;
this.element = element;
this.type = type;
this.classNames = classNames;
this.preventPaste = preventPaste;
this.isFocussed = this.element.isEqualNode(document.activeElement);
this.isDisabled = element.disabled;
this._onPaste = this._onPaste.bind(this);
this._onInput = this._onInput.bind(this);
this._onFocus = this._onFocus.bind(this);
this._onBlur = this._onBlur.bind(this);
}
Object.defineProperty(Input.prototype, "placeholder", {
set: function (placeholder) {
this.element.placeholder = placeholder;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Input.prototype, "value", {
get: function () {
return this.element.value;
},
set: function (value) {
this.element.value = value;
},
enumerable: false,
configurable: true
});
Input.prototype.addEventListeners = function () {
var el = this.element;
el.addEventListener('paste', this._onPaste);
el.addEventListener('input', this._onInput, {
passive: true,
});
el.addEventListener('focus', this._onFocus, {
passive: true,
});
el.addEventListener('blur', this._onBlur, {
passive: true,
});
};
Input.prototype.removeEventListeners = function () {
var el = this.element;
el.removeEventListener('input', this._onInput);
el.removeEventListener('paste', this._onPaste);
el.removeEventListener('focus', this._onFocus);
el.removeEventListener('blur', this._onBlur);
};
Input.prototype.enable = function () {
var el = this.element;
el.removeAttribute('disabled');
this.isDisabled = false;
};
Input.prototype.disable = function () {
var el = this.element;
el.setAttribute('disabled', '');
this.isDisabled = true;
};
Input.prototype.focus = function () {
if (!this.isFocussed) {
this.element.focus();
}
};
Input.prototype.blur = function () {
if (this.isFocussed) {
this.element.blur();
}
};
Input.prototype.clear = function (setWidth) {
if (setWidth === void 0) { setWidth = true; }
this.element.value = '';
if (setWidth) {
this.setWidth();
}
return this;
};
/**
* Set the correct input width based on placeholder
* value or input value
*/
Input.prototype.setWidth = function () {
// Resize input to contents or placeholder
var element = this.element;
element.style.minWidth = "".concat(element.placeholder.length + 1, "ch");
element.style.width = "".concat(element.value.length + 1, "ch");
};
Input.prototype.setActiveDescendant = function (activeDescendantID) {
this.element.setAttribute('aria-activedescendant', activeDescendantID);
};
Input.prototype.removeActiveDescendant = function () {
this.element.removeAttribute('aria-activedescendant');
};
Input.prototype._onInput = function () {
if (this.type !== PassedElementTypes.SelectOne) {
this.setWidth();
}
};
Input.prototype._onPaste = function (event) {
if (this.preventPaste) {
event.preventDefault();
}
};
Input.prototype._onFocus = function () {
this.isFocussed = true;
};
Input.prototype._onBlur = function () {
this.isFocussed = false;
};
return Input;
}());
var SCROLLING_SPEED = 4;
var List = /** @class */ (function () {
function List(_a) {
var element = _a.element;
this.element = element;
this.scrollPos = this.element.scrollTop;
this.height = this.element.offsetHeight;
}
List.prototype.prepend = function (node) {
var child = this.element.firstElementChild;
if (child) {
this.element.insertBefore(node, child);
}
else {
this.element.append(node);
}
};
List.prototype.scrollToTop = function () {
this.element.scrollTop = 0;
};
List.prototype.scrollToChildElement = function (element, direction) {
var _this = this;
if (!element) {
return;
}
var listHeight = this.element.offsetHeight;
// Scroll position of dropdown
var listScrollPosition = this.element.scrollTop + listHeight;
var elementHeight = element.offsetHeight;
// Distance from bottom of element to top of parent
var elementPos = element.offsetTop + elementHeight;
// Difference between the element and scroll position
var destination = direction > 0 ? this.element.scrollTop + elementPos - listScrollPosition : element.offsetTop;
requestAnimationFrame(function () {
_this._animateScroll(destination, direction);
});
};
List.prototype._scrollDown = function (scrollPos, strength, destination) {
var easing = (destination - scrollPos) / strength;
var distance = easing > 1 ? easing : 1;
this.element.scrollTop = scrollPos + distance;
};
List.prototype._scrollUp = function (scrollPos, strength, destination) {
var easing = (scrollPos - destination) / strength;
var distance = easing > 1 ? easing : 1;
this.element.scrollTop = scrollPos - distance;
};
List.prototype._animateScroll = function (destination, direction) {
var _this = this;
var strength = SCROLLING_SPEED;
var choiceListScrollTop = this.element.scrollTop;
var continueAnimation = false;
if (direction > 0) {
this._scrollDown(choiceListScrollTop, strength, destination);
if (choiceListScrollTop < destination) {
continueAnimation = true;
}
}
else {
this._scrollUp(choiceListScrollTop, strength, destination);
if (choiceListScrollTop > destination) {
continueAnimation = true;
}
}
if (continueAnimation) {
requestAnimationFrame(function () {
_this._animateScroll(destination, direction);
});
}
};
return List;
}());
var WrappedElement = /** @class */ (function () {
function WrappedElement(_a) {
var element = _a.element, classNames = _a.classNames;
this.element = element;
this.classNames = classNames;
this.isDisabled = false;
}
Object.defineProperty(WrappedElement.prototype, "isActive", {
get: function () {
return this.element.dataset.choice === 'active';
},
enumerable: false,
configurable: true
});
Object.defineProperty(WrappedElement.prototype, "dir", {
get: function () {
return this.element.dir;
},
enumerable: false,
configurable: true
});
Object.defineProperty(WrappedElement.prototype, "value", {
get: function () {
return this.element.value;
},
set: function (value) {
this.element.setAttribute('value', value);
this.element.value = value;
},
enumerable: false,
configurable: true
});
WrappedElement.prototype.conceal = function () {
var el = this.element;
// Hide passed input
addClassesToElement(el, this.classNames.input);
el.hidden = true;
// Remove element from tab index
el.tabIndex = -1;
// Backup original styles if any
var origStyle = el.getAttribute('style');
if (origStyle) {
el.setAttribute('data-choice-orig-style', origStyle);
}
el.setAttribute('data-choice', 'active');
};
WrappedElement.prototype.reveal = function () {
var el = this.element;
// Reinstate passed element
removeClassesFromElement(el, this.classNames.input);
el.hidden = false;
el.removeAttribute('tabindex');
// Recover original styles if any
var origStyle = el.getAttribute('data-choice-orig-style');
if (origStyle) {
el.removeAttribute('data-choice-orig-style');
el.setAttribute('style', origStyle);
}
else {
el.removeAttribute('style');
}
el.removeAttribute('data-choice');
};
WrappedElement.prototype.enable = function () {
this.element.removeAttribute('disabled');
this.element.disabled = false;
this.isDisabled = false;
};
WrappedElement.prototype.disable = function () {
this.element.setAttribute('disabled', '');
this.element.disabled = true;
this.isDisabled = true;
};
WrappedElement.prototype.triggerEvent = function (eventType, data) {
dispatchEvent(this.element, eventType, data || {});
};
return WrappedElement;
}());
var WrappedInput = /** @class */ (function (_super) {
__extends(WrappedInput, _super);
function WrappedInput() {
return _super !== null && _super.apply(this, arguments) || this;
}
return WrappedInput;
}(WrappedElement));
var coerceBool = function (arg, defaultValue) {
if (defaultValue === void 0) { defaultValue = true; }
return typeof arg === 'undefined' ? defaultValue : !!arg;
};
var stringToHtmlClass = function (input) {
if (typeof input === 'string') {
// eslint-disable-next-line no-param-reassign
input = input.split(' ').filter(function (s) { return s.length; });
}
if (Array.isArray(input) && input.length) {
return input;
}
return undefined;
};
var mapInputToChoice = function (value, allowGroup, allowRawString) {
if (allowRawString === void 0) { allowRawString = true; }
if (typeof value === 'string') {
var sanitisedValue = sanitise(value);
var userValue = allowRawString || sanitisedValue === value ? value : { escaped: sanitisedValue, raw: value };
var result_1 = mapInputToChoice({
value: value,
label: userValue,
selected: true,
}, false);
return result_1;
}
var groupOrChoice = value;
if ('choices' in groupOrChoice) {
if (!allowGroup) {
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/optgroup
throw new TypeError("optGroup is not allowed");
}
var group = groupOrChoice;
var choices = group.choices.map(function (e) { return mapInputToChoice(e, false); });
var result_2 = {
id: 0, // actual ID will be assigned during _addGroup
label: unwrapStringForRaw(group.label) || group.value,
active: !!choices.length,
disabled: !!group.disabled,
choices: choices,
};
return result_2;
}
var choice = groupOrChoice;
var result = {
id: 0, // actual ID will be assigned during _addChoice
group: null, // actual group will be assigned during _addGroup but before _addChoice
score: 0, // used in search
rank: 0, // used in search, stable sort order
value: choice.value,
label: choice.label || choice.value,
active: coerceBool(choice.active),
selected: coerceBool(choice.selected, false),
disabled: coerceBool(choice.disabled, false),
placeholder: coerceBool(choice.placeholder, false),
highlighted: false,
labelClass: stringToHtmlClass(choice.labelClass),
labelDescription: choice.labelDescription,
customProperties: choice.customProperties,
};
return result;
};
var isHtmlInputElement = function (e) { return e.tagName === 'INPUT'; };
var isHtmlSelectElement = function (e) { return e.tagName === 'SELECT'; };
var isHtmlOption = function (e) { return e.tagName === 'OPTION'; };
var isHtmlOptgroup = function (e) { return e.tagName === 'OPTGROUP'; };
var WrappedSelect = /** @class */ (function (_super) {
__extends(WrappedSelect, _super);
function WrappedSelect(_a) {
var element = _a.element, classNames = _a.classNames, template = _a.template, extractPlaceholder = _a.extractPlaceholder;
var _this = _super.call(this, { element: element, classNames: classNames }) || this;
_this.template = template;
_this.extractPlaceholder = extractPlaceholder;
return _this;
}
Object.defineProperty(WrappedSelect.prototype, "placeholderOption", {
get: function () {
return (this.element.querySelector('option[value=""]') ||
// Backward compatibility layer for the non-standard placeholder attribute supported in older versions.
this.element.querySelector('option[placeholder]'));
},
enumerable: false,
configurable: true
});
WrappedSelect.prototype.addOptions = function (choices) {
var _this = this;
var fragment = document.createDocumentFragment();
choices.forEach(function (obj) {
var choice = obj;
if (choice.element) {
return;
}
var option = _this.template(choice);
fragment.appendChild(option);
choice.element = option;
});
this.element.appendChild(fragment);
};
WrappedSelect.prototype.optionsAsChoices = function () {
var _this = this;
var choices = [];
this.element.querySelectorAll(':scope > option, :scope > optgroup').forEach(function (e) {
if (isHtmlOption(e)) {
choices.push(_this._optionToChoice(e));
}
else if (isHtmlOptgroup(e)) {
choices.push(_this._optgroupToChoice(e));
}
// todo: hr as empty optgroup, requires displaying empty opt-groups to be useful
});
return choices;
};
// eslint-disable-next-line class-methods-use-this
WrappedSelect.prototype._optionToChoice = function (option) {
// option.value returns the label if there is no value attribute, which can break legacy placeholder attribute support
if (!option.hasAttribute('value') && option.hasAttribute('placeholder')) {
option.setAttribute('value', '');
option.value = '';
}
return {
id: 0,
group: null,
score: 0,
rank: 0,
value: option.value,
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/option
// This attribute is text for the label indicating the meaning of the option. If the `label` attribute isn't defined, its value is that of the element text content (ie `innerText`).
label: option.label,
element: option,
active: true,
// this returns true if nothing is selected on initial load, which will break placeholder support
selected: this.extractPlaceholder ? option.selected : option.hasAttribute('selected'),
disabled: option.disabled,
highlighted: false,
placeholder: this.extractPlaceholder && (!option.value || option.hasAttribute('placeholder')),
labelClass: typeof option.dataset.labelClass !== 'undefined' ? stringToHtmlClass(option.dataset.labelClass) : undefined,
labelDescription: typeof option.dataset.labelDescription !== 'undefined' ? option.dataset.labelDescription : undefined,
customProperties: parseCustomProperties(option.dataset.customProperties),
};
};
WrappedSelect.prototype._optgroupToChoice = function (optgroup) {
var _this = this;
var options = optgroup.querySelectorAll('option');
var choices = Array.from(options).map(function (option) { return _this._optionToChoice(option); });
return {
id: 0,
label: optgroup.label || '',
element: optgroup,
active: !!choices.length,
disabled: optgroup.disabled,
choices: choices,
};
};
return WrappedSelect;
}(WrappedElement));
var DEFAULT_CLASSNAMES = {
containerOuter: ['choices'],
containerInner: ['choices__inner'],
input: ['choices__input'],
inputCloned: ['choices__input--cloned'],
list: ['choices__list'],
listItems: ['choices__list--multiple'],
listSingle: ['choices__list--single'],
listDropdown: ['choices__list--dropdown'],
item: ['choices__item'],
itemSelectable: ['choices__item--selectable'],
itemDisabled: ['choices__item--disabled'],
itemChoice: ['choices__item--choice'],
description: ['choices__description'],
placeholder: ['choices__placeholder'],
group: ['choices__group'],
groupHeading: ['choices__heading'],
button: ['choices__button'],
activeState: ['is-active'],
focusState: ['is-focused'],
openState: ['is-open'],
disabledState: ['is-disabled'],
highlightedState: ['is-highlighted'],
selectedState: ['is-selected'],
flippedState: ['is-flipped'],
loadingState: ['is-loading'],
notice: ['choices__notice'],
addChoice: ['choices__item--selectable', 'add-choice'],
noResults: ['has-no-results'],
noChoices: ['has-no-choices'],
};
var DEFAULT_CONFIG = {
items: [],
choices: [],
silent: false,
renderChoiceLimit: -1,
maxItemCount: -1,
closeDropdownOnSelect: 'auto',
singleModeForMultiSelect: false,
addChoices: false,
addItems: true,
addItemFilter: function (value) { return !!value && value !== ''; },
removeItems: true,
removeItemButton: false,
removeItemButtonAlignLeft: false,
editItems: false,
allowHTML: false,
allowHtmlUserInput: false,
duplicateItemsAllowed: true,
delimiter: ',',
paste: true,
searchEnabled: true,
searchChoices: true,
searchFloor: 1,
searchResultLimit: 4,
searchFields: ['label', 'value'],
position: 'auto',
resetScrollPosition: true,
shouldSort: true,
shouldSortItems: false,
sorter: sortByAlpha,
shadowRoot: null,
placeholder: true,
placeholderValue: null,
searchPlaceholderValue: null,
prependValue: null,
appendValue: null,
renderSelectedChoices: 'auto',
loadingText: 'Loading...',
noResultsText: 'No results found',
noChoicesText: 'No choices to choose from',
itemSelectText: 'Press to select',
uniqueItemText: 'Only unique values can be added',
customAddItemText: 'Only values matching specific conditions can be added',
addItemText: function (value) { return "Press Enter to add <b>\"".concat(value, "\"</b>"); },
removeItemIconText: function () { return "Remove item"; },
removeItemLabelText: function (value) { return "Remove item: ".concat(value); },
maxItemText: function (maxItemCount) { return "Only ".concat(maxItemCount, " values can be added"); },
valueComparer: function (value1, value2) { return value1 === value2; },
fuseOptions: {
includeScore: true,
},
labelId: '',
callbackOnInit: null,
callbackOnCreateTemplates: null,
classNames: DEFAULT_CLASSNAMES,
appendGroupInSearch: false,
};
var removeItem = function (item) {
var itemEl = item.itemEl;
if (itemEl) {
itemEl.remove();
item.itemEl = undefined;
}
};
function items(s, action, context) {
var state = s;
var update = true;
switch (action.type) {
case ActionType.ADD_ITEM: {
action.item.selected = true;
var el = action.item.element;
if (el) {
el.selected = true;
el.setAttribute('selected', '');
}
state.push(action.item);
break;
}
case ActionType.REMOVE_ITEM: {
action.item.selected = false;
var el = action.item.element;
if (el) {
el.selected = false;
el.removeAttribute('selected');
// For a select-one, if all options are deselected, the first item is selected. To set a black value, select.value needs to be set
var select = el.parentElement;
if (select && isHtmlSelectElement(select) && select.type === PassedElementTypes.SelectOne) {
select.value = '';
}
}
// this is mixing concerns, but this is *so much faster*
removeItem(action.item);
state = state.filter(function (choice) { return choice.id !== action.item.id; });
break;
}
case ActionType.REMOVE_CHOICE: {
removeItem(action.choice);
state = state.filter(function (item) { return item.id !== action.choice.id; });
break;
}
case ActionType.HIGHLIGHT_ITEM: {
var highlighted = action.highlighted;
var item = state.find(function (obj) { return obj.id === action.item.id; });
if (item && item.highlighted !== highlighted) {
item.highlighted = highlighted;
if (context) {
updateClassList(item, highlighted ? context.classNames.highlightedState : context.classNames.selectedState, highlighted ? context.classNames.selectedState : context.classNames.highlightedState);
}
}
break;
}
default: {
update = false;
break;
}
}
return { state: state, update: update };
}
function groups(s, action) {
var state = s;
var update = true;
switch (action.type) {
case ActionType.ADD_GROUP: {
state.push(action.group);
break;
}
case ActionType.CLEAR_CHOICES: {
state = [];
break;
}
default: {
update = false;
break;
}
}
return { state: state, update: update };
}
/* eslint-disable */
function choices(s, action, context) {
var state = s;
var update = true;
switch (action.type) {
case ActionType.ADD_CHOICE: {
state.push(action.choice);
break;
}
case ActionType.REMOVE_CHOICE: {
action.choice.choiceEl = undefined;
if (action.choice.group) {
action.choice.group.choices = action.choice.group.choices.filter(function (obj) { return obj.id !== action.choice.id; });
}
state = state.filter(function (obj) { return obj.id !== action.choice.id; });
break;
}
case ActionType.ADD_ITEM:
case ActionType.REMOVE_ITEM: {
action.item.choiceEl = undefined;
break;
}
case ActionType.FILTER_CHOICES: {
// avoid O(n^2) algorithm complexity when searching/filtering choices
var scoreLookup_1 = [];
action.results.forEach(function (result) {
scoreLookup_1[result.item.id] = result;
});
state.forEach(function (choice) {
var result = scoreLookup_1[choice.id];
if (result !== undefined) {
choice.score = result.score;
choice.rank = result.rank;
choice.active = true;
}
else {
choice.score = 0;
choice.rank = 0;
choice.active = false;
}
if (context && context.appendGroupInSearch) {
choice.choiceEl = undefined;
}
});
break;
}
case ActionType.ACTIVATE_CHOICES: {
state.forEach(function (choice) {
choice.active = action.active;
if (context && context.appendGroupInSearch) {
choice.choiceEl = undefined;
}
});
break;
}
case ActionType.CLEAR_CHOICES: {
state = [];
break;
}
default: {
update = false;
break;
}
}
return { state: state, update: update };
}
var reducers = {
groups: groups,
items: items,
choices: choices,
};
var Store = /** @class */ (function () {
function Store(context) {
this._state = this.defaultState;
this._listeners = [];
this._txn = 0;
this._context = context;
}
Object.defineProperty(Store.prototype, "defaultState", {
// eslint-disable-next-line class-methods-use-this
get: function () {
return {
groups: [],
items: [],
choices: [],
};
},
enumerable: false,
configurable: true
});
// eslint-disable-next-line class-methods-use-this
Store.prototype.changeSet = function (init) {
return {
groups: init,
items: init,
choices: init,
};
};
Store.prototype.reset = function () {
this._state = this.defaultState;
var changes = this.changeSet(true);
if (this._txn) {
this._changeSet = changes;
}
else {
this._listeners.forEach(function (l) { return l(changes); });
}
};
Store.prototype.subscribe = function (onChange) {
this._listeners.push(onChange);
return this;
};
Store.prototype.dispatch = function (action) {
var _this = this;
var state = this._state;
var hasChanges = false;
var changes = this._changeSet || this.changeSet(false);
Object.keys(reducers).forEach(function (key) {
var stateUpdate = reducers[key](state[key], action, _this._context);
if (stateUpdate.update) {
hasChanges = true;
changes[key] = true;
state[key] = stateUpdate.state;
}
});
if (hasChanges) {
if (this._txn) {
this._changeSet = changes;
}
else {
this._listeners.forEach(function (l) { return l(changes); });
}
}
};
Store.prototype.withTxn = function (func) {
this._txn++;
try {
func();
}
finally {
this._txn = Math.max(0, this._txn - 1);
if (!this._txn) {
var changeSet_1 = this._changeSet;
if (changeSet_1) {
this._changeSet = undefined;
this._listeners.forEach(function (l) { return l(changeSet_1); });
}
}
}
};
Object.defineProperty(Store.prototype, "state", {
/**
* Get store object
*/
get: function () {
return this._state;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Store.prototype, "items", {
/**
* Get items from store
*/
get: function () {
return this.state.items;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Store.prototype, "highlightedActiveItems", {
/**
* Get highlighted items from store
*/
get: function () {
return this.items.filter(function (item) { return item.active && item.highlighted; });
},
enumerable: false,
configurable: true
});
Object.defineProperty(Store.prototype, "choices", {
/**
* Get choices from store
*/
get: function () {
return this.state.choices;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Store.prototype, "activeChoices", {
/**
* Get active choices from store
*/
get: function () {
return this.choices.filter(function (choice) { return choice.active; });
},
enumerable: false,
configurable: true
});
Object.defineProperty(Store.prototype, "searchableChoices", {
/**
* Get choices that can be searched (excluding placeholders or disabled choices)
*/
get: function () {
return this.choices.filter(function (choice) { return !choice.disabled && !choice.placeholder; });
},
enumerable: false,
configurable: true
});
Object.defineProperty(Store.prototype, "groups", {
/**
* Get groups from store
*/
get: function () {
return this.state.groups;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Store.prototype, "activeGroups", {
/**
* Get active groups from store
*/
get: function () {
var _this = th