vgapp 0.1.5 → 0.1.7

package/app/modules/vgselect/js/vgselect.js

@@ -1,5 +1,13 @@
 import BaseModule from "../../base-module";
-import {isDisabled, isEmptyObj, mergeDeepObject, noop, transliterate} from "../../../utils/js/functions";
+import {
+	execute,
+	isDisabled,
+	isEmptyObj,
+	mergeDeepObject,
+	noop,
+	normalizeData,
+	transliterate
+} from "../../../utils/js/functions";
 import {Manipulator} from "../../../utils/js/dom/manipulator";
 import EventHandler from "../../../utils/js/dom/event";
 import Selectors from "../../../utils/js/dom/selectors";
@@ -23,13 +31,16 @@ const CLASS_NAME_PLACEHOLDER    = 'vg-select-current--placeholder';
 const CLASS_NAME_SEARCH         = 'vg-select-search';
 
 const EVENT_KEY_CLICK_DATA_API  = `click.${NAME_KEY}.data.api`;
+const EVENT_KEY_UP_DATA_API     = `keyup.${NAME_KEY}.data.api`;
 const EVENT_KEY_CHANGE          = `${NAME_KEY}.change`;
 const EVENT_KEY_HIDE            = `${NAME_KEY}.hide`;
 const EVENT_KEY_HIDDEN          = `${NAME_KEY}.hidden`;
 const EVENT_KEY_SHOW            = `${NAME_KEY}.show`;
 const EVENT_KEY_SHOWN           = `${NAME_KEY}.shown`;
 
-const SELECTOR_DATA_TOGGLE = '[data-vg-toggle="select"]';
+const SELECTOR_DATA_TOGGLE    = '[data-vg-toggle="select"]';
+const SELECTOR_OPTION_TOGGLE  = '[data-vg-toggle="select-option"]';
+const SELECTOR_SEARCH_TOGGLE  = '[name=vg-select-search]';
 
 
 let observerTimout;
@@ -46,10 +57,15 @@ class VGSelect extends BaseModule {
 				target: '',
 				method: 'get',
 				loader: false,
+			},
+			render: {
+				option: noop,
+				item: noop
 			}
 		}, params));
 
 		this._drop = Selectors.find('.' + CLASS_NAME_DROPDOWN, this._element);
+		this.refresh();
 	}
 
 	static get NAME() {
@@ -60,101 +76,109 @@ class VGSelect extends BaseModule {
 		return NAME_KEY;
 	}
 
-	toggle(relatedTarget) {
-		return !this._isShown() ? this.show(relatedTarget) : this.hide();
-	}
+	static buildListOptions(selector, drop) {
+		let options = selector.options,
+			list = document.createElement('ul');
 
-	show(relatedTarget) {
-		if (isDisabled(this._element)) return;
+		list.classList.add(CLASS_NAME_LIST);
 
-		const showEvent = EventHandler.trigger(this._element, EVENT_KEY_SHOW, { relatedTarget })
-		if (showEvent.defaultPrevented) return;
+		let optGroup = selector.querySelectorAll('optgroup');
 
-		if ('ontouchstart' in document.documentElement) {
-			for (const element of [].concat(...document.body.children)) {
-				EventHandler.on(element, 'mouseover', noop);
-			}
-		}
+		if (optGroup.length) {
+			let isSelected = false;
+			[...optGroup].forEach(function (el) {
+				let olOptGroup = document.createElement('ol');
+				olOptGroup.classList.add(CLASS_NAME_OPTGROUP);
 
-		this._element.classList.add(CLASS_NAME_SHOW);
+				let liLabel = document.createElement('li');
+				liLabel.innerHTML = el.label.trim();
+				liLabel.classList.add(CLASS_NAME_OPTGROUP_TITLE)
 
-		const completeCallBack = () => {
-			this._element.classList.add(CLASS_NAME_ACTIVE);
-			EventHandler.trigger(this._element, EVENT_KEY_SHOWN, { relatedTarget });
+				olOptGroup.prepend(liLabel)
+
+				let optGroupOptions = Selectors.findAll('option', el);
+
+				createLi(optGroupOptions, olOptGroup, isSelected);
+
+				list.append(olOptGroup);
+				isSelected = true;
+			});
+		} else {
+			let isSelected = false;
+			createLi(options, list, isSelected);
 		}
 
-		this._queueCallback(completeCallBack, this._drop, true, 50)
-	}
+		drop.append(list);
 
-	hide() {
-		if (isDisabled(this._element) || !this._isShown()) return;
+		return list;
 
-		this._completeHide();
-	}
+		function createLi(options, list, isSelected) {
+			let i = 0;
+			for (const option of options) {
+				let li = document.createElement('li');
 
-	_completeHide() {
-		const hideEvent = EventHandler.trigger(this._element, EVENT_KEY_HIDE, {})
-		if (hideEvent.defaultPrevented) return;
+				li.innerHTML = option.innerHTML.trim().replace(/<\/[^>]+(>|$)/g, "")
+				li.dataset.value = Manipulator.get(option, 'value');
+				li.classList.add(CLASS_NAME_OPTION);
 
-		this._element.classList.remove(CLASS_NAME_ACTIVE);
-		//this._element.setAttribute('aria-expanded', 'false');
+				Manipulator.set(li, 'data-vg-toggle', 'select-option');
 
-		if ('ontouchstart' in document.documentElement) {
-			for (const element of [].concat(...document.body.children)) {
-				EventHandler.off(element, 'mouseover', noop);
-			}
-		}
+				let liData = Manipulator.get(option);
+				if (!isEmptyObj(liData)) {
+					for (const key of Object.keys(liData)) {
+						Manipulator.set(li, 'data-' + key, liData[key]);
+					}
+				}
 
-		const completeCallback = () => {
-			this._element.classList.remove(CLASS_NAME_SHOW);
-			EventHandler.trigger(this._element, EVENT_KEY_HIDDEN, {});
-		}
-		this._queueCallback(completeCallback, this._element, true, 10);
-	}
+				if (i === selector.selectedIndex && !isSelected) {
+					li.classList.add('selected');
+				}
 
-	_isShown() {
-		return this._element.classList.contains(CLASS_NAME_SHOW);
-	}
+				if (Manipulator.has(option, 'disabled')) li.classList.add('disabled');
+				if (Manipulator.has(option, 'hidden')) li.classList.add('hidden');
 
-	build(isRebuild, elm = null) {
-		const _this = this;
-		let element = this._element;
+				list.append(li);
 
-		if (elm) element = elm;
+				i++;
+			}
+		}
+	}
 
-		if (element.dataset?.inited === 'true' && !isRebuild) {
+	static build(selector, reBuild) {
+		let option_selected,
+			placeholder = selector.dataset.placeholder || '',
+			isSearch = selector.dataset.search || false;
+
+		if (selector.dataset?.inited === 'true' && !reBuild) {
 			return;
-		} else if (isRebuild) {
-			_this.destroy(element);
+		} else if (reBuild) {
+			VGSelect.destroy(selector);
 		}
 
-		element.parentElement.style.position = 'relative';
-
-		let option_selected,
-			options = element.options;
+		selector.parentElement.style.position = 'relative';
 
-		if (_this._params.placeholder && element.selectedIndex === 0) {
-			option_selected = '<span class="'+ CLASS_NAME_PLACEHOLDER +'">' + _this._params.placeholder + '<span>';
+		if (placeholder && selector.selectedIndex === 0) {
+			option_selected = '<span class="'+ CLASS_NAME_PLACEHOLDER +'">' + placeholder + '<span>';
 		} else {
-			option_selected = element.options[element.selectedIndex].innerText;
+			option_selected = selector.options[selector.selectedIndex].innerText;
 		}
 
 		// Создаем основной элемент с классами селекта
-		let classes = Manipulator.get(element,'class'),
-			select = document.createElement('div');
+		let classes = Manipulator.get(selector,'class'),
+			element = document.createElement('div');
 
 		classes = classes.split(' ');
 
 		for (const _class of classes) {
-			select.classList.add(_class)
+			element.classList.add(_class)
 		}
 
-		if (Manipulator.has(element, 'disabled')) select.classList.add('disabled')
+		if (Manipulator.has(selector, 'disabled')) element.classList.add('disabled');
 
-		let elData = Manipulator.get(element);
+		let elData = Manipulator.get(selector);
 		if (!isEmptyObj(elData)) {
 			for (const key of Object.keys(elData)) {
-				Manipulator.set(select,'data-' + key, elData[key]);
+				Manipulator.set(element,'data-' + key, elData[key]);
 			}
 		}
 
@@ -164,109 +188,138 @@ class VGSelect extends BaseModule {
 		Manipulator.set(current, 'data-vg-toggle', 'select');
 		Manipulator.set(current, 'aria-expanded', 'false');
 		current.innerHTML = option_selected.trim();
-		select.append(current);
+		element.append(current);
 
 		// Создаем элемент выпадающего списка
 		let dropdown = document.createElement('div');
 		dropdown.classList.add(CLASS_NAME_DROPDOWN);
-		select.append(dropdown);
+		element.append(dropdown);
 
 		// Создаем список и варианты селекта
-		let list = document.createElement('ul');
-		list.classList.add(CLASS_NAME_LIST);
-
-		let optGroup = element.querySelectorAll('optgroup');
-
-		if (optGroup.length) {
-			let isSelected = false;
-			[...optGroup].forEach(function (el) {
-				let olOptGroup = document.createElement('ol');
-				olOptGroup.classList.add(CLASS_NAME_OPTGROUP);
+		VGSelect.buildListOptions(selector, dropdown);
 
-				let liLabel = document.createElement('li');
-				liLabel.innerHTML = el.label.trim();
-				liLabel.classList.add(CLASS_NAME_OPTGROUP_TITLE)
+		// Добавляем все созданный контейнер после селекта
+		selector.insertAdjacentElement('afterend', element);
 
-				olOptGroup.prepend(liLabel)
+		// помечаем элемент инициализированным
+		selector.dataset.inited = 'true';
 
-				let optGroupOptions = el.querySelectorAll('option');
+		if (isSearch) {
+			let search_container = document.createElement('div');
+			search_container.classList.add(CLASS_NAME_SEARCH);
 
-				createLi(optGroupOptions, olOptGroup, isSelected);
+			let input = document.createElement('input');
+			Manipulator.set(input, 'name', 'vg-select-search');
+			Manipulator.set(input, 'type', 'text');
+			Manipulator.set(input, 'placeholder', 'Поиск...');
 
-				list.append(olOptGroup);
-				isSelected = true;
-			});
-		} else {
-			let isSelected = false;
-			createLi(options, list, isSelected);
+			search_container.append(input);
+			dropdown.prepend(search_container);
 		}
 
-		function createLi(options, list, isSelected) {
-			let i = 0;
-			for (const option of options) {
-				let li = document.createElement('li');
+		return element;
+	}
 
-				li.innerHTML = option.innerHTML.trim().replace(/<\/[^>]+(>|$)/g, "")
-				li.dataset.value = Manipulator.get(option, 'value');
-				li.classList.add(CLASS_NAME_OPTION);
+	render(selector, callback) {
+		let list = Selectors.find('.' + CLASS_NAME_LIST, this._drop);
+		if (list) list.remove();
 
-				let liData = Manipulator.get(option);
-				if (!isEmptyObj(liData)) {
-					for (const key of Object.keys(liData)) {
-						Manipulator.set(li, 'data-' + key, liData[key]);
-					}
-				}
+		VGSelect.buildListOptions(selector, this._drop);
 
-				if (i === element.selectedIndex && !isSelected) {
-					li.classList.add('selected');
-				}
+		execute(callback, [this, selector]);
+	}
 
-				if (Manipulator.has(option, 'disabled')) li.classList.add('disabled');
-				if (Manipulator.has(option, 'hidden')) li.classList.add('hidden');
+	toggle(relatedTarget) {
+		return !this._isShown() ? this.show(relatedTarget) : this.hide();
+	}
 
-				list.append(li);
+	show(relatedTarget) {
+		if (isDisabled(this._element)) return;
 
-				i++;
+		const showEvent = EventHandler.trigger(this._element, EVENT_KEY_SHOW, { relatedTarget })
+		if (showEvent.defaultPrevented) return;
+
+		if ('ontouchstart' in document.documentElement) {
+			for (const element of [].concat(...document.body.children)) {
+				EventHandler.on(element, 'mouseover', noop);
 			}
 		}
 
-		dropdown.append(list);
+		// TODO доделать
+		/*this._route((status, data) => {
+			let response = normalizeData(data.response),
+				select = this._element.previousSibling;
 
-		// Добавляем все созданный контейнер после селекта
-		element.insertAdjacentElement('afterend', select);
+			if (response.length) {
+				Selectors.findAll('option', select).forEach(option => {
+					option.remove();
+				});
 
-		// помечаем элемент инициализированным
-		element.dataset.inited = 'true';
+				response.forEach(el => {
+					let option = document.createElement('option');
+					option.innerText = el.title;
+					Manipulator.set(option, 'value', el.id);
+
+					select.append(option);
+				});
+
+				this.render(select);
+			}
+		});*/
+
+		this._element.classList.add(CLASS_NAME_SHOW);
 
-		if (_this._params.search) {
-			this.search(select);
+		if (this._params.search) {
+			let input = Selectors.find('input', this._element);
+			if (input) input.focus();
 		}
+
+		const completeCallBack = () => {
+			this._element.classList.add(CLASS_NAME_ACTIVE);
+			EventHandler.trigger(this._element, EVENT_KEY_SHOWN, { relatedTarget });
+		}
+
+		this._queueCallback(completeCallBack, this._drop, true, 50)
 	}
 
-	destroy(select) {
-		let element = select.nextElementSibling;
+	hide() {
+		if (isDisabled(this._element) || !this._isShown()) return;
 
-		if (element) {
-			if (element.classList.contains(CLASS_NAME_CONTAINER)) {
-				element.remove();
+		this._completeHide();
+	}
 
-				select.selectedIndex = 0;
-				[...select.querySelectorAll('option')].forEach(function (el, index) {
-					if (el.hasAttribute('selected')) {
-						select.selectedIndex = index;
-					}
-				});
+	_completeHide() {
+		const hideEvent = EventHandler.trigger(this._element, EVENT_KEY_HIDE, {})
+		if (hideEvent.defaultPrevented) return;
+
+		this._element.classList.remove(CLASS_NAME_ACTIVE);
+		let toggle = Selectors.find(SELECTOR_DATA_TOGGLE, this._element);
+		Manipulator.set(toggle, 'aria-expanded', 'false');
+
+		if ('ontouchstart' in document.documentElement) {
+			for (const element of [].concat(...document.body.children)) {
+				EventHandler.off(element, 'mouseover', noop);
 			}
 		}
+
+		const completeCallback = () => {
+			this._element.classList.remove(CLASS_NAME_SHOW);
+			EventHandler.trigger(this._element, EVENT_KEY_HIDDEN, {});
+		}
+		this._queueCallback(completeCallback, this._element, true, 10);
+	}
+
+	_isShown() {
+		return this._element.classList.contains(CLASS_NAME_SHOW);
 	}
 
-	refresh(select) {
-		const _this = this;
+	refresh() {
+		const select = this._element.previousSibling;
 
 		let observer = new MutationObserver(() => {
 			clearTimeout(observerTimout);
 			observerTimout = setTimeout(() => {
-				_this.build(true, select);
+				VGSelect.build(select, true);
 			}, 100);
 		});
 
@@ -279,131 +332,62 @@ class VGSelect extends BaseModule {
 	}
 
 	search(select) {
-		let dropdown = select.querySelector('.' + CLASS_NAME_DROPDOWN);
-
-		let search_container = document.createElement('div');
-		search_container.classList.add(CLASS_NAME_SEARCH);
-
-		let input = document.createElement('input');
-		input.setAttribute('name', 'vg-select-search');
-		input.setAttribute('type', 'text');
-		input.setAttribute('placeholder', 'Поиск...');
-
-		search_container.append(input);
-		dropdown.prepend(search_container);
-
-		search_container.querySelector('[name=vg-select-search]').addEventListener('keyup', (e) => {
-			e.preventDefault();
-
-			let el = e.target;
-
-			let selectList = el?.closest('.' + CLASS_NAME_DROPDOWN).querySelector('.' + CLASS_NAME_LIST);
-			if (selectList) {
-				let options = [...selectList.querySelectorAll('.' + CLASS_NAME_OPTION)],
-					optionsGroup = [...selectList.querySelectorAll('.' + CLASS_NAME_OPTGROUP)],
-					value = el?.value;
-
-				options = options.concat(optionsGroup);
-
-				for (const option of options) {
-					Manipulator.show(option);
-				}
-
-				if (value.length) {
-					value = value.trim();
-					value = value.toLowerCase();
-					value = transliterate(value, true);
-
-					for (const option of options) {
-						let text = option.innerText.toLowerCase();
 
-						if (text.indexOf(value) === -1) Manipulator.hide(option);
-					}
-				}
-			}
-		});
 	}
 
 	dispose() {
 		super.dispose();
 	}
 
-	_addEventListeners(select) {
-		const _this = this;
+	static destroy(select) {
+		let element = select.nextElementSibling;
 
-		select.querySelector('.' + CLASS_NAME_CURRENT).onclick = function (e) {
-			let el = e.target,
-				container = el.closest('.' + CLASS_NAME_CONTAINER);
+		if (element) {
+			if (element.classList.contains(CLASS_NAME_CONTAINER)) {
+				element.remove();
 
-			let selects = document.querySelectorAll('.' + CLASS_NAME_CONTAINER);
-			if (selects.length) {
-				for (const els of selects) {
-					if (els !== container) {
-						els?.classList.remove('show');
+				select.selectedIndex = 0;
+				[...select.querySelectorAll('option')].forEach(function (el, index) {
+					if (el.hasAttribute('selected')) {
+						select.selectedIndex = index;
 					}
-				}
-			}
-
-			if (container.classList.contains('show')) {
-				container.classList.remove('show');
-			} else {
-				container.classList.add('show');
-
-				if (_this._params.search) {
-					let input = container.querySelector('input');
-					if (input) input.focus();
-				}
+				});
 			}
-
-			return false;
 		}
+	}
 
-		select.querySelectorAll('.' + CLASS_NAME_OPTION).forEach((option) => {
-			option.addEventListener('click', (e) => {
-				e.preventDefault();
+	static hideOpenToggles(event) {
+		const openToggles = Selectors.findAll('.vg-select:not(.disabled):not(:disabled).show');
 
-				let el = e.target;
+		for (const toggle of openToggles) {
+			const context = VGSelect.getInstance(toggle);
+			if (!context) continue;
 
-				if (!el.classList.contains('disabled')) {
-					let container = el.closest('.' + CLASS_NAME_CONTAINER),
-						options = container.querySelectorAll('.' + CLASS_NAME_OPTION);
+			if (event.target.closest('.' + CLASS_NAME_CONTAINER) === context._element) {
+				return;
+			}
 
-					if (options.length) {
-						for (const option of options) {
-							option.classList.remove('selected');
-						}
-					}
+			const composedPath = event.composedPath();
+			if (composedPath.includes(context._element)) {
+				continue
+			}
 
-					el.classList.add('selected');
+			const relatedTarget = { relatedTarget: context._element }
 
-					container.querySelector('.' + CLASS_NAME_CURRENT).innerText = el.innerText;
-					container.classList.remove('show');
+			if (event.type === 'click') {
+				relatedTarget.clickEvent = event
+			}
 
-					let select = container.previousSibling;
-					select.value = el.dataset.value;
-					EventHandler.trigger(select, EVENT_KEY_CHANGE)
-				}
-			});
-		});
+			context._completeHide(relatedTarget)
+		}
+	}
 
-		window.addEventListener('click', function (e) {
-			if (!e?.target.closest('.' + CLASS_NAME_CONTAINER)) {
-				let selects = document.querySelectorAll('.' + CLASS_NAME_CONTAINER);
-				if (selects.length) {
-					for (const el of selects) {
-						el?.classList.remove('show');
-					}
-				}
-			}
-		});
+	static clearDrops(event) {
+		if (event.button === 2 || (event.type === 'keyup' && event.key !== 'Tab')) {
+			return
+		}
 
-		[...document.querySelectorAll('form')].forEach(function (form) {
-			form.addEventListener("reset", function () {
-				form.querySelectorAll('select.vg-select').forEach(function (select) {
-					VGSelect.init(select, {}, true)
-				})
-			});
-		});
+		VGSelect.hideOpenToggles(event)
 	}
 
 	/**
@@ -413,20 +397,18 @@ class VGSelect extends BaseModule {
 	 * @param isRebuild
 	 */
 	static init(element, params = {}, isRebuild = false) {
-		const instance = VGSelect.getOrCreateInstance(element, params);
-		instance.build(isRebuild);
+		let elm = VGSelect.build(element);
+		VGSelect.getOrCreateInstance(elm, params);
 	}
 }
 
+EventHandler.on(document, EVENT_KEY_CLICK_DATA_API, VGSelect.clearDrops);
+
 EventHandler.on(document, EVENT_KEY_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function () {
 	const target = this.closest('.' + CLASS_NAME_CONTAINER);
 
 	Manipulator.set(this, 'aria-expanded', true);
 
-	EventHandler.one(target, EVENT_KEY_HIDDEN, () => {
-		Manipulator.set(this, 'aria-expanded', false);
-	})
-
 	const alreadyOpen = Selectors.find('.vg-select.show')
 	if (alreadyOpen && alreadyOpen !== target) {
 		VGSelect.getInstance(alreadyOpen).hide();
@@ -436,5 +418,59 @@ EventHandler.on(document, EVENT_KEY_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, functi
 	instance.toggle(this);
 });
 
+EventHandler.on(document, EVENT_KEY_CLICK_DATA_API, SELECTOR_OPTION_TOGGLE, function (e) {
+	let el = e.target;
+
+	if (!el.classList.contains('disabled')) {
+		let container = el.closest('.' + CLASS_NAME_CONTAINER),
+			options = container.querySelectorAll('.' + CLASS_NAME_OPTION);
+
+		if (options.length) {
+			for (const option of options) {
+				option.classList.remove('selected');
+			}
+		}
+
+		el.classList.add('selected');
+
+		container.querySelector('.' + CLASS_NAME_CURRENT).innerText = el.innerText;
+		container.classList.remove('show');
+
+		let select = container.previousSibling;
+		select.value = el.dataset.value;
+		EventHandler.trigger(select, EVENT_KEY_CHANGE, {value: normalizeData(el.dataset.value)});
+		EventHandler.trigger(select, 'change', {value: normalizeData(el.dataset.value)});
+	}
+});
+
+EventHandler.on(document, EVENT_KEY_UP_DATA_API, SELECTOR_SEARCH_TOGGLE, function (e) {
+	let el = this;
+
+	let selectList = el?.closest('.' + CLASS_NAME_DROPDOWN).querySelector('.' + CLASS_NAME_LIST);
+	if (selectList) {
+		let options = [...selectList.querySelectorAll('.' + CLASS_NAME_OPTION)],
+			optionsGroup = [...selectList.querySelectorAll('.' + CLASS_NAME_OPTGROUP)],
+			value = el?.value;
+
+		options = options.concat(optionsGroup);
+
+		for (const option of options) {
+			Manipulator.show(option);
+		}
+
+		if (value.length) {
+			value = value.trim();
+			value = value.toLowerCase();
+			value = transliterate(value, true);
+
+			for (const option of options) {
+				let text = option.innerText.toLowerCase();
+
+				if (text.indexOf(value) === -1) Manipulator.hide(option);
+			}
+		}
+	}
+});
+
 
 export default VGSelect;