diff --git a/development/issues/closed/287.html b/development/issues/closed/287.html
new file mode 100644
index 0000000000000000000000000000000000000000..31861655d99da8a73228762e2d8380a8861c1619
--- /dev/null
+++ b/development/issues/closed/287.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="UTF-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <title>The null values should be deinable in the select #287</title>
+ <script src="./287.mjs" type="module"></script>
+</head>
+<body>
+<h1>The null values should be deinable in the select #287</h1>
+<p></p>
+<ul>
+ <li><a href="https://gitlab.schukai.com/oss/libraries/javascript/monster/-/issues/287">Issue #287</a></li>
+ <li><a href="/">Back to overview</a></li>
+</ul>
+<main>
+
+ <monster-datasource-rest id="ds224" data-monster-option-read-url="/issue-287.json"
+ data-monster-option-write-url="/issue-287"
+ data-monster-option-write-acceptedstatus="400::200"
+ data-monster-option-features-autoinit="true">
+ </monster-datasource-rest>
+
+ <monster-form data-monster-option-datasource-selector="#ds224" data-monster-option-mapping-data=""
+ data-monster-option-features-mutationobserver="false">
+
+ <div data-monster-replace="path:data | tojson"></div>
+
+ <monster-select data-monster-attributes="value path:data.integer"
+ data-monster-option-type="checkbox"
+ data-monster-bind="path:data.integer"
+ data-monster-bind-type="int[]"
+ >
+ <div data-monster-value="1">label-1</div>
+ <div data-monster-value="2">label-2</div>
+ <div data-monster-value="3">label-3</div>
+ </monster-select>
+
+ </monster-form>
+</main>
+</body>
+</html>
diff --git a/development/issues/closed/287.mjs b/development/issues/closed/287.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..6c3d6ac123c3b2f0197571d5010d898555e41383
--- /dev/null
+++ b/development/issues/closed/287.mjs
@@ -0,0 +1,21 @@
+/**
+* @file development/issues/open/287.mjs
+* @url https://gitlab.schukai.com/oss/libraries/javascript/monster/-/issues/287
+* @description The null values should be deinable in the select
+* @issue 287
+*/
+
+import "../../../source/components/style/property.pcss";
+import "../../../source/components/style/link.pcss";
+import "../../../source/components/style/color.pcss";
+import "../../../source/components/style/theme.pcss";
+import "../../../source/components/style/normalize.pcss";
+import "../../../source/components/style/typography.pcss";
+
+
+import "../../../source/components/form/select.mjs";
+import "../../../source/components/form/field-set.mjs";
+import "../../../source/components/form/button.mjs";
+import "../../../source/components/form/form.mjs";
+import "../../../source/components/form/button-bar.mjs";
+import "../../../source/components/datatable/datasource/rest.mjs";
diff --git a/development/mock/issue-287.js b/development/mock/issue-287.js
new file mode 100644
index 0000000000000000000000000000000000000000..3cc2683fc0aaa54853903c1f1de30cbffe25972d
--- /dev/null
+++ b/development/mock/issue-287.js
@@ -0,0 +1,70 @@
+const json =
+ `[
+ {
+ "id": 1000,
+ "name": "name 1",
+ "integer": 2,
+ "float": 1.1,
+ "boolean": true
+ }
+ ]`;
+
+
+// check if json is valid
+JSON.parse(json)
+
+const json400Error=`[
+ {
+ "sys": {
+ "type": "Error",
+ "message": "Invalid request"
+ }
+ }
+ ]`
+
+// check if json is valid
+JSON.parse(json400Error)
+
+
+const json200Error=`[
+ {
+ "sys": {
+ "type": "Error",
+ "message": "Invalid request"
+ }
+ }
+ ]`
+
+JSON.parse(json200Error)
+
+
+const requestDelay = 100
+
+export default [
+ {
+ url: '/issue-287.json',
+ method: 'get',
+ rawResponse: async (req, res) => {
+ res.setHeader('Content-Type', 'application/json')
+ res.statusCode = 200
+
+ setTimeout(function() {
+ res.end(json)
+ }, requestDelay);
+ },
+ },
+
+ {
+ url: '/issue-287',
+ method: 'post',
+ rawResponse: async (req, res) => {
+ res.setHeader('Content-Type', 'application/json')
+ res.statusCode = 400
+
+ setTimeout(function() {
+ res.end(json400Error)
+ }, requestDelay);
+ }
+ }
+
+];
\ No newline at end of file
diff --git a/source/components/form/select.mjs b/source/components/form/select.mjs
index 732c823412ee5afe98226db1aed1a0d35a8811a8..993d29a52e6cbe85ad1b61240b5f80d8e6b01678 100644
--- a/source/components/form/select.mjs
+++ b/source/components/form/select.mjs
@@ -12,59 +12,59 @@
* SPDX-License-Identifier: AGPL-3.0
*/
-import { instanceSymbol } from "../../constants.mjs";
-import { internalSymbol } from "../../constants.mjs";
-import { buildMap } from "../../data/buildmap.mjs";
-import { DeadMansSwitch } from "../../util/deadmansswitch.mjs";
-import { positionPopper } from "./util/floating-ui.mjs";
+import {instanceSymbol} from "../../constants.mjs";
+import {internalSymbol} from "../../constants.mjs";
+import {buildMap} from "../../data/buildmap.mjs";
+import {DeadMansSwitch} from "../../util/deadmansswitch.mjs";
+import {positionPopper} from "./util/floating-ui.mjs";
import {
- addAttributeToken,
- findClosestByAttribute,
- removeAttributeToken,
+ addAttributeToken,
+ findClosestByAttribute,
+ removeAttributeToken,
} from "../../dom/attributes.mjs";
-import { ATTRIBUTE_PREFIX, ATTRIBUTE_ROLE } from "../../dom/constants.mjs";
-import { CustomControl } from "../../dom/customcontrol.mjs";
+import {ATTRIBUTE_PREFIX, ATTRIBUTE_ROLE} from "../../dom/constants.mjs";
+import {CustomControl} from "../../dom/customcontrol.mjs";
import {
- assembleMethodSymbol,
- getSlottedElements,
- registerCustomElement,
+ assembleMethodSymbol,
+ getSlottedElements,
+ registerCustomElement,
} from "../../dom/customelement.mjs";
import {
- findTargetElementFromEvent,
- fireCustomEvent,
- fireEvent,
+ findTargetElementFromEvent,
+ fireCustomEvent,
+ fireEvent,
} from "../../dom/events.mjs";
-import { getDocument } from "../../dom/util.mjs";
-import { Formatter } from "../../text/formatter.mjs";
-import { getGlobal } from "../../types/global.mjs";
-import { ID } from "../../types/id.mjs";
+import {getDocument} from "../../dom/util.mjs";
+import {Formatter} from "../../text/formatter.mjs";
+import {getGlobal} from "../../types/global.mjs";
+import {ID} from "../../types/id.mjs";
import {
- isArray,
- isFunction,
- isInteger,
- isIterable,
- isObject,
- isPrimitive,
- isString,
+ isArray,
+ isFunction,
+ isInteger,
+ isIterable,
+ isObject,
+ isPrimitive,
+ isString,
} from "../../types/is.mjs";
-import { Observer } from "../../types/observer.mjs";
-import { ProxyObserver } from "../../types/proxyobserver.mjs";
-import { validateArray, validateString } from "../../types/validate.mjs";
-import { Processing } from "../../util/processing.mjs";
-import { STYLE_DISPLAY_MODE_BLOCK } from "./constants.mjs";
-import { SelectStyleSheet } from "./stylesheet/select.mjs";
+import {Observer} from "../../types/observer.mjs";
+import {ProxyObserver} from "../../types/proxyobserver.mjs";
+import {validateArray, validateString} from "../../types/validate.mjs";
+import {Processing} from "../../util/processing.mjs";
+import {STYLE_DISPLAY_MODE_BLOCK} from "./constants.mjs";
+import {SelectStyleSheet} from "./stylesheet/select.mjs";
import {
- getDocumentTranslations,
- Translations,
+ getDocumentTranslations,
+ Translations,
} from "../../i18n/translations.mjs";
-import { getLocaleOfDocument } from "../../dom/locale.mjs";
-import { addErrorAttribute, removeErrorAttribute } from "../../dom/error.mjs";
+import {getLocaleOfDocument} from "../../dom/locale.mjs";
+import {addErrorAttribute, removeErrorAttribute} from "../../dom/error.mjs";
export {
- Select,
- popperElementSymbol,
- getSummaryTemplate,
- getSelectionTemplate,
+ Select,
+ popperElementSymbol,
+ getSummaryTemplate,
+ getSelectionTemplate,
};
/**
@@ -185,7 +185,7 @@ const popperFilterElementSymbol = Symbol("popperFilterElement");
* @type {Symbol}
*/
const popperFilterContainerElementSymbol = Symbol(
- "popperFilterContainerElement",
+ "popperFilterContainerElement",
);
/**
@@ -264,9 +264,8 @@ const FILTER_POSITION_INLINE = "inline";
/**
* A select control that can be used to select o
*
- * ne or more options from a list.
- *
* @issue @issue https://localhost.alvine.dev:8444/development/issues/closed/280.html
+ * @issue @issue https://localhost.alvine.dev:8444/development/issues/closed/287.html
*
* @fragments /fragments/components/form/select/
*
@@ -284,482 +283,497 @@ const FILTER_POSITION_INLINE = "inline";
* @fires monster-changed
*/
class Select extends CustomControl {
- /**
- *
- */
- constructor() {
- super();
- initOptionObserver.call(this);
- }
-
- /**
- * This method is called by the `instanceof` operator.
- * @return {Symbol}
- */
- static get [instanceSymbol]() {
- return Symbol.for("@schukai/monster/components/form/select@@instance");
- }
-
- /**
- * The current selection of the Select
- *
- * ```
- * e = document.querySelector('monster-select');
- * console.log(e.value)
- * // ↦ 1
- * // ↦ ['1','2']
- * ```
- *
- * @return {string}
- */
- get value() {
- return convertSelectionToValue.call(this, this.getOption("selection"));
- }
-
- /**
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/attachInternals}
- * @return {boolean}
- */
- static get formAssociated() {
- return true;
- }
-
- /**
- * Set selection
- *
- * ```
- * e = document.querySelector('monster-select');
- * e.value=1
- * ```
- *
- * @property {string|array} value
- * @throws {Error} unsupported type
- * @fires monster-selected this event is fired when the selection is set
- */
- set value(value) {
- const result = convertValueToSelection.call(this, value);
- setSelection
- .call(this, result.selection)
- .then(() => {})
- .catch((e) => {
- addErrorAttribute(this, e);
- });
- }
-
- /**
- * To set the options via the HTML tag, the attribute `data-monster-options` must be used.
- * @see {@link https://monsterjs.org/en/doc/#configurate-a-monster-control}
- *
- * The individual configuration values can be found in the table.
- *
- * @property {Object} toggleEventType List of event types to be observed for opening the dropdown
- * @property {boolean} delegatesFocus lorem [see mozilla.org](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot/delegatesFocus)
- * @property {Object[]} options Selection of key identifier pairs available for selection and displayed in the dropdown.
- * @property {string} options[].label
- * @property {string} options[].value
- * @property {string} options[].visibility hidden or visible
- * @property {Array} selection Selected options
- * @property {Integer} showMaxOptions Maximum number of visible options before a scroll bar should be displayed.
- * @property {string} type Multiple (checkbox) or single selection (radio)
- * @property {string} name Name of the form field
- * @property {string} url Load options from server per url
- * @property {object} lookup Load options from server per url
- * @property {string} lookup.url Load options from server per url
- * @property {boolean} lookup.grouping Load all selected options from server per url at once (true) or one by one (false)
- * @property {Object} fetch Fetch [see Using Fetch mozilla.org](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch)
- * @property {String} fetch.redirect
- * @property {String} fetch.method
- * @property {String} fetch.mode
- * @property {String} fetch.credentials
- * @property {Object} fetch.headers
- * @property {Object} labels
- * @property {string} labels.cannot-be-loaded cannot be loaded
- * @property {string} labels.no-options-available no options available
- * @property {string} labels.select-an-option select an option
- * @property {string} labels.no-option no option in the list, maybe you have to change the filter
- * @property {Object} features List with features
- * @property {Boolean} features.clearAll Display of a delete button to delete the entire selection
- * @property {Boolean} features.clear Display of a delete key for deleting the specific selection
- * @property {Boolean} features.lazyLoad Load options when first opening the dropdown. (Hint; lazylLoad is not supported with remote filter)
- * @property {Boolean} features.closeOnSelect Close the dropdown when an option is selected (since 3.54.0)
- * @property {Boolean} features.emptyValueIfNoOptions If no options are available, the selection is set to an empty array
- * @property {Boolean} features.storeFetchedData Store fetched data in the object
- * @property {Boolean} features.useStrictValueComparison Use strict value comparison for the selection
- * @property {string} filter.defaultValue Default filter value, if the filter is empty, if the default value is null, then no request is made
- * @property {Boolean} filter.mode Filter mode, values: options, remote, disabled (Hint; lazylLoad is not supported with remote filter, if you use remote filter, the lazyLoad is disabled)
- * @property {Object} templates Template definitions
- * @property {string} templates.main Main template
- * @property {string} templateMapping Mapping of the template placeholders
- * @property {string} templateMapping.selected Selected Template
- * @property {Object} popper [PopperJS Options](https://popper.js.org/docs/v2/)
- * @property {string} popper.placement PopperJS placement
- * @property {Object[]} modifiers PopperJS placement
- * @property {Object} mapping
- * @property {String} mapping.selector Path to select the appropriate entries
- * @property {String} mapping.labelTemplate template with the label placeholders in the form ${name}, where name is the key (**)
- * @property {String} mapping.valueTemplate template with the value placeholders in the form ${name}, where name is the key
- * @property {function|undefined} mapping.filter Filtering of values via a function
- * @property {Array} mapping.ignoreValues Ignore values by importing
- * @property {Object} formatter
- * @property {function|undefined} formatter.selection format selection label
- */
- get defaults() {
- return Object.assign(
- {},
- super.defaults,
- {
- toggleEventType: ["click", "touch"],
- delegatesFocus: false,
- options: [],
- selection: [],
- showMaxOptions: 10,
- type: "radio",
- name: new ID("s").toString(),
- features: {
- clearAll: true,
- clear: true,
- lazyLoad: false,
- closeOnSelect: false,
- emptyValueIfNoOptions: false,
- storeFetchedData: false,
- useStrictValueComparison: false,
- },
- url: null,
- lookup: {
- url: null,
- grouping: false,
- },
- labels: getTranslations(),
- messages: {
- control: null,
- selected: null,
- emptyOptions: null,
- },
- fetch: {
- redirect: "error",
- method: "GET",
- mode: "same-origin",
- credentials: "same-origin",
- headers: {
- accept: "application/json",
- },
- },
- filter: {
- defaultValue: null,
- mode: FILTER_MODE_DISABLED,
- position: FILTER_POSITION_INLINE,
- marker: {
- open: "{",
- close: "}",
- },
- },
- classes: {
- badge: "monster-badge-primary",
- statusOrRemoveBadge: "empty",
- },
- mapping: {
- selector: "*",
- labelTemplate: "",
- valueTemplate: "",
- filter: null,
- ignoreValues: ["0", 0, undefined, null],
- },
- formatter: {
- selection: buildSelectionLabel,
- },
- templates: {
- main: getTemplate(),
- },
- templateMapping: {
- /** with the attribute `data-monster-selected-template` the template for the selected options can be defined. */
- selected: getSelectionTemplate(),
- },
-
- popper: {
- placement: "bottom",
- middleware: ["flip", "offset:1"],
- },
- },
- initOptionsFromArguments.call(this),
- );
- }
-
- /**
- * @return {Select}
- */
- [assembleMethodSymbol]() {
- const self = this;
- super[assembleMethodSymbol]();
-
- initControlReferences.call(self);
- initEventHandler.call(self);
-
- let lazyLoadFlag = self.getOption("features.lazyLoad", false);
- let remoteFilterFlag = getFilterMode.call(this) === FILTER_MODE_REMOTE;
-
- if (getFilterMode.call(this) === FILTER_MODE_REMOTE) {
- self.getOption("features.lazyLoad", false);
- if (lazyLoadFlag === true) {
- addErrorAttribute(this, "lazyLoad is not supported with remote filter");
- lazyLoadFlag = false;
- }
- }
-
- if (self.hasAttribute("value")) {
- new Processing(10, () => {
- this.value = this.getAttribute("value");
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
- }
-
- if (self.getOption("url") !== null) {
- if (lazyLoadFlag || remoteFilterFlag) {
- lookupSelection.call(self);
- } else {
- self.fetch().catch((e) => {
- addErrorAttribute(self, e);
- });
- }
- }
-
- requestAnimationFrame(() => {
- let lastValue = self.value;
- self[internalSymbol].attachObserver(
- new Observer(function () {
- if (isObject(this) && this instanceof ProxyObserver) {
- const n = this.getSubject()?.options?.value;
-
- if (lastValue !== n && n !== undefined) {
- lastValue = n;
- setSelection
- .call(self, n)
- .then(() => {})
- .catch((e) => {
- addErrorAttribute(self, e);
- });
- }
- }
- }),
- );
-
- areOptionsAvailableAndInit.call(self);
- });
-
- return this;
- }
-
- /**
- *
- * @return {*}
- * @throws {Error} storeFetchedData is not enabled
- * @since 3.66.0
- */
- getLastFetchedData() {
- if (this.getOption("features.storeFetchedData") === false) {
- throw new Error("storeFetchedData is not enabled");
- }
-
- return this?.[lastFetchedDataSymbol];
- }
-
- /**
- * The Button.click() method simulates a click on the internal button element.
- *
- * @since 3.27.0
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click}
- */
- click() {
- if (this.getOption("disabled") === true) {
- return;
- }
-
- toggle.call(this);
- }
-
- /**
- * The Button.focus() method sets focus on the internal button element.
- *
- * @since 3.27.0
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus}
- */
- focus(options) {
- if (this.getOption("disabled") === true) {
- return;
- }
-
- new Processing(() => {
- gatherState.call(this);
- focusFilter.call(this, options);
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
- }
-
- /**
- * The Button.blur() method removes focus from the internal button element.
- * @link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/blur
- */
- blur() {
- new Processing(() => {
- gatherState.call(this);
- blurFilter.call(this);
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
- }
-
- /**
- * If no url is specified, the options are taken from the Component itself.
- *
- * @param {string|URL} url URL to fetch the options
- * @return {Promise}
- */
- fetch(url) {
- return fetchIt.call(this, url);
- }
-
- /**
- * @return {void}
- */
- connectedCallback() {
- super.connectedCallback();
- const document = getDocument();
-
- for (const [, type] of Object.entries(["click", "touch"])) {
- // close on outside ui-events
- document.addEventListener(type, this[closeEventHandler]);
- }
-
- parseSlotsToOptions.call(this);
- attachResizeObserver.call(this);
- updatePopper.call(this);
-
- new Processing(() => {
- gatherState.call(this);
- focusFilter.call(this);
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
- }
-
- /**
- * @return {void}
- */
- disconnectedCallback() {
- super.disconnectedCallback();
- const document = getDocument();
-
- // close on outside ui-events
- for (const [, type] of Object.entries(["click", "touch"])) {
- document.removeEventListener(type, this[closeEventHandler]);
- }
-
- disconnectResizeObserver.call(this);
- }
-
- /**
- * Import Select Options from dataset
- * Not to be confused with the control defaults/options
- *
- * @param {array|object|Map|Set} data
- * @return {Select}
- * @throws {Error} map is not iterable
- * @throws {Error} missing label configuration
- * @fires monster-options-set this event is fired when the options are set
- */
- importOptions(data) {
- const mappingOptions = this.getOption("mapping", {});
- const selector = mappingOptions?.["selector"];
- const labelTemplate = mappingOptions?.["labelTemplate"];
- const valueTemplate = mappingOptions?.["valueTemplate"];
- const filter = mappingOptions?.["filter"];
-
- let flag = false;
- if (labelTemplate === "") {
- addErrorAttribute(this, "empty label template");
- flag = true;
- }
-
- if (valueTemplate === "") {
- addErrorAttribute(this, "empty value template");
- flag = true;
- }
-
- if (flag === true) {
- throw new Error("missing label configuration");
- }
-
- const map = buildMap(data, selector, labelTemplate, valueTemplate, filter);
-
- const options = [];
-
- if (!isIterable(map)) {
- throw new Error("map is not iterable");
- }
-
- const visibility = "visible";
-
- map.forEach((label, value) => {
- options.push({
- value,
- label,
- visibility,
- data: map.get(value),
- });
- });
-
- runAsOptionLengthChanged.call(this, map.size);
- this.setOption("options", options);
-
- fireCustomEvent(this, "monster-options-set", {
- options,
- });
-
- setTimeout(() => {
- setSelection
- .call(this, this.getOption("selection"))
- .then(() => {})
- .catch((e) => {
- addErrorAttribute(this, e);
- });
- }, 10);
-
- return this;
- }
-
- /**
- * @private
- * @return {Select}
- */
- calcAndSetOptionsDimension() {
- calcAndSetOptionsDimension.call(this);
- return this;
- }
-
- /**
- *
- * @return {string}
- */
- static getTag() {
- return "monster-select";
- }
-
- /**
- *
- * @return {CSSStyleSheet[]}
- */
- static getCSSStyleSheet() {
- return [SelectStyleSheet];
- }
+ /**
+ *
+ */
+ constructor() {
+ super();
+ initOptionObserver.call(this);
+ }
+
+ /**
+ * This method is called by the `instanceof` operator.
+ * @return {Symbol}
+ */
+ static get [instanceSymbol]() {
+ return Symbol.for("@schukai/monster/components/form/select@@instance");
+ }
+
+ /**
+ * The current selection of the Select
+ *
+ * ```
+ * e = document.querySelector('monster-select');
+ * console.log(e.value)
+ * // ↦ 1
+ * // ↦ ['1','2']
+ * ```
+ *
+ * @return {string}
+ */
+ get value() {
+ return convertSelectionToValue.call(this, this.getOption("selection"));
+ }
+
+ /**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/attachInternals}
+ * @return {boolean}
+ */
+ static get formAssociated() {
+ return true;
+ }
+
+ /**
+ * Set selection
+ *
+ * ```
+ * e = document.querySelector('monster-select');
+ * e.value=1
+ * ```
+ *
+ * @property {string|array} value
+ * @throws {Error} unsupported type
+ * @fires monster-selected this event is fired when the selection is set
+ */
+ set value(value) {
+
+ let ignoreValues = this.getOption("ignoreValues", []);
+ if(!isArray(ignoreValues)){
+ ignoreValues = [];
+ }
+
+ for (const v of ignoreValues) {
+ if (value === v) {
+ return;
+ }
+ }
+
+ const result = convertValueToSelection.call(this, value);
+ setSelection
+ .call(this, result.selection)
+ .then(() => {
+ })
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ }
+
+ /**
+ * To set the options via the HTML tag, the attribute `data-monster-options` must be used.
+ * @see {@link https://monsterjs.org/en/doc/#configurate-a-monster-control}
+ *
+ * The individual configuration values can be found in the table.
+ *
+ * @property {Object} toggleEventType List of event types to be observed for opening the dropdown
+ * @property {boolean} delegatesFocus lorem [see mozilla.org](https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot/delegatesFocus)
+ * @property {Object[]} options Selection of key identifier pairs available for selection and displayed in the dropdown.
+ * @property {string} options[].label
+ * @property {string} options[].value
+ * @property {string} options[].visibility hidden or visible
+ * @property {Array} selection Selected options
+ * @property {Integer} showMaxOptions Maximum number of visible options before a scroll bar should be displayed.
+ * @property {string} type Multiple (checkbox) or single selection (radio)
+ * @property {string} name Name of the form field
+ * @property {string} url Load options from server per url
+ * @property {object} lookup Load options from server per url
+ * @property {string} lookup.url Load options from server per url
+ * @property {boolean} lookup.grouping Load all selected options from server per url at once (true) or one by one (false)
+ * @property {Object} fetch Fetch [see Using Fetch mozilla.org](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch)
+ * @property {String} fetch.redirect
+ * @property {String} fetch.method
+ * @property {String} fetch.mode
+ * @property {String} fetch.credentials
+ * @property {Object} fetch.headers
+ * @property {Object} labels
+ * @property {string} labels.cannot-be-loaded cannot be loaded
+ * @property {string} labels.no-options-available no options available
+ * @property {string} labels.select-an-option select an option
+ * @property {string} labels.no-option no option in the list, maybe you have to change the filter
+ * @property {Object} features List with features
+ * @property {Boolean} features.clearAll Display of a delete button to delete the entire selection
+ * @property {Boolean} features.clear Display of a delete key for deleting the specific selection
+ * @property {Boolean} features.lazyLoad Load options when first opening the dropdown. (Hint; lazylLoad is not supported with remote filter)
+ * @property {Boolean} features.closeOnSelect Close the dropdown when an option is selected (since 3.54.0)
+ * @property {Boolean} features.emptyValueIfNoOptions If no options are available, the selection is set to an empty array
+ * @property {Boolean} features.storeFetchedData Store fetched data in the object
+ * @property {Boolean} features.useStrictValueComparison Use strict value comparison for the selection
+ * @property {string} filter.defaultValue Default filter value, if the filter is empty, if the default value is null, then no request is made
+ * @property {Boolean} filter.mode Filter mode, values: options, remote, disabled (Hint; lazylLoad is not supported with remote filter, if you use remote filter, the lazyLoad is disabled)
+ * @property {Object} templates Template definitions
+ * @property {string} templates.main Main template
+ * @property {string} templateMapping Mapping of the template placeholders
+ * @property {string} templateMapping.selected Selected Template
+ * @property {Object} popper [PopperJS Options](https://popper.js.org/docs/v2/)
+ * @property {string} popper.placement PopperJS placement
+ * @property {Object[]} modifiers PopperJS placement
+ * @property {Object} mapping
+ * @property {String} mapping.selector Path to select the appropriate entries
+ * @property {String} mapping.labelTemplate template with the label placeholders in the form ${name}, where name is the key (**)
+ * @property {String} mapping.valueTemplate template with the value placeholders in the form ${name}, where name is the key
+ * @property {function|undefined} mapping.filter Filtering of values via a function
+ * @property {Array} ignoreValues Ignore values in the selection and value
+ * @property {Object} formatter
+ * @property {function|undefined} formatter.selection format selection label
+ */
+ get defaults() {
+ return Object.assign(
+ {},
+ super.defaults,
+ {
+ toggleEventType: ["click", "touch"],
+ delegatesFocus: false,
+ options: [],
+ selection: [],
+ showMaxOptions: 10,
+ type: "radio",
+ name: new ID("s").toString(),
+ features: {
+ clearAll: true,
+ clear: true,
+ lazyLoad: false,
+ closeOnSelect: false,
+ emptyValueIfNoOptions: false,
+ storeFetchedData: false,
+ useStrictValueComparison: false
+ },
+ url: null,
+ lookup: {
+ url: null,
+ grouping: false,
+ },
+ labels: getTranslations(),
+ messages: {
+ control: null,
+ selected: null,
+ emptyOptions: null,
+ },
+ fetch: {
+ redirect: "error",
+ method: "GET",
+ mode: "same-origin",
+ credentials: "same-origin",
+ headers: {
+ accept: "application/json",
+ },
+ },
+ filter: {
+ defaultValue: null,
+ mode: FILTER_MODE_DISABLED,
+ position: FILTER_POSITION_INLINE,
+ marker: {
+ open: "{",
+ close: "}",
+ },
+ },
+ classes: {
+ badge: "monster-badge-primary",
+ statusOrRemoveBadge: "empty",
+ },
+ mapping: {
+ selector: "*",
+ labelTemplate: "",
+ valueTemplate: "",
+ filter: null
+ },
+ ignoreValues: [undefined, null, ""],
+ formatter: {
+ selection: buildSelectionLabel,
+ },
+ templates: {
+ main: getTemplate(),
+ },
+ templateMapping: {
+ /** with the attribute `data-monster-selected-template` the template for the selected options can be defined. */
+ selected: getSelectionTemplate(),
+ },
+
+ popper: {
+ placement: "bottom",
+ middleware: ["flip", "offset:1"],
+ },
+ },
+ initOptionsFromArguments.call(this),
+ );
+ }
+
+ /**
+ * @return {Select}
+ */
+ [assembleMethodSymbol]() {
+ const self = this;
+ super[assembleMethodSymbol]();
+
+ initControlReferences.call(self);
+ initEventHandler.call(self);
+
+ let lazyLoadFlag = self.getOption("features.lazyLoad", false);
+ let remoteFilterFlag = getFilterMode.call(this) === FILTER_MODE_REMOTE;
+
+ if (getFilterMode.call(this) === FILTER_MODE_REMOTE) {
+ self.getOption("features.lazyLoad", false);
+ if (lazyLoadFlag === true) {
+ addErrorAttribute(this, "lazyLoad is not supported with remote filter");
+ lazyLoadFlag = false;
+ }
+ }
+
+ if (self.hasAttribute("value")) {
+ new Processing(10, () => {
+ this.value = this.getAttribute("value");
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ }
+
+ if (self.getOption("url") !== null) {
+ if (lazyLoadFlag || remoteFilterFlag) {
+ lookupSelection.call(self);
+ } else {
+ self.fetch().catch((e) => {
+ addErrorAttribute(self, e);
+ });
+ }
+ }
+
+ requestAnimationFrame(() => {
+ let lastValue = self.value;
+ self[internalSymbol].attachObserver(
+ new Observer(function () {
+ if (isObject(this) && this instanceof ProxyObserver) {
+ const n = this.getSubject()?.options?.value;
+
+ if (lastValue !== n && n !== undefined) {
+ lastValue = n;
+ setSelection
+ .call(self, n)
+ .then(() => {
+ })
+ .catch((e) => {
+ addErrorAttribute(self, e);
+ });
+ }
+ }
+ }),
+ );
+
+ areOptionsAvailableAndInit.call(self);
+ });
+
+ return this;
+ }
+
+ /**
+ *
+ * @return {*}
+ * @throws {Error} storeFetchedData is not enabled
+ * @since 3.66.0
+ */
+ getLastFetchedData() {
+ if (this.getOption("features.storeFetchedData") === false) {
+ throw new Error("storeFetchedData is not enabled");
+ }
+
+ return this?.[lastFetchedDataSymbol];
+ }
+
+ /**
+ * The Button.click() method simulates a click on the internal button element.
+ *
+ * @since 3.27.0
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click}
+ */
+ click() {
+ if (this.getOption("disabled") === true) {
+ return;
+ }
+
+ toggle.call(this);
+ }
+
+ /**
+ * The Button.focus() method sets focus on the internal button element.
+ *
+ * @since 3.27.0
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus}
+ */
+ focus(options) {
+ if (this.getOption("disabled") === true) {
+ return;
+ }
+
+ new Processing(() => {
+ gatherState.call(this);
+ focusFilter.call(this, options);
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ }
+
+ /**
+ * The Button.blur() method removes focus from the internal button element.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/blur
+ */
+ blur() {
+ new Processing(() => {
+ gatherState.call(this);
+ blurFilter.call(this);
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ }
+
+ /**
+ * If no url is specified, the options are taken from the Component itself.
+ *
+ * @param {string|URL} url URL to fetch the options
+ * @return {Promise}
+ */
+ fetch(url) {
+ return fetchIt.call(this, url);
+ }
+
+ /**
+ * @return {void}
+ */
+ connectedCallback() {
+ super.connectedCallback();
+ const document = getDocument();
+
+ for (const [, type] of Object.entries(["click", "touch"])) {
+ // close on outside ui-events
+ document.addEventListener(type, this[closeEventHandler]);
+ }
+
+ parseSlotsToOptions.call(this);
+ attachResizeObserver.call(this);
+ updatePopper.call(this);
+
+ new Processing(() => {
+ gatherState.call(this);
+ focusFilter.call(this);
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ }
+
+ /**
+ * @return {void}
+ */
+ disconnectedCallback() {
+ super.disconnectedCallback();
+ const document = getDocument();
+
+ // close on outside ui-events
+ for (const [, type] of Object.entries(["click", "touch"])) {
+ document.removeEventListener(type, this[closeEventHandler]);
+ }
+
+ disconnectResizeObserver.call(this);
+ }
+
+ /**
+ * Import Select Options from dataset
+ * Not to be confused with the control defaults/options
+ *
+ * @param {array|object|Map|Set} data
+ * @return {Select}
+ * @throws {Error} map is not iterable
+ * @throws {Error} missing label configuration
+ * @fires monster-options-set this event is fired when the options are set
+ */
+ importOptions(data) {
+ const mappingOptions = this.getOption("mapping", {});
+ const selector = mappingOptions?.["selector"];
+ const labelTemplate = mappingOptions?.["labelTemplate"];
+ const valueTemplate = mappingOptions?.["valueTemplate"];
+ const filter = mappingOptions?.["filter"];
+
+ let flag = false;
+ if (labelTemplate === "") {
+ addErrorAttribute(this, "empty label template");
+ flag = true;
+ }
+
+ if (valueTemplate === "") {
+ addErrorAttribute(this, "empty value template");
+ flag = true;
+ }
+
+ if (flag === true) {
+ throw new Error("missing label configuration");
+ }
+
+ const map = buildMap(data, selector, labelTemplate, valueTemplate, filter);
+
+ const options = [];
+
+ if (!isIterable(map)) {
+ throw new Error("map is not iterable");
+ }
+
+ const visibility = "visible";
+
+ map.forEach((label, value) => {
+ options.push({
+ value,
+ label,
+ visibility,
+ data: map.get(value),
+ });
+ });
+
+ runAsOptionLengthChanged.call(this, map.size);
+ this.setOption("options", options);
+
+ fireCustomEvent(this, "monster-options-set", {
+ options,
+ });
+
+ setTimeout(() => {
+ setSelection
+ .call(this, this.getOption("selection"))
+ .then(() => {
+ })
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ }, 10);
+
+ return this;
+ }
+
+ /**
+ * @private
+ * @return {Select}
+ */
+ calcAndSetOptionsDimension() {
+ calcAndSetOptionsDimension.call(this);
+ return this;
+ }
+
+ /**
+ *
+ * @return {string}
+ */
+ static getTag() {
+ return "monster-select";
+ }
+
+ /**
+ *
+ * @return {CSSStyleSheet[]}
+ */
+ static getCSSStyleSheet() {
+ return [SelectStyleSheet];
+ }
}
/**
@@ -767,285 +781,285 @@ class Select extends CustomControl {
* @returns {object}
*/
function getTranslations() {
- const locale = getLocaleOfDocument();
- switch (locale.language) {
- case "de":
- return {
- "cannot-be-loaded": "Kann nicht geladen werden",
- "no-options-available": "Keine Optionen verfügbar.",
- "click-to-load-options": "Klicken, um Optionen zu laden.",
- "select-an-option": "Wähle eine Option",
- "summary-text": {
- zero: "Keine Einträge ausgewählt",
- one: '<span class="monster-badge-primary-pill">1</span> Eintrag ausgewählt',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> Einträge ausgewählt',
- },
- "no-options": "Leider gibt es keine Optionen in der Liste.",
- "no-options-found":
- "Keine Optionen in der Liste verfügbar. Bitte ändern Sie den Filter.",
- };
- case "fr":
- return {
- "cannot-be-loaded": "Impossible de charger",
- "no-options-available": "Aucune option disponible.",
- "click-to-load-options": "Cliquez pour charger les options.",
- "select-an-option": "Sélectionnez une option",
- "summary-text": {
- zero: "Aucune entrée sélectionnée",
- one: '<span class="monster-badge-primary-pill">1</span> entrée sélectionnée',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> entrées sélectionnées',
- },
- "no-options":
- "Malheureusement, il n'y a pas d'options disponibles dans la liste.",
- "no-options-found":
- "Aucune option disponible dans la liste. Veuillez modifier le filtre.",
- };
-
- case "sp":
- return {
- "cannot-be-loaded": "No se puede cargar",
- "no-options-available": "No hay opciones disponibles.",
- "click-to-load-options": "Haga clic para cargar opciones.",
- "select-an-option": "Seleccione una opción",
- "summary-text": {
- zero: "No se seleccionaron entradas",
- one: '<span class="monster-badge-primary-pill">1</span> entrada seleccionada',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> entradas seleccionadas',
- },
- "no-options":
- "Desafortunadamente, no hay opciones disponibles en la lista.",
- "no-options-found":
- "No hay opciones disponibles en la lista. Considere modificar el filtro.",
- };
- case "it":
- return {
- "cannot-be-loaded": "Non può essere caricato",
- "no-options-available": "Nessuna opzione disponibile.",
- "click-to-load-options": "Clicca per caricare le opzioni.",
- "select-an-option": "Seleziona un'opzione",
- "summary-text": {
- zero: "Nessuna voce selezionata",
- one: '<span class="monster-badge-primary-pill">1</span> voce selezionata',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> voci selezionate',
- },
- "no-options": "Purtroppo, non ci sono opzioni disponibili nella lista.",
- "no-options-found":
- "Nessuna opzione disponibile nella lista. Si prega di modificare il filtro.",
- };
- case "pl":
- return {
- "cannot-be-loaded": "Nie można załadować",
- "no-options-available": "Brak dostępnych opcji.",
- "click-to-load-options": "Kliknij, aby załadować opcje.",
- "select-an-option": "Wybierz opcję",
- "summary-text": {
- zero: "Nie wybrano żadnych wpisów",
- one: '<span class="monster-badge-primary-pill">1</span> wpis został wybrany',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> wpisy zostały wybrane',
- },
- "no-options": "Niestety, nie ma dostępnych opcji na liście.",
- "no-options-found":
- "Brak dostępnych opcji na liście. Rozważ zmianę filtra.",
- };
- case "no":
- return {
- "cannot-be-loaded": "Kan ikke lastes",
- "no-options-available": "Ingen alternativer tilgjengelig.",
- "click-to-load-options": "Klikk for å laste alternativer.",
- "select-an-option": "Velg et alternativ",
- "summary-text": {
- zero: "Ingen oppføringer ble valgt",
- one: '<span class="monster-badge-primary-pill">1</span> oppføring valgt',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> oppføringer valgt',
- },
- "no-options":
- "Dessverre er det ingen alternativer tilgjengelig i listen.",
- "no-options-found":
- "Ingen alternativer tilgjengelig på listen. Vurder å endre filteret.",
- };
-
- case "dk":
- return {
- "cannot-be-loaded": "Kan ikke indlæses",
- "no-options-available": "Ingen muligheder tilgængelige.",
- "click-to-load-options": "Klik for at indlæse muligheder.",
- "select-an-option": "Vælg en mulighed",
- "summary-text": {
- zero: "Ingen indlæg blev valgt",
- one: '<span class="monster-badge-primary-pill">1</span> indlæg blev valgt',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> indlæg blev valgt',
- },
- "no-options":
- "Desværre er der ingen muligheder tilgængelige på listen.",
- "no-options-found":
- "Ingen muligheder tilgængelige på listen. Overvej at ændre filteret.",
- };
- case "sw":
- return {
- "cannot-be-loaded": "Kan inte laddas",
- "no-options-available": "Inga alternativ tillgängliga.",
- "click-to-load-options": "Klicka för att ladda alternativ.",
- "select-an-option": "Välj ett alternativ",
- "summary-text": {
- zero: "Inga poster valdes",
- one: '<span class="monster-badge-primary-pill">1</span> post valdes',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> poster valdes',
- },
- "no-options": "Tyvärr finns det inga alternativ tillgängliga i listan.",
- "no-options-found":
- "Inga alternativ finns tillgängliga i listan. Överväg att modifiera filtret.",
- };
-
- default:
- case "en":
- return {
- "cannot-be-loaded": "Cannot be loaded",
- "no-options-available": "No options available.",
- "click-to-load-options": "Click to load options.",
- "select-an-option": "Select an option",
- "summary-text": {
- zero: "No entries were selected",
- one: '<span class="monster-badge-primary-pill">1</span> entry was selected',
- other:
- '<span class="monster-badge-primary-pill">${count}</span> entries were selected',
- },
- "no-options":
- "Unfortunately, there are no options available in the list.",
- "no-options-found":
- "No options are available in the list. Please consider modifying the filter.",
- };
- }
+ const locale = getLocaleOfDocument();
+ switch (locale.language) {
+ case "de":
+ return {
+ "cannot-be-loaded": "Kann nicht geladen werden",
+ "no-options-available": "Keine Optionen verfügbar.",
+ "click-to-load-options": "Klicken, um Optionen zu laden.",
+ "select-an-option": "Wähle eine Option",
+ "summary-text": {
+ zero: "Keine Einträge ausgewählt",
+ one: '<span class="monster-badge-primary-pill">1</span> Eintrag ausgewählt',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> Einträge ausgewählt',
+ },
+ "no-options": "Leider gibt es keine Optionen in der Liste.",
+ "no-options-found":
+ "Keine Optionen in der Liste verfügbar. Bitte ändern Sie den Filter.",
+ };
+ case "fr":
+ return {
+ "cannot-be-loaded": "Impossible de charger",
+ "no-options-available": "Aucune option disponible.",
+ "click-to-load-options": "Cliquez pour charger les options.",
+ "select-an-option": "Sélectionnez une option",
+ "summary-text": {
+ zero: "Aucune entrée sélectionnée",
+ one: '<span class="monster-badge-primary-pill">1</span> entrée sélectionnée',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> entrées sélectionnées',
+ },
+ "no-options":
+ "Malheureusement, il n'y a pas d'options disponibles dans la liste.",
+ "no-options-found":
+ "Aucune option disponible dans la liste. Veuillez modifier le filtre.",
+ };
+
+ case "sp":
+ return {
+ "cannot-be-loaded": "No se puede cargar",
+ "no-options-available": "No hay opciones disponibles.",
+ "click-to-load-options": "Haga clic para cargar opciones.",
+ "select-an-option": "Seleccione una opción",
+ "summary-text": {
+ zero: "No se seleccionaron entradas",
+ one: '<span class="monster-badge-primary-pill">1</span> entrada seleccionada',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> entradas seleccionadas',
+ },
+ "no-options":
+ "Desafortunadamente, no hay opciones disponibles en la lista.",
+ "no-options-found":
+ "No hay opciones disponibles en la lista. Considere modificar el filtro.",
+ };
+ case "it":
+ return {
+ "cannot-be-loaded": "Non può essere caricato",
+ "no-options-available": "Nessuna opzione disponibile.",
+ "click-to-load-options": "Clicca per caricare le opzioni.",
+ "select-an-option": "Seleziona un'opzione",
+ "summary-text": {
+ zero: "Nessuna voce selezionata",
+ one: '<span class="monster-badge-primary-pill">1</span> voce selezionata',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> voci selezionate',
+ },
+ "no-options": "Purtroppo, non ci sono opzioni disponibili nella lista.",
+ "no-options-found":
+ "Nessuna opzione disponibile nella lista. Si prega di modificare il filtro.",
+ };
+ case "pl":
+ return {
+ "cannot-be-loaded": "Nie można załadować",
+ "no-options-available": "Brak dostępnych opcji.",
+ "click-to-load-options": "Kliknij, aby załadować opcje.",
+ "select-an-option": "Wybierz opcję",
+ "summary-text": {
+ zero: "Nie wybrano żadnych wpisów",
+ one: '<span class="monster-badge-primary-pill">1</span> wpis został wybrany',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> wpisy zostały wybrane',
+ },
+ "no-options": "Niestety, nie ma dostępnych opcji na liście.",
+ "no-options-found":
+ "Brak dostępnych opcji na liście. Rozważ zmianę filtra.",
+ };
+ case "no":
+ return {
+ "cannot-be-loaded": "Kan ikke lastes",
+ "no-options-available": "Ingen alternativer tilgjengelig.",
+ "click-to-load-options": "Klikk for å laste alternativer.",
+ "select-an-option": "Velg et alternativ",
+ "summary-text": {
+ zero: "Ingen oppføringer ble valgt",
+ one: '<span class="monster-badge-primary-pill">1</span> oppføring valgt',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> oppføringer valgt',
+ },
+ "no-options":
+ "Dessverre er det ingen alternativer tilgjengelig i listen.",
+ "no-options-found":
+ "Ingen alternativer tilgjengelig på listen. Vurder å endre filteret.",
+ };
+
+ case "dk":
+ return {
+ "cannot-be-loaded": "Kan ikke indlæses",
+ "no-options-available": "Ingen muligheder tilgængelige.",
+ "click-to-load-options": "Klik for at indlæse muligheder.",
+ "select-an-option": "Vælg en mulighed",
+ "summary-text": {
+ zero: "Ingen indlæg blev valgt",
+ one: '<span class="monster-badge-primary-pill">1</span> indlæg blev valgt',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> indlæg blev valgt',
+ },
+ "no-options":
+ "Desværre er der ingen muligheder tilgængelige på listen.",
+ "no-options-found":
+ "Ingen muligheder tilgængelige på listen. Overvej at ændre filteret.",
+ };
+ case "sw":
+ return {
+ "cannot-be-loaded": "Kan inte laddas",
+ "no-options-available": "Inga alternativ tillgängliga.",
+ "click-to-load-options": "Klicka för att ladda alternativ.",
+ "select-an-option": "Välj ett alternativ",
+ "summary-text": {
+ zero: "Inga poster valdes",
+ one: '<span class="monster-badge-primary-pill">1</span> post valdes',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> poster valdes',
+ },
+ "no-options": "Tyvärr finns det inga alternativ tillgängliga i listan.",
+ "no-options-found":
+ "Inga alternativ finns tillgängliga i listan. Överväg att modifiera filtret.",
+ };
+
+ default:
+ case "en":
+ return {
+ "cannot-be-loaded": "Cannot be loaded",
+ "no-options-available": "No options available.",
+ "click-to-load-options": "Click to load options.",
+ "select-an-option": "Select an option",
+ "summary-text": {
+ zero: "No entries were selected",
+ one: '<span class="monster-badge-primary-pill">1</span> entry was selected',
+ other:
+ '<span class="monster-badge-primary-pill">${count}</span> entries were selected',
+ },
+ "no-options":
+ "Unfortunately, there are no options available in the list.",
+ "no-options-found":
+ "No options are available in the list. Please consider modifying the filter.",
+ };
+ }
}
/**
* @private
*/
function lookupSelection() {
- const self = this;
-
- setTimeout(() => {
- const selection = self.getOption("selection");
- if (selection.length === 0) {
- return;
- }
-
- if (self[isLoadingSymbol] === true) {
- return;
- }
-
- if (self[lazyLoadDoneSymbol] === true) {
- return;
- }
-
- let url = self.getOption("url");
- let lookupUrl = self.getOption("lookup.url");
- if (lookupUrl !== null) {
- url = lookupUrl;
- }
-
- if (this.getOption("lookup.grouping") === true) {
- filterFromRemoteByValue
- .call(
- self,
- url,
- selection.map((s) => s?.["value"]),
- )
- .catch((e) => {
- addErrorAttribute(self, e);
- });
- return;
- }
-
- for (const s of selection) {
- if (s?.["value"]) {
- filterFromRemoteByValue.call(self, url, s?.["value"]).catch((e) => {
- addErrorAttribute(self, e);
- });
- }
- }
- }, 100);
+ const self = this;
+
+ setTimeout(() => {
+ const selection = self.getOption("selection");
+ if (selection.length === 0) {
+ return;
+ }
+
+ if (self[isLoadingSymbol] === true) {
+ return;
+ }
+
+ if (self[lazyLoadDoneSymbol] === true) {
+ return;
+ }
+
+ let url = self.getOption("url");
+ let lookupUrl = self.getOption("lookup.url");
+ if (lookupUrl !== null) {
+ url = lookupUrl;
+ }
+
+ if (this.getOption("lookup.grouping") === true) {
+ filterFromRemoteByValue
+ .call(
+ self,
+ url,
+ selection.map((s) => s?.["value"]),
+ )
+ .catch((e) => {
+ addErrorAttribute(self, e);
+ });
+ return;
+ }
+
+ for (const s of selection) {
+ if (s?.["value"]) {
+ filterFromRemoteByValue.call(self, url, s?.["value"]).catch((e) => {
+ addErrorAttribute(self, e);
+ });
+ }
+ }
+ }, 100);
}
function fetchIt(url, controlOptions) {
- if (url instanceof URL) {
- url = url.toString();
- }
-
- if (url !== undefined && url !== null) {
- url = validateString(url);
- } else {
- url = this.getOption("url");
- if (url === null) {
- return Promise.reject(new Error("No url defined"));
- }
- }
-
- return new Promise((resolve, reject) => {
- setStatusOrRemoveBadges.call(this, "loading");
-
- new Processing(10, () => {
- fetchData
- .call(this, url)
- .then((map) => {
- if (
- isObject(map) ||
- isArray(map) ||
- map instanceof Set ||
- map instanceof Map
- ) {
- try {
- this.importOptions(map);
- } catch (e) {
- setStatusOrRemoveBadges.call(this, "error");
- reject(e);
- return;
- }
-
- this[lastFetchedDataSymbol] = map;
-
- let result;
- const selection = this.getOption("selection");
- let newValue = [];
- if (selection) {
- newValue = selection;
- } else if (this.hasAttribute("value")) {
- newValue = this.getAttribute("value");
- }
-
- result = setSelection.call(this, newValue);
- requestAnimationFrame(() => {
- checkOptionState.call(this);
- setStatusOrRemoveBadges.call(this, "closed");
- updatePopper.call(this);
- resolve(result);
- });
-
- return;
- }
-
- setStatusOrRemoveBadges.call(this, "error");
- reject(new Error("invalid response"));
- })
- .catch((e) => {
- setStatusOrRemoveBadges.call(this, "error");
- reject(e);
- });
- })
- .run()
- .catch((e) => {
- setStatusOrRemoveBadges.call(this, "error");
- addErrorAttribute(this, e);
- reject(e);
- });
- });
+ if (url instanceof URL) {
+ url = url.toString();
+ }
+
+ if (url !== undefined && url !== null) {
+ url = validateString(url);
+ } else {
+ url = this.getOption("url");
+ if (url === null) {
+ return Promise.reject(new Error("No url defined"));
+ }
+ }
+
+ return new Promise((resolve, reject) => {
+ setStatusOrRemoveBadges.call(this, "loading");
+
+ new Processing(10, () => {
+ fetchData
+ .call(this, url)
+ .then((map) => {
+ if (
+ isObject(map) ||
+ isArray(map) ||
+ map instanceof Set ||
+ map instanceof Map
+ ) {
+ try {
+ this.importOptions(map);
+ } catch (e) {
+ setStatusOrRemoveBadges.call(this, "error");
+ reject(e);
+ return;
+ }
+
+ this[lastFetchedDataSymbol] = map;
+
+ let result;
+ const selection = this.getOption("selection");
+ let newValue = [];
+ if (selection) {
+ newValue = selection;
+ } else if (this.hasAttribute("value")) {
+ newValue = this.getAttribute("value");
+ }
+
+ result = setSelection.call(this, newValue);
+ requestAnimationFrame(() => {
+ checkOptionState.call(this);
+ setStatusOrRemoveBadges.call(this, "closed");
+ updatePopper.call(this);
+ resolve(result);
+ });
+
+ return;
+ }
+
+ setStatusOrRemoveBadges.call(this, "error");
+ reject(new Error("invalid response"));
+ })
+ .catch((e) => {
+ setStatusOrRemoveBadges.call(this, "error");
+ reject(e);
+ });
+ })
+ .run()
+ .catch((e) => {
+ setStatusOrRemoveBadges.call(this, "error");
+ addErrorAttribute(this, e);
+ reject(e);
+ });
+ });
}
/**
@@ -1060,68 +1074,68 @@ function fetchIt(url, controlOptions) {
* @return {object}
*/
function initOptionsFromArguments() {
- const options = {};
-
- const template = this.getAttribute("data-monster-selected-template");
- if (isString(template)) {
- if (!options["templateMapping"]) options["templateMapping"] = {};
-
- switch (template) {
- case "summary":
- case "default":
- options["templateMapping"]["selected"] = getSummaryTemplate();
- break;
- case "selected":
- options["templateMapping"]["selected"] = getSelectionTemplate();
- break;
- default:
- addErrorAttribute(this, "invalid template, use summary or selected");
- }
- }
-
- return options;
+ const options = {};
+
+ const template = this.getAttribute("data-monster-selected-template");
+ if (isString(template)) {
+ if (!options["templateMapping"]) options["templateMapping"] = {};
+
+ switch (template) {
+ case "summary":
+ case "default":
+ options["templateMapping"]["selected"] = getSummaryTemplate();
+ break;
+ case "selected":
+ options["templateMapping"]["selected"] = getSelectionTemplate();
+ break;
+ default:
+ addErrorAttribute(this, "invalid template, use summary or selected");
+ }
+ }
+
+ return options;
}
/**
* @private
*/
function attachResizeObserver() {
- // against flickering
- this[resizeObserverSymbol] = new ResizeObserver((entries) => {
- if (this[timerCallbackSymbol] instanceof DeadMansSwitch) {
- try {
- this[timerCallbackSymbol].touch();
- return;
- } catch (e) {
- delete this[timerCallbackSymbol];
- }
- }
-
- this[timerCallbackSymbol] = new DeadMansSwitch(200, () => {
- updatePopper.call(this);
- delete this[timerCallbackSymbol];
- });
- });
-
- requestAnimationFrame(() => {
- let parent = this.parentNode;
- while (!(parent instanceof HTMLElement) && parent !== null) {
- parent = parent.parentNode;
- }
-
- if (parent instanceof HTMLElement) {
- this[resizeObserverSymbol].observe(parent);
- }
- });
+ // against flickering
+ this[resizeObserverSymbol] = new ResizeObserver((entries) => {
+ if (this[timerCallbackSymbol] instanceof DeadMansSwitch) {
+ try {
+ this[timerCallbackSymbol].touch();
+ return;
+ } catch (e) {
+ delete this[timerCallbackSymbol];
+ }
+ }
+
+ this[timerCallbackSymbol] = new DeadMansSwitch(200, () => {
+ updatePopper.call(this);
+ delete this[timerCallbackSymbol];
+ });
+ });
+
+ requestAnimationFrame(() => {
+ let parent = this.parentNode;
+ while (!(parent instanceof HTMLElement) && parent !== null) {
+ parent = parent.parentNode;
+ }
+
+ if (parent instanceof HTMLElement) {
+ this[resizeObserverSymbol].observe(parent);
+ }
+ });
}
/**
* @private
*/
function disconnectResizeObserver() {
- if (this[resizeObserverSymbol] instanceof ResizeObserver) {
- this[resizeObserverSymbol].disconnect();
- }
+ if (this[resizeObserverSymbol] instanceof ResizeObserver) {
+ this[resizeObserverSymbol].disconnect();
+ }
}
/**
@@ -1129,7 +1143,7 @@ function disconnectResizeObserver() {
* @returns {string}
*/
function getSelectionTemplate() {
- return `<div data-monster-role="selection" part="selection"
+ return `<div data-monster-role="selection" part="selection"
data-monster-insert="selection path:selection" role="search"
><input type="text" role="searchbox"
part="inline-filter" name="inline-filter"
@@ -1145,7 +1159,7 @@ function getSelectionTemplate() {
* @returns {string}
*/
function getSummaryTemplate() {
- return `<div data-monster-role="selection" role="search" part="summary">
+ return `<div data-monster-role="selection" role="search" part="summary">
<input type="text" role="searchbox"
part="inline-filter" name="inline-filter"
data-monster-role="filter"
@@ -1161,35 +1175,35 @@ function getSummaryTemplate() {
* @private
*/
function parseSlotsToOptions() {
- let options = this.getOption("options");
- if (!isIterable(options)) {
- options = [];
- }
-
- let counter = 1;
- getSlottedElements.call(this, "div").forEach((node) => {
- let value = (counter++).toString();
- let visibility = "visible";
-
- if (node.hasAttribute("data-monster-value")) {
- value = node.getAttribute("data-monster-value");
- }
-
- let label = node.outerHTML;
-
- if (node.style.display === "none") {
- visibility = "hidden";
- }
-
- options.push({
- value,
- label,
- visibility,
- });
- });
-
- runAsOptionLengthChanged.call(this, options.length);
- this.setOption("options", options);
+ let options = this.getOption("options");
+ if (!isIterable(options)) {
+ options = [];
+ }
+
+ let counter = 1;
+ getSlottedElements.call(this, "div").forEach((node) => {
+ let value = (counter++).toString();
+ let visibility = "visible";
+
+ if (node.hasAttribute("data-monster-value")) {
+ value = node.getAttribute("data-monster-value");
+ }
+
+ let label = node.outerHTML;
+
+ if (node.style.display === "none") {
+ visibility = "hidden";
+ }
+
+ options.push({
+ value,
+ label,
+ visibility,
+ });
+ });
+
+ runAsOptionLengthChanged.call(this, options.length);
+ this.setOption("options", options);
}
/**
@@ -1199,39 +1213,39 @@ function parseSlotsToOptions() {
* @param {int} targetLength
*/
function runAsOptionLengthChanged(targetLength) {
- const self = this;
-
- if (!self[optionsElementSymbol]) {
- return;
- }
-
- const callback = function (mutationsList, observer) {
- const run = false;
- for (const mutation of mutationsList) {
- if (mutation.type === "childList") {
- const run = true;
- break;
- }
- }
-
- if (run === true) {
- const nodes = self[optionsElementSymbol].querySelectorAll(
- `div[${ATTRIBUTE_ROLE}=option]`,
- );
-
- if (nodes.length === targetLength) {
- checkOptionState.call(self);
- observer.disconnect();
- }
- }
- };
-
- const observer = new MutationObserver(callback);
- observer.observe(self[optionsElementSymbol], {
- attributes: false,
- childList: true,
- subtree: true,
- });
+ const self = this;
+
+ if (!self[optionsElementSymbol]) {
+ return;
+ }
+
+ const callback = function (mutationsList, observer) {
+ const run = false;
+ for (const mutation of mutationsList) {
+ if (mutation.type === "childList") {
+ const run = true;
+ break;
+ }
+ }
+
+ if (run === true) {
+ const nodes = self[optionsElementSymbol].querySelectorAll(
+ `div[${ATTRIBUTE_ROLE}=option]`,
+ );
+
+ if (nodes.length === targetLength) {
+ checkOptionState.call(self);
+ observer.disconnect();
+ }
+ }
+ };
+
+ const observer = new MutationObserver(callback);
+ observer.observe(self[optionsElementSymbol], {
+ attributes: false,
+ childList: true,
+ subtree: true,
+ });
}
/**
@@ -1240,38 +1254,38 @@ function runAsOptionLengthChanged(targetLength) {
* @return {*}
*/
function buildSelectionLabel(value) {
- const options = this.getOption("options");
-
- for (let i = 0; i < options.length; i++) {
- let o = options?.[i];
- let l, v, v2;
-
- if (this.getOption("features.useStrictValueComparison") === true) {
- v = value;
- } else {
- v = `${value}`;
- }
-
- if (isPrimitive(o) && o === value) {
- return o;
- } else if (!isObject(o)) {
- continue;
- }
-
- if (this.getOption("features.useStrictValueComparison") === true) {
- l = o?.["label"];
- v2 = o?.["value"];
- } else {
- l = `${o?.["label"]}`;
- v2 = `${o?.["value"]}`;
- }
-
- if (v2 === v) {
- return l;
- }
- }
-
- return undefined;
+ const options = this.getOption("options");
+
+ for (let i = 0; i < options.length; i++) {
+ let o = options?.[i];
+ let l, v, v2;
+
+ if (this.getOption("features.useStrictValueComparison") === true) {
+ v = value;
+ } else {
+ v = `${value}`;
+ }
+
+ if (isPrimitive(o) && o === value) {
+ return o;
+ } else if (!isObject(o)) {
+ continue;
+ }
+
+ if (this.getOption("features.useStrictValueComparison") === true) {
+ l = o?.["label"];
+ v2 = o?.["value"];
+ } else {
+ l = `${o?.["label"]}`;
+ v2 = `${o?.["value"]}`;
+ }
+
+ if (v2 === v) {
+ return l;
+ }
+ }
+
+ return undefined;
}
/**
@@ -1281,17 +1295,17 @@ function buildSelectionLabel(value) {
* @throws {Error} no value found
*/
function getSelectionLabel(value) {
- const callback = this.getOption("formatter.selection");
- if (isFunction(callback)) {
- const label = callback.call(this, value);
- if (isString(label)) return label;
- }
+ const callback = this.getOption("formatter.selection");
+ if (isFunction(callback)) {
+ const label = callback.call(this, value);
+ if (isString(label)) return label;
+ }
- if (isString(value) || isInteger(value)) {
- return `${value}`;
- }
+ if (isString(value) || isInteger(value)) {
+ return `${value}`;
+ }
- return this.getOption("labels.cannot-be-loaded", value);
+ return this.getOption("labels.cannot-be-loaded", value);
}
/**
@@ -1299,25 +1313,25 @@ function getSelectionLabel(value) {
* @param {Event} event
*/
function handleToggleKeyboardEvents(event) {
- switch (event?.["code"]) {
- case "Escape":
- toggle.call(this);
- event.preventDefault();
- break;
- case "Space":
- toggle.call(this);
- event.preventDefault();
- break;
- case "ArrowDown":
- show.call(this);
- activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
- event.preventDefault();
- break;
- case "ArrowUp":
- hide.call(this);
- event.preventDefault();
- break;
- }
+ switch (event?.["code"]) {
+ case "Escape":
+ toggle.call(this);
+ event.preventDefault();
+ break;
+ case "Space":
+ toggle.call(this);
+ event.preventDefault();
+ break;
+ case "ArrowDown":
+ show.call(this);
+ activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
+ event.preventDefault();
+ break;
+ case "ArrowUp":
+ hide.call(this);
+ event.preventDefault();
+ break;
+ }
}
/**
@@ -1327,32 +1341,32 @@ function handleToggleKeyboardEvents(event) {
* @this CustomElement
*/
function initOptionObserver() {
- const self = this;
-
- self.attachObserver(
- new Observer(function () {
- new Processing(() => {
- try {
- self.updateI18n();
- } catch (e) {
- addErrorAttribute(self, e);
- requestAnimationFrame(() => {
- setStatusOrRemoveBadges.call(self, "error");
- });
- }
- try {
- areOptionsAvailableAndInit.call(self);
- } catch (e) {
- addErrorAttribute(self, e);
- requestAnimationFrame(() => {
- setStatusOrRemoveBadges.call(self, "error");
- });
- }
-
- setSummaryAndControlText.call(self);
- }).run();
- }),
- );
+ const self = this;
+
+ self.attachObserver(
+ new Observer(function () {
+ new Processing(() => {
+ try {
+ self.updateI18n();
+ } catch (e) {
+ addErrorAttribute(self, e);
+ requestAnimationFrame(() => {
+ setStatusOrRemoveBadges.call(self, "error");
+ });
+ }
+ try {
+ areOptionsAvailableAndInit.call(self);
+ } catch (e) {
+ addErrorAttribute(self, e);
+ requestAnimationFrame(() => {
+ setStatusOrRemoveBadges.call(self, "error");
+ });
+ }
+
+ setSummaryAndControlText.call(self);
+ }).run();
+ }),
+ );
}
/**
@@ -1360,16 +1374,17 @@ function initOptionObserver() {
* @returns {Translations}
*/
function getDefaultTranslation() {
- const translation = new Translations("en").assignTranslations(
- this.getOption("labels", {}),
- );
+ const translation = new Translations("en").assignTranslations(
+ this.getOption("labels", {}),
+ );
- try {
- const doc = getDocumentTranslations();
- translation.locale = doc.locale;
- } catch (e) {}
+ try {
+ const doc = getDocumentTranslations();
+ translation.locale = doc.locale;
+ } catch (e) {
+ }
- return translation;
+ return translation;
}
/**
@@ -1377,36 +1392,36 @@ function getDefaultTranslation() {
* @return {string|*}
*/
function setSummaryAndControlText() {
- const translations = getDefaultTranslation.call(this);
- const selections = this.getOption("selection");
-
- const text = translations.getPluralRuleText(
- "summary-text",
- selections.length,
- "",
- );
-
- const selectedText = new Formatter({
- count: String(selections.length),
- }).format(text);
-
- this.setOption("messages.selected", selectedText);
-
- const current = this.getOption("messages.control");
- const msg = this.getOption("labels.select-an-option");
-
- if (
- current === "" ||
- current === undefined ||
- current === msg ||
- current === null
- ) {
- if (selections.length === 0) {
- this.setOption("messages.control", msg);
- } else {
- this.setOption("messages.control", "");
- }
- }
+ const translations = getDefaultTranslation.call(this);
+ const selections = this.getOption("selection");
+
+ const text = translations.getPluralRuleText(
+ "summary-text",
+ selections.length,
+ "",
+ );
+
+ const selectedText = new Formatter({
+ count: String(selections.length),
+ }).format(text);
+
+ this.setOption("messages.selected", selectedText);
+
+ const current = this.getOption("messages.control");
+ const msg = this.getOption("labels.select-an-option");
+
+ if (
+ current === "" ||
+ current === undefined ||
+ current === msg ||
+ current === null
+ ) {
+ if (selections.length === 0) {
+ this.setOption("messages.control", msg);
+ } else {
+ this.setOption("messages.control", "");
+ }
+ }
}
/**
@@ -1414,9 +1429,9 @@ function setSummaryAndControlText() {
* @return {NodeList}
*/
function getOptionElements() {
- return this[optionsElementSymbol].querySelectorAll(
- `[${ATTRIBUTE_ROLE}=option]`,
- );
+ return this[optionsElementSymbol].querySelectorAll(
+ `[${ATTRIBUTE_ROLE}=option]`,
+ );
}
/**
@@ -1440,75 +1455,75 @@ function getOptionElements() {
* @private
*/
function calcAndSetOptionsDimension() {
- const options = getOptionElements.call(this);
- const container = this[optionsElementSymbol];
- if (!(container instanceof HTMLElement && options instanceof NodeList)) {
- return;
- }
-
- let visible = 0;
- let optionHeight = 0;
- const max = this.getOption("showMaxOptions", 10);
-
- let scrollFlag = false;
- for (const [, option] of Object.entries(options)) {
- const computedStyle = getGlobal().getComputedStyle(option);
- if (computedStyle.display === "none") continue;
-
- let h = option.getBoundingClientRect().height;
- h += parseInt(computedStyle.getPropertyValue("margin-top"), 10);
- h += parseInt(computedStyle.getPropertyValue("margin-bottom"), 10);
- optionHeight += h;
-
- visible++;
-
- if (visible > max) {
- break;
- }
- }
-
- if (visible > max) {
- visible = max;
- scrollFlag = true;
- }
-
- if (visible === 0) {
- if (getFilterMode.call(this) === FILTER_MODE_DISABLED) {
- this.setOption(
- "messages.emptyOptions",
- this.getOption("labels.no-options-available"),
- );
- } else {
- this.setOption(
- "messages.emptyOptions",
- this.getOption("labels.no-options-found"),
- );
- }
- this[noOptionsAvailableElementSymbol].classList.remove("d-none");
- } else {
- this[noOptionsAvailableElementSymbol].classList.add("d-none");
- }
-
- const styles = getGlobal().getComputedStyle(this[optionsElementSymbol]);
- let padding = parseInt(styles.getPropertyValue("padding-top"), 10);
- padding += parseInt(styles.getPropertyValue("padding-bottom"), 10);
-
- let margin = parseInt(styles.getPropertyValue("margin-top"), 10);
- margin += parseInt(styles.getPropertyValue("margin-bottom"), 10);
-
- const containerHeight = optionHeight + padding + margin;
- container.style.height = `${containerHeight}px`;
-
- if (scrollFlag === true) {
- container.style.overflowY = "scroll";
- } else {
- container.style.overflowY = "auto";
- }
-
- const domRect = this[controlElementSymbol].getBoundingClientRect();
-
- this[popperElementSymbol].style.width = `${domRect.width}px`;
- container.style.overflowX = "auto";
+ const options = getOptionElements.call(this);
+ const container = this[optionsElementSymbol];
+ if (!(container instanceof HTMLElement && options instanceof NodeList)) {
+ return;
+ }
+
+ let visible = 0;
+ let optionHeight = 0;
+ const max = this.getOption("showMaxOptions", 10);
+
+ let scrollFlag = false;
+ for (const [, option] of Object.entries(options)) {
+ const computedStyle = getGlobal().getComputedStyle(option);
+ if (computedStyle.display === "none") continue;
+
+ let h = option.getBoundingClientRect().height;
+ h += parseInt(computedStyle.getPropertyValue("margin-top"), 10);
+ h += parseInt(computedStyle.getPropertyValue("margin-bottom"), 10);
+ optionHeight += h;
+
+ visible++;
+
+ if (visible > max) {
+ break;
+ }
+ }
+
+ if (visible > max) {
+ visible = max;
+ scrollFlag = true;
+ }
+
+ if (visible === 0) {
+ if (getFilterMode.call(this) === FILTER_MODE_DISABLED) {
+ this.setOption(
+ "messages.emptyOptions",
+ this.getOption("labels.no-options-available"),
+ );
+ } else {
+ this.setOption(
+ "messages.emptyOptions",
+ this.getOption("labels.no-options-found"),
+ );
+ }
+ this[noOptionsAvailableElementSymbol].classList.remove("d-none");
+ } else {
+ this[noOptionsAvailableElementSymbol].classList.add("d-none");
+ }
+
+ const styles = getGlobal().getComputedStyle(this[optionsElementSymbol]);
+ let padding = parseInt(styles.getPropertyValue("padding-top"), 10);
+ padding += parseInt(styles.getPropertyValue("padding-bottom"), 10);
+
+ let margin = parseInt(styles.getPropertyValue("margin-top"), 10);
+ margin += parseInt(styles.getPropertyValue("margin-bottom"), 10);
+
+ const containerHeight = optionHeight + padding + margin;
+ container.style.height = `${containerHeight}px`;
+
+ if (scrollFlag === true) {
+ container.style.overflowY = "scroll";
+ } else {
+ container.style.overflowY = "auto";
+ }
+
+ const domRect = this[controlElementSymbol].getBoundingClientRect();
+
+ this[popperElementSymbol].style.width = `${domRect.width}px`;
+ container.style.overflowX = "auto";
}
/**
@@ -1517,126 +1532,126 @@ function calcAndSetOptionsDimension() {
* @throws {Error} no shadow-root is defined
*/
function activateCurrentOption(direction) {
- if (!this.shadowRoot) {
- throw new Error("no shadow-root is defined");
- }
-
- let focused = this.shadowRoot.querySelector(`[${ATTRIBUTE_PREFIX}focused]`);
-
- if (
- !(focused instanceof HTMLElement) ||
- focused.matches("[data-monster-visibility=hidden]")
- ) {
- for (const [, e] of Object.entries(
- this.shadowRoot.querySelectorAll(`[${ATTRIBUTE_ROLE}=option]`),
- )) {
- if (e.matches("[data-monster-visibility=visible]")) {
- focused = e;
- break;
- }
- }
- } else {
- if (direction === FOCUS_DIRECTION_DOWN) {
- while (focused.nextSibling) {
- focused = focused.nextSibling;
-
- if (
- focused instanceof HTMLElement &&
- focused.hasAttribute(ATTRIBUTE_ROLE) &&
- focused.getAttribute(ATTRIBUTE_ROLE) === "option" &&
- focused.matches("[data-monster-visibility=visible]") &&
- focused.matches(":not([data-monster-filtered=true])")
- ) {
- break;
- }
- }
- } else {
- let found = false;
- while (focused.previousSibling) {
- focused = focused.previousSibling;
- if (
- focused instanceof HTMLElement &&
- focused.hasAttribute(ATTRIBUTE_ROLE) &&
- focused.getAttribute(ATTRIBUTE_ROLE) === "option" &&
- focused.matches("[data-monster-visibility=visible]") &&
- focused.matches(":not([data-monster-filtered=true])")
- ) {
- found = true;
- break;
- }
- }
- if (found === false) {
- focusFilter.call(this);
- }
- }
- }
-
- new Processing(() => {
- if (focused instanceof HTMLElement) {
- this.shadowRoot
- .querySelectorAll(`[${ATTRIBUTE_PREFIX}focused]`)
- .forEach((e) => {
- e.removeAttribute(`${ATTRIBUTE_PREFIX}focused`);
- });
-
- focused.focus();
- focused.setAttribute(`${ATTRIBUTE_PREFIX}focused`, true);
- }
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
+ if (!this.shadowRoot) {
+ throw new Error("no shadow-root is defined");
+ }
+
+ let focused = this.shadowRoot.querySelector(`[${ATTRIBUTE_PREFIX}focused]`);
+
+ if (
+ !(focused instanceof HTMLElement) ||
+ focused.matches("[data-monster-visibility=hidden]")
+ ) {
+ for (const [, e] of Object.entries(
+ this.shadowRoot.querySelectorAll(`[${ATTRIBUTE_ROLE}=option]`),
+ )) {
+ if (e.matches("[data-monster-visibility=visible]")) {
+ focused = e;
+ break;
+ }
+ }
+ } else {
+ if (direction === FOCUS_DIRECTION_DOWN) {
+ while (focused.nextSibling) {
+ focused = focused.nextSibling;
+
+ if (
+ focused instanceof HTMLElement &&
+ focused.hasAttribute(ATTRIBUTE_ROLE) &&
+ focused.getAttribute(ATTRIBUTE_ROLE) === "option" &&
+ focused.matches("[data-monster-visibility=visible]") &&
+ focused.matches(":not([data-monster-filtered=true])")
+ ) {
+ break;
+ }
+ }
+ } else {
+ let found = false;
+ while (focused.previousSibling) {
+ focused = focused.previousSibling;
+ if (
+ focused instanceof HTMLElement &&
+ focused.hasAttribute(ATTRIBUTE_ROLE) &&
+ focused.getAttribute(ATTRIBUTE_ROLE) === "option" &&
+ focused.matches("[data-monster-visibility=visible]") &&
+ focused.matches(":not([data-monster-filtered=true])")
+ ) {
+ found = true;
+ break;
+ }
+ }
+ if (found === false) {
+ focusFilter.call(this);
+ }
+ }
+ }
+
+ new Processing(() => {
+ if (focused instanceof HTMLElement) {
+ this.shadowRoot
+ .querySelectorAll(`[${ATTRIBUTE_PREFIX}focused]`)
+ .forEach((e) => {
+ e.removeAttribute(`${ATTRIBUTE_PREFIX}focused`);
+ });
+
+ focused.focus();
+ focused.setAttribute(`${ATTRIBUTE_PREFIX}focused`, true);
+ }
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
}
/**
* @private
*/
function filterOptions() {
- new Processing(() => {
- let filterValue;
-
- switch (this.getOption("filter.position")) {
- case FILTER_POSITION_INLINE:
- if (this[inlineFilterElementSymbol] instanceof HTMLElement) {
- filterValue = this[inlineFilterElementSymbol].value.toLowerCase();
- } else {
- return;
- }
-
- break;
- case FILTER_POSITION_POPPER:
- default:
- if (this[popperFilterElementSymbol] instanceof HTMLInputElement) {
- filterValue = this[popperFilterElementSymbol].value.toLowerCase();
- } else {
- return;
- }
- }
-
- const options = this.getOption("options");
- for (const [i, option] of Object.entries(options)) {
- if (option.label.toLowerCase().indexOf(filterValue) === -1) {
- this.setOption(`options.${i}.filtered`, "true");
- } else {
- this.setOption(`options.${i}.filtered`, undefined);
- }
- }
- })
- .run()
- .then(() => {
- new Processing(100, () => {
- calcAndSetOptionsDimension.call(this);
- focusFilter.call(this);
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
- })
- .catch((e) => {
- addErrorAttribute(this, e);
- });
+ new Processing(() => {
+ let filterValue;
+
+ switch (this.getOption("filter.position")) {
+ case FILTER_POSITION_INLINE:
+ if (this[inlineFilterElementSymbol] instanceof HTMLElement) {
+ filterValue = this[inlineFilterElementSymbol].value.toLowerCase();
+ } else {
+ return;
+ }
+
+ break;
+ case FILTER_POSITION_POPPER:
+ default:
+ if (this[popperFilterElementSymbol] instanceof HTMLInputElement) {
+ filterValue = this[popperFilterElementSymbol].value.toLowerCase();
+ } else {
+ return;
+ }
+ }
+
+ const options = this.getOption("options");
+ for (const [i, option] of Object.entries(options)) {
+ if (option.label.toLowerCase().indexOf(filterValue) === -1) {
+ this.setOption(`options.${i}.filtered`, "true");
+ } else {
+ this.setOption(`options.${i}.filtered`, undefined);
+ }
+ }
+ })
+ .run()
+ .then(() => {
+ new Processing(100, () => {
+ calcAndSetOptionsDimension.call(this);
+ focusFilter.call(this);
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ })
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
}
/**
@@ -1644,37 +1659,37 @@ function filterOptions() {
* @param {Event} event
*/
function handleFilterKeyboardEvents(event) {
- const shiftKey = event?.["shiftKey"];
-
- switch (event?.["code"]) {
- case "Tab":
- activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
- event.preventDefault();
- break;
- case "Escape":
- toggle.call(this);
- event.preventDefault();
- break;
- case "Tab" && shiftKey === true:
- case "ArrowUp":
- activateCurrentOption.call(this, FOCUS_DIRECTION_UP);
- event.preventDefault();
- break;
- case "Tab" && !shiftKey:
- case "ArrowDown":
- activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
- event.preventDefault();
- break;
- default:
- if (
- this.getOption("features.lazyLoad") === true &&
- this[lazyLoadDoneSymbol] !== true
- ) {
- this.click();
- }
-
- handleFilterKeyEvents.call(this);
- }
+ const shiftKey = event?.["shiftKey"];
+
+ switch (event?.["code"]) {
+ case "Tab":
+ activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
+ event.preventDefault();
+ break;
+ case "Escape":
+ toggle.call(this);
+ event.preventDefault();
+ break;
+ case "Tab" && shiftKey === true:
+ case "ArrowUp":
+ activateCurrentOption.call(this, FOCUS_DIRECTION_UP);
+ event.preventDefault();
+ break;
+ case "Tab" && !shiftKey:
+ case "ArrowDown":
+ activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
+ event.preventDefault();
+ break;
+ default:
+ if (
+ this.getOption("features.lazyLoad") === true &&
+ this[lazyLoadDoneSymbol] !== true
+ ) {
+ this.click();
+ }
+
+ handleFilterKeyEvents.call(this);
+ }
}
/**
@@ -1688,86 +1703,86 @@ function handleFilterKeyboardEvents(event) {
* @return {void} This method does not return anything.
*/
function handleFilterKeyEvents() {
- if (this[keyFilterEventSymbol] instanceof DeadMansSwitch) {
- try {
- this[keyFilterEventSymbol].touch();
- return;
- } catch (e) {
- delete this[keyFilterEventSymbol];
- }
- }
-
- this[keyFilterEventSymbol] = new DeadMansSwitch(200, () => {
- if (getFilterMode.call(this) !== FILTER_MODE_REMOTE) {
- filterOptions.call(this);
- } else {
- filterFromRemote.call(this).catch((e) => {
- addErrorAttribute(this, e);
- });
- }
-
- delete this[keyFilterEventSymbol];
- });
+ if (this[keyFilterEventSymbol] instanceof DeadMansSwitch) {
+ try {
+ this[keyFilterEventSymbol].touch();
+ return;
+ } catch (e) {
+ delete this[keyFilterEventSymbol];
+ }
+ }
+
+ this[keyFilterEventSymbol] = new DeadMansSwitch(200, () => {
+ if (getFilterMode.call(this) !== FILTER_MODE_REMOTE) {
+ filterOptions.call(this);
+ } else {
+ filterFromRemote.call(this).catch((e) => {
+ addErrorAttribute(this, e);
+ });
+ }
+
+ delete this[keyFilterEventSymbol];
+ });
}
/**
* @private
*/
function filterFromRemote() {
- if (
- !(this[inlineFilterElementSymbol] instanceof HTMLElement) &&
- !(this[popperFilterElementSymbol] instanceof HTMLElement)
- ) {
- return;
- }
-
- show.call(this);
-
- const url = this.getOption("url");
- if (!url) {
- addErrorAttribute(this, "Missing URL for Remote Filter.");
- return;
- }
-
- let filterValue;
-
- switch (this.getOption("filter.position")) {
- case FILTER_POSITION_INLINE:
- if (this[inlineFilterElementSymbol] instanceof HTMLElement) {
- filterValue = this[inlineFilterElementSymbol].value.toLowerCase();
- }
-
- break;
- case FILTER_POSITION_POPPER:
- default:
- if (this[popperFilterElementSymbol] instanceof HTMLInputElement) {
- filterValue = this[popperFilterElementSymbol].value.toLowerCase();
- }
- }
-
- return filterFromRemoteByValue.call(this, url, filterValue);
+ if (
+ !(this[inlineFilterElementSymbol] instanceof HTMLElement) &&
+ !(this[popperFilterElementSymbol] instanceof HTMLElement)
+ ) {
+ return;
+ }
+
+ show.call(this);
+
+ const url = this.getOption("url");
+ if (!url) {
+ addErrorAttribute(this, "Missing URL for Remote Filter.");
+ return;
+ }
+
+ let filterValue;
+
+ switch (this.getOption("filter.position")) {
+ case FILTER_POSITION_INLINE:
+ if (this[inlineFilterElementSymbol] instanceof HTMLElement) {
+ filterValue = this[inlineFilterElementSymbol].value.toLowerCase();
+ }
+
+ break;
+ case FILTER_POSITION_POPPER:
+ default:
+ if (this[popperFilterElementSymbol] instanceof HTMLInputElement) {
+ filterValue = this[popperFilterElementSymbol].value.toLowerCase();
+ }
+ }
+
+ return filterFromRemoteByValue.call(this, url, filterValue);
}
function formatURL(url, value) {
- if (value === undefined || value === null || value === "") {
- value = this.getOption("filter.defaultValue");
- if (value === undefined || value === null || value === "") {
- value = disabledRequestMarker.toString();
- }
- }
-
- const formatter = new Formatter({ filter: encodeURI(value) });
- const openMarker = this.getOption("filter.marker.open");
- let closeMarker = this.getOption("filter.marker.close");
- if (!closeMarker) {
- closeMarker = openMarker;
- }
-
- if (openMarker && closeMarker) {
- formatter.setMarker(openMarker, closeMarker);
- }
-
- return formatter.format(url);
+ if (value === undefined || value === null || value === "") {
+ value = this.getOption("filter.defaultValue");
+ if (value === undefined || value === null || value === "") {
+ value = disabledRequestMarker.toString();
+ }
+ }
+
+ const formatter = new Formatter({filter: encodeURI(value)});
+ const openMarker = this.getOption("filter.marker.open");
+ let closeMarker = this.getOption("filter.marker.close");
+ if (!closeMarker) {
+ closeMarker = openMarker;
+ }
+
+ if (openMarker && closeMarker) {
+ formatter.setMarker(openMarker, closeMarker);
+ }
+
+ return formatter.format(url);
}
/**
@@ -1777,28 +1792,28 @@ function formatURL(url, value) {
* @returns {Promise<unknown>}
*/
function filterFromRemoteByValue(optionUrl, value) {
- return new Processing(() => {
- let url = formatURL.call(this, optionUrl, value);
- if (url.indexOf(disabledRequestMarker.toString()) !== -1) {
- return;
- }
-
- fetchIt
- .call(this, url, {
- disableHiding: true,
- })
- .then(() => {
- checkOptionState.call(this);
- show.call(this);
- })
- .catch((e) => {
- throw e;
- });
- })
- .run()
- .catch((e) => {
- throw e;
- });
+ return new Processing(() => {
+ let url = formatURL.call(this, optionUrl, value);
+ if (url.indexOf(disabledRequestMarker.toString()) !== -1) {
+ return;
+ }
+
+ fetchIt
+ .call(this, url, {
+ disableHiding: true,
+ })
+ .then(() => {
+ checkOptionState.call(this);
+ show.call(this);
+ })
+ .catch((e) => {
+ throw e;
+ });
+ })
+ .run()
+ .catch((e) => {
+ throw e;
+ });
}
/**
@@ -1806,50 +1821,50 @@ function filterFromRemoteByValue(optionUrl, value) {
* @private
*/
function handleOptionKeyboardEvents(event) {
- const shiftKey = event?.["shiftKey"];
-
- switch (event?.["code"]) {
- case "Escape":
- toggle.call(this);
- event.preventDefault();
- break;
- case "Enter":
- case "Space":
- const path = event.composedPath();
- const element = path?.[0];
- if (element instanceof HTMLElement) {
- const input = element.getElementsByTagName("input");
- if (!input) {
- return;
- }
- fireEvent(input, "click");
- }
- event.preventDefault();
- break;
-
- case "Tab" && shiftKey === true:
- case "ArrowUp":
- activateCurrentOption.call(this, FOCUS_DIRECTION_UP);
- event.preventDefault();
- break;
-
- case "Tab" && !shiftKey:
- case "ArrowLeft":
- case "ArrowRight":
- // handled by tree select
- break;
- case "ArrowDown":
- activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
- event.preventDefault();
- break;
- default:
- const p = event.composedPath();
- if (p?.[0] instanceof HTMLInputElement) {
- return;
- }
- focusFilter.call(this);
- break;
- }
+ const shiftKey = event?.["shiftKey"];
+
+ switch (event?.["code"]) {
+ case "Escape":
+ toggle.call(this);
+ event.preventDefault();
+ break;
+ case "Enter":
+ case "Space":
+ const path = event.composedPath();
+ const element = path?.[0];
+ if (element instanceof HTMLElement) {
+ const input = element.getElementsByTagName("input");
+ if (!input) {
+ return;
+ }
+ fireEvent(input, "click");
+ }
+ event.preventDefault();
+ break;
+
+ case "Tab" && shiftKey === true:
+ case "ArrowUp":
+ activateCurrentOption.call(this, FOCUS_DIRECTION_UP);
+ event.preventDefault();
+ break;
+
+ case "Tab" && !shiftKey:
+ case "ArrowLeft":
+ case "ArrowRight":
+ // handled by tree select
+ break;
+ case "ArrowDown":
+ activateCurrentOption.call(this, FOCUS_DIRECTION_DOWN);
+ event.preventDefault();
+ break;
+ default:
+ const p = event.composedPath();
+ if (p?.[0] instanceof HTMLInputElement) {
+ return;
+ }
+ focusFilter.call(this);
+ break;
+ }
}
/**
@@ -1857,33 +1872,33 @@ function handleOptionKeyboardEvents(event) {
* @return {string}
*/
function getFilterMode() {
- switch (this.getOption("filter.mode")) {
- case FILTER_MODE_OPTIONS:
- return FILTER_MODE_OPTIONS;
- case FILTER_MODE_REMOTE:
- return FILTER_MODE_REMOTE;
- default:
- return FILTER_MODE_DISABLED;
- }
+ switch (this.getOption("filter.mode")) {
+ case FILTER_MODE_OPTIONS:
+ return FILTER_MODE_OPTIONS;
+ case FILTER_MODE_REMOTE:
+ return FILTER_MODE_REMOTE;
+ default:
+ return FILTER_MODE_DISABLED;
+ }
}
/**
* @private
*/
function blurFilter() {
- if (!(this[inlineFilterElementSymbol] instanceof HTMLElement)) {
- return;
- }
+ if (!(this[inlineFilterElementSymbol] instanceof HTMLElement)) {
+ return;
+ }
- if (getFilterMode.call(this) === FILTER_MODE_DISABLED) {
- return;
- }
+ if (getFilterMode.call(this) === FILTER_MODE_DISABLED) {
+ return;
+ }
- this[popperFilterContainerElementSymbol].classList.remove("active");
- this[popperFilterContainerElementSymbol].blur();
+ this[popperFilterContainerElementSymbol].classList.remove("active");
+ this[popperFilterContainerElementSymbol].blur();
- this[inlineFilterElementSymbol].classList.remove("active");
- this[inlineFilterElementSymbol].blur();
+ this[inlineFilterElementSymbol].classList.remove("active");
+ this[inlineFilterElementSymbol].blur();
}
/**
@@ -1891,25 +1906,25 @@ function blurFilter() {
* @param focusOptions
*/
function focusPopperFilter(focusOptions) {
- this[popperFilterContainerElementSymbol].classList.remove("d-none");
- this[popperFilterElementSymbol].classList.add("active");
- this[inlineFilterElementSymbol].classList.remove("active");
- this[inlineFilterElementSymbol].classList.add("d-none");
-
- if (!(this[popperFilterElementSymbol] instanceof HTMLElement)) {
- addErrorAttribute(this, "Missing Popper Filter Element.");
- return;
- }
-
- // visibility is set to visible, because focus() does not work on invisible elements
- // and the class definition is assigned later in the processing
- setTimeout(() => {
- if (focusOptions === undefined || focusOptions === null) {
- this[popperFilterElementSymbol].focus();
- } else {
- this[popperFilterElementSymbol].focus(focusOptions);
- }
- }, 100);
+ this[popperFilterContainerElementSymbol].classList.remove("d-none");
+ this[popperFilterElementSymbol].classList.add("active");
+ this[inlineFilterElementSymbol].classList.remove("active");
+ this[inlineFilterElementSymbol].classList.add("d-none");
+
+ if (!(this[popperFilterElementSymbol] instanceof HTMLElement)) {
+ addErrorAttribute(this, "Missing Popper Filter Element.");
+ return;
+ }
+
+ // visibility is set to visible, because focus() does not work on invisible elements
+ // and the class definition is assigned later in the processing
+ setTimeout(() => {
+ if (focusOptions === undefined || focusOptions === null) {
+ this[popperFilterElementSymbol].focus();
+ } else {
+ this[popperFilterElementSymbol].focus(focusOptions);
+ }
+ }, 100);
}
/**
@@ -1917,44 +1932,44 @@ function focusPopperFilter(focusOptions) {
* @param focusOptions
*/
function focusInlineFilter(focusOptions) {
- const options = this.getOption("options");
- if (
- (!isArray(options) || options.length === 0) &&
- getFilterMode.call(this) !== FILTER_MODE_REMOTE
- ) {
- return;
- }
-
- this[popperFilterContainerElementSymbol].classList.add("d-none");
- this[inlineFilterElementSymbol].classList.add("active");
- this[inlineFilterElementSymbol].classList.remove("d-none");
-
- // visibility is set to visible, because focus() does not work on invisible elements
- // and the class definition is assigned later in the processing
- setTimeout(() => {
- if (focusOptions === undefined || focusOptions === null) {
- this[inlineFilterElementSymbol].focus();
- } else {
- this[inlineFilterElementSymbol].focus(focusOptions);
- }
- }, 100);
+ const options = this.getOption("options");
+ if (
+ (!isArray(options) || options.length === 0) &&
+ getFilterMode.call(this) !== FILTER_MODE_REMOTE
+ ) {
+ return;
+ }
+
+ this[popperFilterContainerElementSymbol].classList.add("d-none");
+ this[inlineFilterElementSymbol].classList.add("active");
+ this[inlineFilterElementSymbol].classList.remove("d-none");
+
+ // visibility is set to visible, because focus() does not work on invisible elements
+ // and the class definition is assigned later in the processing
+ setTimeout(() => {
+ if (focusOptions === undefined || focusOptions === null) {
+ this[inlineFilterElementSymbol].focus();
+ } else {
+ this[inlineFilterElementSymbol].focus(focusOptions);
+ }
+ }, 100);
}
/**
* @private
*/
function focusFilter(focusOptions) {
- if (getFilterMode.call(this) === FILTER_MODE_DISABLED) {
- this[popperFilterContainerElementSymbol].classList.add("d-none");
- this[inlineFilterElementSymbol].classList.add("d-none");
- return;
- }
+ if (getFilterMode.call(this) === FILTER_MODE_DISABLED) {
+ this[popperFilterContainerElementSymbol].classList.add("d-none");
+ this[inlineFilterElementSymbol].classList.add("d-none");
+ return;
+ }
- if (this.getOption("filter.position") === FILTER_POSITION_INLINE) {
- return focusInlineFilter.call(this, focusOptions);
- }
+ if (this.getOption("filter.position") === FILTER_POSITION_INLINE) {
+ return focusInlineFilter.call(this, focusOptions);
+ }
- return focusPopperFilter.call(this, focusOptions);
+ return focusPopperFilter.call(this, focusOptions);
}
/**
@@ -1964,39 +1979,40 @@ function focusFilter(focusOptions) {
* @throws {Error} unsupported type
*/
function gatherState() {
- const type = this.getOption("type");
- if (["radio", "checkbox"].indexOf(type) === -1) {
- throw new Error("unsupported type");
- }
-
- if (!this.shadowRoot) {
- throw new Error("no shadow-root is defined");
- }
-
- const selection = [];
- const elements = this.shadowRoot.querySelectorAll(
- `input[type=${type}]:checked`,
- );
-
- for (const e of elements) {
- selection.push({
- label: getSelectionLabel.call(this, e.value),
- value: e.value,
- });
- }
-
- setSelection
- .call(this, selection)
- .then(() => {})
- .catch((e) => {
- addErrorAttribute(this, e);
- });
-
- if (this.getOption("features.closeOnSelect") === true) {
- toggle.call(this);
- }
-
- return this;
+ const type = this.getOption("type");
+ if (["radio", "checkbox"].indexOf(type) === -1) {
+ throw new Error("unsupported type");
+ }
+
+ if (!this.shadowRoot) {
+ throw new Error("no shadow-root is defined");
+ }
+
+ const selection = [];
+ const elements = this.shadowRoot.querySelectorAll(
+ `input[type=${type}]:checked`,
+ );
+
+ for (const e of elements) {
+ selection.push({
+ label: getSelectionLabel.call(this, e.value),
+ value: e.value,
+ });
+ }
+
+ setSelection
+ .call(this, selection)
+ .then(() => {
+ })
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+
+ if (this.getOption("features.closeOnSelect") === true) {
+ toggle.call(this);
+ }
+
+ return this;
}
/**
@@ -2005,120 +2021,121 @@ function gatherState() {
* @throws {Error} unsupported type
*/
function clearSelection() {
- const type = this.getOption("type");
- if (["radio", "checkbox"].indexOf(type) === -1) {
- throw new Error("unsupported type");
- }
-
- if (!this.shadowRoot) {
- throw new Error("no shadow-root is defined");
- }
-
- setSelection
- .call(this, [])
- .then(() => {})
- .catch((e) => {
- addErrorAttribute(this, e);
- });
+ const type = this.getOption("type");
+ if (["radio", "checkbox"].indexOf(type) === -1) {
+ throw new Error("unsupported type");
+ }
+
+ if (!this.shadowRoot) {
+ throw new Error("no shadow-root is defined");
+ }
+
+ setSelection
+ .call(this, [])
+ .then(() => {
+ })
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
}
/**
* @private
*/
function areOptionsAvailableAndInit() {
- // prevent multiple calls
- if (this[areOptionsAvailableAndInitSymbol] === undefined) {
- this[areOptionsAvailableAndInitSymbol] = 0;
- }
-
- if (this[areOptionsAvailableAndInitSymbol] > 0) {
- this[areOptionsAvailableAndInitSymbol]--;
- return true;
- }
-
- this[areOptionsAvailableAndInitSymbol]++;
-
- const options = this.getOption("options");
-
- if (
- options === undefined ||
- options === null ||
- (isArray(options) && options.length === 0)
- ) {
- setStatusOrRemoveBadges.call(this, "empty");
-
- // hide.call(this);
-
- let msg = this.getOption("labels.no-options-available");
-
- if (
- this.getOption("url") !== null &&
- this.getOption("features.lazyLoad") === true &&
- this[lazyLoadDoneSymbol] !== true
- ) {
- msg = this.getOption("labels.click-to-load-options");
- }
-
- this.setOption("messages.control", msg);
- this.setOption("messages.summary", "");
-
- if (this.getOption("features.emptyValueIfNoOptions") === true) {
- this.value = "";
- }
- addErrorAttribute(this, "No options available.");
- return false;
- }
-
- const selections = this.getOption("selection");
- if (
- selections === undefined ||
- selections === null ||
- selections.length === 0
- ) {
- this.setOption(
- "messages.control",
- this.getOption("labels.select-an-option"),
- );
- } else {
- this.setOption("messages.control", "");
- }
-
- this.setOption("messages.summary", setSummaryAndControlText.call(this));
-
- let updated = false;
- let valueCounter = 1;
- for (const option of options) {
- if (option?.visibility === undefined) {
- option.visibility = "visible";
- updated = true;
- }
-
- if (option?.value === undefined && option?.label === undefined) {
- option.value = `${valueCounter++}`;
- option.label = option.value;
- updated = true;
- continue;
- }
-
- if (option?.value === undefined) {
- option.value = option.label;
- updated = true;
- }
-
- if (option?.label === undefined) {
- option.label = option.value;
- updated = true;
- }
- }
-
- if (updated) {
- this.setOption("options", options);
- }
-
- setStatusOrRemoveBadges.call(this);
-
- removeErrorAttribute(this, "No options available.");
- return true;
+ // prevent multiple calls
+ if (this[areOptionsAvailableAndInitSymbol] === undefined) {
+ this[areOptionsAvailableAndInitSymbol] = 0;
+ }
+
+ if (this[areOptionsAvailableAndInitSymbol] > 0) {
+ this[areOptionsAvailableAndInitSymbol]--;
+ return true;
+ }
+
+ this[areOptionsAvailableAndInitSymbol]++;
+
+ const options = this.getOption("options");
+
+ if (
+ options === undefined ||
+ options === null ||
+ (isArray(options) && options.length === 0)
+ ) {
+ setStatusOrRemoveBadges.call(this, "empty");
+
+ // hide.call(this);
+
+ let msg = this.getOption("labels.no-options-available");
+
+ if (
+ this.getOption("url") !== null &&
+ this.getOption("features.lazyLoad") === true &&
+ this[lazyLoadDoneSymbol] !== true
+ ) {
+ msg = this.getOption("labels.click-to-load-options");
+ }
+
+ this.setOption("messages.control", msg);
+ this.setOption("messages.summary", "");
+
+ if (this.getOption("features.emptyValueIfNoOptions") === true) {
+ this.value = "";
+ }
+ addErrorAttribute(this, "No options available.");
+ return false;
+ }
+
+ const selections = this.getOption("selection");
+ if (
+ selections === undefined ||
+ selections === null ||
+ selections.length === 0
+ ) {
+ this.setOption(
+ "messages.control",
+ this.getOption("labels.select-an-option"),
+ );
+ } else {
+ this.setOption("messages.control", "");
+ }
+
+ this.setOption("messages.summary", setSummaryAndControlText.call(this));
+
+ let updated = false;
+ let valueCounter = 1;
+ for (const option of options) {
+ if (option?.visibility === undefined) {
+ option.visibility = "visible";
+ updated = true;
+ }
+
+ if (option?.value === undefined && option?.label === undefined) {
+ option.value = `${valueCounter++}`;
+ option.label = option.value;
+ updated = true;
+ continue;
+ }
+
+ if (option?.value === undefined) {
+ option.value = option.label;
+ updated = true;
+ }
+
+ if (option?.label === undefined) {
+ option.label = option.value;
+ updated = true;
+ }
+ }
+
+ if (updated) {
+ this.setOption("options", options);
+ }
+
+ setStatusOrRemoveBadges.call(this);
+
+ removeErrorAttribute(this, "No options available.");
+ return true;
}
/**
@@ -2126,30 +2143,30 @@ function areOptionsAvailableAndInit() {
* @throws {Error} no shadow-root is defined
*/
function checkOptionState() {
- if (!this.shadowRoot) {
- throw new Error("no shadow-root is defined");
- }
-
- const elements = this.shadowRoot.querySelectorAll(
- `[${ATTRIBUTE_ROLE}=option] input`,
- );
-
- let selection = this.getOption("selection");
- if (!isArray(selection)) {
- selection = [];
- }
-
- const checkedValues = selection.map((a) => {
- return a.value;
- });
-
- for (const e of elements) {
- if (checkedValues.indexOf(e.value) !== -1) {
- if (e.checked !== true) e.checked = true;
- } else {
- if (e.checked !== false) e.checked = false;
- }
- }
+ if (!this.shadowRoot) {
+ throw new Error("no shadow-root is defined");
+ }
+
+ const elements = this.shadowRoot.querySelectorAll(
+ `[${ATTRIBUTE_ROLE}=option] input`,
+ );
+
+ let selection = this.getOption("selection");
+ if (!isArray(selection)) {
+ selection = [];
+ }
+
+ const checkedValues = selection.map((a) => {
+ return a.value;
+ });
+
+ for (const e of elements) {
+ if (checkedValues.indexOf(e.value) !== -1) {
+ if (e.checked !== true) e.checked = true;
+ } else {
+ if (e.checked !== false) e.checked = false;
+ }
+ }
}
/**
@@ -2158,41 +2175,41 @@ function checkOptionState() {
* @return {Object}
*/
function convertValueToSelection(value) {
- const selection = [];
-
- if (isString(value)) {
- value = value
- .split(",")
- .map((a) => {
- return a.trim();
- })
- .filter((a) => {
- return a !== "";
- });
- }
-
- if (isString(value) || isInteger(value)) {
- selection.push({
- label: getSelectionLabel.call(this, value),
- value: value,
- });
- } else if (isArray(value)) {
+ const selection = [];
+
+ if (isString(value)) {
+ value = value
+ .split(",")
+ .map((a) => {
+ return a.trim();
+ })
+ .filter((a) => {
+ return a !== "";
+ });
+ }
+
+ if (isString(value) || isInteger(value)) {
+ selection.push({
+ label: getSelectionLabel.call(this, value),
+ value: value,
+ });
+ } else if (isArray(value)) {
for (const v of value) {
- selection.push({
- label: getSelectionLabel.call(this, v),
- value: v,
- });
- }
-
- value = value.join(",");
- } else {
- throw new Error("unsupported type");
- }
-
- return {
- selection: selection,
- value: value,
- };
+ selection.push({
+ label: getSelectionLabel.call(this, v),
+ value: v,
+ });
+ }
+
+ value = value.join(",");
+ } else {
+ throw new Error("unsupported type");
+ }
+
+ return {
+ selection: selection,
+ value: value,
+ };
}
/**
@@ -2201,104 +2218,127 @@ function convertValueToSelection(value) {
* @return {string}
*/
function convertSelectionToValue(selection) {
- const value = [];
-
- if (isArray(selection)) {
- for (const obj of selection) {
- const v = obj?.["value"];
- if (v !== undefined) value.push(`${v}`);
- }
- }
-
- if (value.length === 0) {
- return "";
- } else if (value.length === 1) {
- const v = value.pop();
- if (v === undefined) return "";
- if (v === null) return "";
- return `${v}`;
- }
-
- return value.join(",");
+ const value = [];
+
+ if (isArray(selection)) {
+ for (const obj of selection) {
+ const v = obj?.["value"];
+ if (v !== undefined) value.push(`${v}`);
+ }
+ }
+
+ if (value.length === 0) {
+ return "";
+ } else if (value.length === 1) {
+ const v = value.pop();
+ if (v === undefined) return "";
+ if (v === null) return "";
+ return `${v}`;
+ }
+
+ return value.join(",");
}
/**
* @private
- * @param {array} selection
+ * @param {array|string} selection
* @return {Promise}
* @throws {Error} no shadow-root is defined
*/
function setSelection(selection) {
- if (isString(selection) || isInteger(selection)) {
- const result = convertValueToSelection.call(this, selection);
- selection = result?.selection;
- } else if (selection === undefined || selection === null) {
- selection = [];
- }
-
- validateArray(selection);
-
- for (let i = 0; i < selection.length; i++) {
- let l = getSelectionLabel.call(this, selection[i].value);
- if (l === selection[i].value) {
- l = selection[i].label;
- }
-
- selection[i] = {
- label: l,
- value: selection[i].value,
- };
- }
-
- this.setOption("selection", selection);
- checkOptionState.call(this);
- setSummaryAndControlText.call(this);
-
- try {
- this?.setFormValue(this.value);
- } catch (e) {
- addErrorAttribute(this, e);
- }
-
- fireCustomEvent(this, "monster-selected", {
- selection,
- });
-
- fireEvent(this, "change");
-
- return new Processing(() => {
- const CLASSNAME = "selected";
-
- if (!this.shadowRoot) {
- throw new Error("no shadow-root is defined");
- }
-
- const notSelected = this.shadowRoot.querySelectorAll(":not(:checked)");
-
- if (notSelected) {
- notSelected.forEach((node) => {
- const parent = node.closest(`[${ATTRIBUTE_ROLE}=option]`);
- if (parent) {
- parent.classList.remove(CLASSNAME);
- }
- });
- }
-
- const selected = this.shadowRoot.querySelectorAll(":checked");
-
- if (selected) {
- selected.forEach((node) => {
- const parent = node.closest(`[${ATTRIBUTE_ROLE}=option]`);
- if (parent) {
- parent.classList.add(CLASSNAME);
- }
- });
- }
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
+
+ if (isString(selection) || isInteger(selection)) {
+ const result = convertValueToSelection.call(this, selection);
+ selection = result?.selection;
+ } else if (selection === undefined || selection === null) {
+ selection = [];
+ }
+
+ validateArray(selection);
+ let ignoreValues = this.getOption("ignoreValues", []);
+ if(!isArray(ignoreValues)) {
+ ignoreValues = [];
+ }
+
+ let resultSelection = [];
+ for (let i = 0; i < selection.length; i++) {
+
+ let ignore = false;
+
+ for (const v of ignoreValues) {
+ if (selection[i].value === v) {
+ ignore = true
+ break;
+ }
+ }
+ if (ignore) {
+ continue;
+ }
+
+ let l = getSelectionLabel.call(this, selection[i].value);
+ if (l === selection[i].value) {
+ l = selection[i].label;
+ }
+
+
+ resultSelection.push({
+ label: l,
+ value: selection[i].value,
+ })
+
+ }
+
+ selection = resultSelection;
+
+ this.setOption("selection", selection);
+ checkOptionState.call(this);
+ setSummaryAndControlText.call(this);
+
+ try {
+ this?.setFormValue(this.value);
+ } catch (e) {
+ addErrorAttribute(this, e);
+ }
+
+ fireCustomEvent(this, "monster-selected", {
+ selection,
+ });
+
+ fireEvent(this, "change");
+
+ return new Processing(() => {
+ const CLASSNAME = "selected";
+
+ if (!this.shadowRoot) {
+ throw new Error("no shadow-root is defined");
+ }
+
+ const notSelected = this.shadowRoot.querySelectorAll(":not(:checked)");
+
+ if (notSelected) {
+ notSelected.forEach((node) => {
+ const parent = node.closest(`[${ATTRIBUTE_ROLE}=option]`);
+ if (parent) {
+ parent.classList.remove(CLASSNAME);
+ }
+ });
+ }
+
+ const selected = this.shadowRoot.querySelectorAll(":checked");
+
+ if (selected) {
+ selected.forEach((node) => {
+ const parent = node.closest(`[${ATTRIBUTE_ROLE}=option]`);
+ if (parent) {
+ parent.classList.add(CLASSNAME);
+ }
+ });
+ }
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
}
/**
@@ -2309,139 +2349,139 @@ function setSelection(selection) {
* @throws {TypeError} unsupported response
*/
function fetchData(url) {
- const self = this;
- if (!url) url = this.getOption("url");
- if (!url) return Promise.resolve();
-
- const fetchOptions = this.getOption("fetch", {});
-
- let delayWatch = false;
-
- // if fetch short time, do not show loading badge, because of flickering
- requestAnimationFrame(() => {
- if (delayWatch === true) return;
- setStatusOrRemoveBadges.call(this, "loading");
- delayWatch = true;
- });
-
- url = formatURL.call(this, url);
-
- self[isLoadingSymbol] = true;
- const global = getGlobal();
- return global
- .fetch(url, fetchOptions)
- .then((response) => {
- self[isLoadingSymbol] = false;
- delayWatch = true;
- const contentType = response.headers.get("content-type");
- if (contentType && contentType.indexOf("application/json") !== -1) {
- return response.text();
- }
-
- throw new TypeError(`unsupported response ${contentType}`);
- })
- .then((text) => {
- try {
- return Promise.resolve(JSON.parse(String(text)));
- } catch (e) {
- throw new TypeError("the result cannot be parsed, check the URL");
- }
- })
- .catch((e) => {
- self[isLoadingSymbol] = false;
- delayWatch = true;
- throw e;
- });
+ const self = this;
+ if (!url) url = this.getOption("url");
+ if (!url) return Promise.resolve();
+
+ const fetchOptions = this.getOption("fetch", {});
+
+ let delayWatch = false;
+
+ // if fetch short time, do not show loading badge, because of flickering
+ requestAnimationFrame(() => {
+ if (delayWatch === true) return;
+ setStatusOrRemoveBadges.call(this, "loading");
+ delayWatch = true;
+ });
+
+ url = formatURL.call(this, url);
+
+ self[isLoadingSymbol] = true;
+ const global = getGlobal();
+ return global
+ .fetch(url, fetchOptions)
+ .then((response) => {
+ self[isLoadingSymbol] = false;
+ delayWatch = true;
+ const contentType = response.headers.get("content-type");
+ if (contentType && contentType.indexOf("application/json") !== -1) {
+ return response.text();
+ }
+
+ throw new TypeError(`unsupported response ${contentType}`);
+ })
+ .then((text) => {
+ try {
+ return Promise.resolve(JSON.parse(String(text)));
+ } catch (e) {
+ throw new TypeError("the result cannot be parsed, check the URL");
+ }
+ })
+ .catch((e) => {
+ self[isLoadingSymbol] = false;
+ delayWatch = true;
+ throw e;
+ });
}
/**
* @private
*/
function hide() {
- this[popperElementSymbol].style.display = "none";
- setStatusOrRemoveBadges.call(this, "closed");
- removeAttributeToken(this[controlElementSymbol], "class", "open");
+ this[popperElementSymbol].style.display = "none";
+ setStatusOrRemoveBadges.call(this, "closed");
+ removeAttributeToken(this[controlElementSymbol], "class", "open");
}
/**
* @private
*/
function show() {
- if (this.getOption("disabled", undefined) === true) {
- return;
- }
-
- if (this[popperElementSymbol].style.display === STYLE_DISPLAY_MODE_BLOCK) {
- return;
- }
-
- focusFilter.call(this);
-
- const lazyLoadFlag =
- this.getOption("features.lazyLoad") && this[lazyLoadDoneSymbol] !== true;
-
- if (lazyLoadFlag === true) {
- this[lazyLoadDoneSymbol] = true;
- setStatusOrRemoveBadges.call(this, "loading");
-
- new Processing(200, () => {
- this.fetch()
- .then(() => {
- checkOptionState.call(this);
- requestAnimationFrame(() => {
- show.call(this);
- });
- })
- .catch((e) => {
- addErrorAttribute(this, e);
- setStatusOrRemoveBadges.call(this, "error");
- });
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- setStatusOrRemoveBadges.call(this, "error");
- });
-
- return;
- }
-
- const hasPopperFilterFlag =
- this.getOption("filter.position") === FILTER_POSITION_POPPER &&
- getFilterMode.call(this) !== FILTER_MODE_DISABLED;
-
- const options = getOptionElements.call(this);
- if (options.length === 0 && hasPopperFilterFlag === false) {
- return;
- }
-
- this[popperElementSymbol].style.visibility = "hidden";
- this[popperElementSymbol].style.display = STYLE_DISPLAY_MODE_BLOCK;
- setStatusOrRemoveBadges.call(this, "open");
-
- addAttributeToken(this[controlElementSymbol], "class", "open");
-
- new Processing(() => {
- calcAndSetOptionsDimension.call(this);
- focusFilter.call(this);
- this[popperElementSymbol].style.removeProperty("visibility");
- updatePopper.call(this);
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
+ if (this.getOption("disabled", undefined) === true) {
+ return;
+ }
+
+ if (this[popperElementSymbol].style.display === STYLE_DISPLAY_MODE_BLOCK) {
+ return;
+ }
+
+ focusFilter.call(this);
+
+ const lazyLoadFlag =
+ this.getOption("features.lazyLoad") && this[lazyLoadDoneSymbol] !== true;
+
+ if (lazyLoadFlag === true) {
+ this[lazyLoadDoneSymbol] = true;
+ setStatusOrRemoveBadges.call(this, "loading");
+
+ new Processing(200, () => {
+ this.fetch()
+ .then(() => {
+ checkOptionState.call(this);
+ requestAnimationFrame(() => {
+ show.call(this);
+ });
+ })
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ setStatusOrRemoveBadges.call(this, "error");
+ });
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ setStatusOrRemoveBadges.call(this, "error");
+ });
+
+ return;
+ }
+
+ const hasPopperFilterFlag =
+ this.getOption("filter.position") === FILTER_POSITION_POPPER &&
+ getFilterMode.call(this) !== FILTER_MODE_DISABLED;
+
+ const options = getOptionElements.call(this);
+ if (options.length === 0 && hasPopperFilterFlag === false) {
+ return;
+ }
+
+ this[popperElementSymbol].style.visibility = "hidden";
+ this[popperElementSymbol].style.display = STYLE_DISPLAY_MODE_BLOCK;
+ setStatusOrRemoveBadges.call(this, "open");
+
+ addAttributeToken(this[controlElementSymbol], "class", "open");
+
+ new Processing(() => {
+ calcAndSetOptionsDimension.call(this);
+ focusFilter.call(this);
+ this[popperElementSymbol].style.removeProperty("visibility");
+ updatePopper.call(this);
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
}
/**
* @private
*/
function toggle() {
- if (this[popperElementSymbol].style.display === STYLE_DISPLAY_MODE_BLOCK) {
- hide.call(this);
- } else {
- show.call(this);
- }
+ if (this[popperElementSymbol].style.display === STYLE_DISPLAY_MODE_BLOCK) {
+ hide.call(this);
+ } else {
+ show.call(this);
+ }
}
/**
@@ -2450,188 +2490,188 @@ function toggle() {
* @fires monster-selection-cleared
*/
function initEventHandler() {
- const self = this;
-
- /**
- * @param {Event} event
- */
- self[clearOptionEventHandler] = (event) => {
- const element = findTargetElementFromEvent(
- event,
- ATTRIBUTE_ROLE,
- "remove-badge",
- );
-
- if (element instanceof HTMLElement) {
- const badge = findClosestByAttribute(element, ATTRIBUTE_ROLE, "badge");
- if (badge instanceof HTMLElement) {
- const value = badge.getAttribute(`${ATTRIBUTE_PREFIX}value`);
-
- let selection = self.getOption("selection");
- selection = selection.filter((b) => {
- return value !== b.value;
- });
-
- setSelection
- .call(self, selection)
- .then(() => {
- fireCustomEvent(self, "monster-selection-removed", {
- value,
- });
- })
- .catch((e) => {
- addErrorAttribute(self, e);
- });
- }
- }
- };
-
- /**
- * @param {Event} event
- */
- self[closeEventHandler] = (event) => {
- const path = event.composedPath();
-
- for (const [, element] of Object.entries(path)) {
- if (element === self) {
- return;
- }
- }
- hide.call(self);
- };
-
- /**
- * @param {Event} event
- */
- self[inputEventHandler] = (event) => {
- const path = event.composedPath();
- const element = path?.[0];
-
- if (element instanceof HTMLElement) {
- if (
- element.hasAttribute(ATTRIBUTE_ROLE) &&
- element.getAttribute(ATTRIBUTE_ROLE) === "option-control"
- ) {
- fireCustomEvent(self, "monster-change", {
- type: event.type,
- value: element.value,
- checked: element.checked,
- });
- } else if (
- element.hasAttribute(ATTRIBUTE_ROLE) &&
- element.getAttribute(ATTRIBUTE_ROLE) === "filter"
- ) {
- }
- }
- };
-
- /**
- * @param {Event} event
- */
- self[changeEventHandler] = (event) => {
- gatherState.call(self);
- fireCustomEvent(self, "monster-changed", event?.detail);
- };
-
- self[keyEventHandler] = (event) => {
- const path = event.composedPath();
- const element = path.shift();
-
- let role;
-
- if (element instanceof HTMLElement) {
- if (element.hasAttribute(ATTRIBUTE_ROLE)) {
- role = element.getAttribute(ATTRIBUTE_ROLE);
- } else if (element === this) {
- show.call(this);
- // focusFilter.call(self);
- } else {
- const e = element.closest(`[${ATTRIBUTE_ROLE}]`);
- if (e instanceof HTMLElement && e.hasAttribute(ATTRIBUTE_ROLE)) {
- role = e.getAttribute(ATTRIBUTE_ROLE);
- }
- }
- } else {
- return;
- }
-
- switch (role) {
- case "filter":
- handleFilterKeyboardEvents.call(self, event);
- break;
- case "option-label":
- case "option-control":
- case "option":
- handleOptionKeyboardEvents.call(self, event);
- break;
- case "control":
- case "toggle":
- handleToggleKeyboardEvents.call(self, event);
- break;
- }
- };
-
- const types = self.getOption("toggleEventType", ["click"]);
-
- for (const [, type] of Object.entries(types)) {
- self[controlElementSymbol]
- .querySelector(`[${ATTRIBUTE_ROLE}="container"]`)
- .addEventListener(type, function (event) {
- const element = findTargetElementFromEvent(
- event,
- ATTRIBUTE_ROLE,
- "remove-badge",
- );
- if (element instanceof HTMLElement) {
- return;
- }
-
- toggle.call(self);
- });
-
- self[controlElementSymbol]
- .querySelector(`[${ATTRIBUTE_ROLE}="status-or-remove-badges"]`)
- .addEventListener(type, function (event) {
- if (self.getOption("disabled", undefined) === true) {
- return;
- }
-
- const path = event.composedPath();
- const element = path?.[0];
- if (element instanceof HTMLElement) {
- const control = element.closest(
- `[${ATTRIBUTE_ROLE}="status-or-remove-badges"]`,
- );
- if (control instanceof HTMLElement) {
- if (control.classList.contains("clear")) {
- clearSelection.call(self);
-
- fireCustomEvent(self, "monster-selection-cleared", {});
- } else {
- const element = findTargetElementFromEvent(
- event,
- ATTRIBUTE_ROLE,
- "remove-badge",
- );
- if (element instanceof HTMLElement) {
- return;
- }
-
- toggle.call(self);
- }
- }
- }
- });
-
- // badge, selection
- self.addEventListener(type, self[clearOptionEventHandler]);
- }
-
- self.addEventListener("monster-change", self[changeEventHandler]);
- self.addEventListener("input", self[inputEventHandler]);
- self.addEventListener("keydown", self[keyEventHandler]);
-
- return self;
+ const self = this;
+
+ /**
+ * @param {Event} event
+ */
+ self[clearOptionEventHandler] = (event) => {
+ const element = findTargetElementFromEvent(
+ event,
+ ATTRIBUTE_ROLE,
+ "remove-badge",
+ );
+
+ if (element instanceof HTMLElement) {
+ const badge = findClosestByAttribute(element, ATTRIBUTE_ROLE, "badge");
+ if (badge instanceof HTMLElement) {
+ const value = badge.getAttribute(`${ATTRIBUTE_PREFIX}value`);
+
+ let selection = self.getOption("selection");
+ selection = selection.filter((b) => {
+ return value !== b.value;
+ });
+
+ setSelection
+ .call(self, selection)
+ .then(() => {
+ fireCustomEvent(self, "monster-selection-removed", {
+ value,
+ });
+ })
+ .catch((e) => {
+ addErrorAttribute(self, e);
+ });
+ }
+ }
+ };
+
+ /**
+ * @param {Event} event
+ */
+ self[closeEventHandler] = (event) => {
+ const path = event.composedPath();
+
+ for (const [, element] of Object.entries(path)) {
+ if (element === self) {
+ return;
+ }
+ }
+ hide.call(self);
+ };
+
+ /**
+ * @param {Event} event
+ */
+ self[inputEventHandler] = (event) => {
+ const path = event.composedPath();
+ const element = path?.[0];
+
+ if (element instanceof HTMLElement) {
+ if (
+ element.hasAttribute(ATTRIBUTE_ROLE) &&
+ element.getAttribute(ATTRIBUTE_ROLE) === "option-control"
+ ) {
+ fireCustomEvent(self, "monster-change", {
+ type: event.type,
+ value: element.value,
+ checked: element.checked,
+ });
+ } else if (
+ element.hasAttribute(ATTRIBUTE_ROLE) &&
+ element.getAttribute(ATTRIBUTE_ROLE) === "filter"
+ ) {
+ }
+ }
+ };
+
+ /**
+ * @param {Event} event
+ */
+ self[changeEventHandler] = (event) => {
+ gatherState.call(self);
+ fireCustomEvent(self, "monster-changed", event?.detail);
+ };
+
+ self[keyEventHandler] = (event) => {
+ const path = event.composedPath();
+ const element = path.shift();
+
+ let role;
+
+ if (element instanceof HTMLElement) {
+ if (element.hasAttribute(ATTRIBUTE_ROLE)) {
+ role = element.getAttribute(ATTRIBUTE_ROLE);
+ } else if (element === this) {
+ show.call(this);
+ // focusFilter.call(self);
+ } else {
+ const e = element.closest(`[${ATTRIBUTE_ROLE}]`);
+ if (e instanceof HTMLElement && e.hasAttribute(ATTRIBUTE_ROLE)) {
+ role = e.getAttribute(ATTRIBUTE_ROLE);
+ }
+ }
+ } else {
+ return;
+ }
+
+ switch (role) {
+ case "filter":
+ handleFilterKeyboardEvents.call(self, event);
+ break;
+ case "option-label":
+ case "option-control":
+ case "option":
+ handleOptionKeyboardEvents.call(self, event);
+ break;
+ case "control":
+ case "toggle":
+ handleToggleKeyboardEvents.call(self, event);
+ break;
+ }
+ };
+
+ const types = self.getOption("toggleEventType", ["click"]);
+
+ for (const [, type] of Object.entries(types)) {
+ self[controlElementSymbol]
+ .querySelector(`[${ATTRIBUTE_ROLE}="container"]`)
+ .addEventListener(type, function (event) {
+ const element = findTargetElementFromEvent(
+ event,
+ ATTRIBUTE_ROLE,
+ "remove-badge",
+ );
+ if (element instanceof HTMLElement) {
+ return;
+ }
+
+ toggle.call(self);
+ });
+
+ self[controlElementSymbol]
+ .querySelector(`[${ATTRIBUTE_ROLE}="status-or-remove-badges"]`)
+ .addEventListener(type, function (event) {
+ if (self.getOption("disabled", undefined) === true) {
+ return;
+ }
+
+ const path = event.composedPath();
+ const element = path?.[0];
+ if (element instanceof HTMLElement) {
+ const control = element.closest(
+ `[${ATTRIBUTE_ROLE}="status-or-remove-badges"]`,
+ );
+ if (control instanceof HTMLElement) {
+ if (control.classList.contains("clear")) {
+ clearSelection.call(self);
+
+ fireCustomEvent(self, "monster-selection-cleared", {});
+ } else {
+ const element = findTargetElementFromEvent(
+ event,
+ ATTRIBUTE_ROLE,
+ "remove-badge",
+ );
+ if (element instanceof HTMLElement) {
+ return;
+ }
+
+ toggle.call(self);
+ }
+ }
+ }
+ });
+
+ // badge, selection
+ self.addEventListener(type, self[clearOptionEventHandler]);
+ }
+
+ self.addEventListener("monster-change", self[changeEventHandler]);
+ self.addEventListener("input", self[inputEventHandler]);
+ self.addEventListener("keydown", self[keyEventHandler]);
+
+ return self;
}
/**
@@ -2639,70 +2679,70 @@ function initEventHandler() {
* @return {Select}
*/
function setStatusOrRemoveBadges(suggestion) {
- requestAnimationFrame(() => {
- const selection = this.getOption("selection");
-
- const clearAllFlag =
- isArray(selection) &&
- selection.length > 0 &&
- this.getOption("features.clearAll") === true;
-
- const current = this.getOption("classes.statusOrRemoveBadge");
-
- if (suggestion === "error") {
- if (current !== "error") {
- this.setOption("classes.statusOrRemoveBadge", "error");
- }
- return;
- }
-
- if (this[isLoadingSymbol] === true) {
- if (current !== "loading") {
- this.setOption("classes.statusOrRemoveBadge", "loading");
- }
- return;
- }
-
- if (suggestion === "loading") {
- if (current !== "loading") {
- this.setOption("classes.statusOrRemoveBadge", "loading");
- }
- return;
- }
-
- if (clearAllFlag) {
- if (current !== "clear") {
- this.setOption("classes.statusOrRemoveBadge", "clear");
- }
- return;
- }
-
- if (this[controlElementSymbol].classList.contains("open")) {
- if (current !== "open") {
- this.setOption("classes.statusOrRemoveBadge", "open");
- }
- return;
- }
-
- const options = this.getOption("options");
- if (
- options === undefined ||
- options === null ||
- (isArray(options) && options.length === 0)
- ) {
- if (current !== "empty") {
- this.setOption("classes.statusOrRemoveBadge", "empty");
- }
- return;
- }
-
- if (suggestion) {
- if (current !== suggestion) {
- this.setOption("classes.statusOrRemoveBadge", suggestion);
- }
- return;
- }
- });
+ requestAnimationFrame(() => {
+ const selection = this.getOption("selection");
+
+ const clearAllFlag =
+ isArray(selection) &&
+ selection.length > 0 &&
+ this.getOption("features.clearAll") === true;
+
+ const current = this.getOption("classes.statusOrRemoveBadge");
+
+ if (suggestion === "error") {
+ if (current !== "error") {
+ this.setOption("classes.statusOrRemoveBadge", "error");
+ }
+ return;
+ }
+
+ if (this[isLoadingSymbol] === true) {
+ if (current !== "loading") {
+ this.setOption("classes.statusOrRemoveBadge", "loading");
+ }
+ return;
+ }
+
+ if (suggestion === "loading") {
+ if (current !== "loading") {
+ this.setOption("classes.statusOrRemoveBadge", "loading");
+ }
+ return;
+ }
+
+ if (clearAllFlag) {
+ if (current !== "clear") {
+ this.setOption("classes.statusOrRemoveBadge", "clear");
+ }
+ return;
+ }
+
+ if (this[controlElementSymbol].classList.contains("open")) {
+ if (current !== "open") {
+ this.setOption("classes.statusOrRemoveBadge", "open");
+ }
+ return;
+ }
+
+ const options = this.getOption("options");
+ if (
+ options === undefined ||
+ options === null ||
+ (isArray(options) && options.length === 0)
+ ) {
+ if (current !== "empty") {
+ this.setOption("classes.statusOrRemoveBadge", "empty");
+ }
+ return;
+ }
+
+ if (suggestion) {
+ if (current !== suggestion) {
+ this.setOption("classes.statusOrRemoveBadge", suggestion);
+ }
+ return;
+ }
+ });
}
/**
@@ -2711,68 +2751,68 @@ function setStatusOrRemoveBadges(suggestion) {
* @throws {Error} no shadow-root is defined
*/
function initControlReferences() {
- if (!this.shadowRoot) {
- throw new Error("no shadow-root is defined");
- }
-
- this[controlElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=control]`,
- );
- this[selectionElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=selection]`,
- );
- this[containerElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=container]`,
- );
- this[popperElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=popper]`,
- );
- this[inlineFilterElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=filter][name="inline-filter"]`,
- );
- this[popperFilterElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=filter][name="popper-filter"]`,
- );
- this[popperFilterContainerElementSymbol] =
- this[popperFilterElementSymbol].parentElement;
- this[optionsElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=options]`,
- );
- this[noOptionsAvailableElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}="no-options"]`,
- );
- this[statusOrRemoveBadgesElementSymbol] = this.shadowRoot.querySelector(
- `[${ATTRIBUTE_ROLE}=status-or-remove-badges]`,
- );
+ if (!this.shadowRoot) {
+ throw new Error("no shadow-root is defined");
+ }
+
+ this[controlElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=control]`,
+ );
+ this[selectionElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=selection]`,
+ );
+ this[containerElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=container]`,
+ );
+ this[popperElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=popper]`,
+ );
+ this[inlineFilterElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=filter][name="inline-filter"]`,
+ );
+ this[popperFilterElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=filter][name="popper-filter"]`,
+ );
+ this[popperFilterContainerElementSymbol] =
+ this[popperFilterElementSymbol].parentElement;
+ this[optionsElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=options]`,
+ );
+ this[noOptionsAvailableElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}="no-options"]`,
+ );
+ this[statusOrRemoveBadgesElementSymbol] = this.shadowRoot.querySelector(
+ `[${ATTRIBUTE_ROLE}=status-or-remove-badges]`,
+ );
}
/**
* @private
*/
function updatePopper() {
- if (this[popperElementSymbol].style.display !== STYLE_DISPLAY_MODE_BLOCK) {
- return;
- }
-
- if (this.getOption("disabled", false) === true) {
- return;
- }
-
- new Processing(() => {
- calcAndSetOptionsDimension.call(this);
- positionPopper.call(
- this,
- this[controlElementSymbol],
- this[popperElementSymbol],
- this.getOption("popper", {}),
- );
- })
- .run()
- .catch((e) => {
- addErrorAttribute(this, e);
- });
-
- return this;
+ if (this[popperElementSymbol].style.display !== STYLE_DISPLAY_MODE_BLOCK) {
+ return;
+ }
+
+ if (this.getOption("disabled", false) === true) {
+ return;
+ }
+
+ new Processing(() => {
+ calcAndSetOptionsDimension.call(this);
+ positionPopper.call(
+ this,
+ this[controlElementSymbol],
+ this[popperElementSymbol],
+ this.getOption("popper", {}),
+ );
+ })
+ .run()
+ .catch((e) => {
+ addErrorAttribute(this, e);
+ });
+
+ return this;
}
/**
@@ -2780,8 +2820,8 @@ function updatePopper() {
* @return {string}
*/
function getTemplate() {
- // language=HTML
- return `
+ // language=HTML
+ return `
<template id="options">
<div data-monster-role="option" tabindex="-1"
data-monster-attributes="