handsontable 16.2.0 → 17.0.0-rc1

package/editors/multiSelectEditor/multiSelectEditor.mjs

@@ -0,0 +1,504 @@
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+import { BaseEditor } from "../baseEditor/index.mjs";
+import EventManager from "../../eventManager.mjs";
+import { DropdownController } from "./controllers/dropdownController.mjs";
+import { SelectedItemsController } from "./controllers/selectedItemsController.mjs";
+import { addClass, setAttribute } from "../../helpers/dom/element.mjs";
+import { isPrintableChar } from "../../helpers/unicode.mjs";
+import { A11Y_LABEL, A11Y_GROUP } from "../../helpers/a11y.mjs";
+import { EDITOR_EDIT_GROUP } from "../../shortcutContexts/constants.mjs";
+import { getValuesIntersection, parseStringifiedValue } from "./utils/utils.mjs";
+export const EDITOR_TYPE = 'multiselect';
+const DROPDOWN_ELEMENT_CSS_CLASSNAME = 'ht-multi-select-editor';
+const DROPDOWN_ARIA_LABEL = 'Select options';
+const SHORTCUTS_GROUP = 'multiselectEditor';
+const EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible';
+
+/**
+ * @private
+ * @class MultiSelectEditor
+ */
+var _selectedItems = /*#__PURE__*/new WeakMap();
+var _editorContainer = /*#__PURE__*/new WeakMap();
+var _MultiSelectEditor_brand = /*#__PURE__*/new WeakSet();
+export class MultiSelectEditor extends BaseEditor {
+  /**
+   * Returns the editor type.
+   *
+   * @returns {string} The editor type.
+   */
+  static get EDITOR_TYPE() {
+    return EDITOR_TYPE;
+  }
+
+  /**
+   * @param {Core} hotInstance The Handsontable instance.
+   */
+  constructor(hotInstance) {
+    var _this$dropdownControl;
+    super(hotInstance);
+    /**
+     * Gets the source (options) for the editor.
+     *
+     * @returns {Array} The source (options) for the editor.
+     */
+    _classPrivateMethodInitSpec(this, _MultiSelectEditor_brand);
+    /**
+     * Prevent the editor from closing after data change.
+     *
+     * @type {boolean}
+     */
+    _defineProperty(this, "_closeAfterDataChange", false);
+    /**
+     * Set of values that are currently checked in the dropdown.
+     *
+     * @private
+     * @type {SelectedItemsController}
+     */
+    _classPrivateFieldInitSpec(this, _selectedItems, new SelectedItemsController());
+    /**
+     * Container element that hosts the editor.
+     *
+     * @private
+     * @type {HTMLDivElement}
+     */
+    _classPrivateFieldInitSpec(this, _editorContainer, null);
+    /**
+     * Container element that hosts the dropdown with checkbox options.
+     *
+     * @private
+     * @type {HTMLDivElement}
+     */
+    _defineProperty(this, "dropdownContainerElement", null);
+    /**
+     * Dropdown controller responsible for rendering and syncing option states.
+     *
+     * @private
+     * @type {DropdownController|null}
+     */
+    _defineProperty(this, "dropdownController", (_this$dropdownControl = this.dropdownController) !== null && _this$dropdownControl !== void 0 ? _this$dropdownControl : null);
+    this.eventManager = new EventManager(this);
+    this.createElements();
+    this.bindEvents();
+  }
+
+  /**
+   * Creates an editor's elements and adds necessary CSS classnames.
+   */
+  createElements() {
+    const {
+      rootDocument
+    } = this.hot;
+    _classPrivateFieldSet(_editorContainer, this, rootDocument.createElement('div'));
+    _classPrivateFieldGet(_editorContainer, this).style.display = 'none';
+    addClass(_classPrivateFieldGet(_editorContainer, this), 'handsontableEditor');
+    this.dropdownContainerElement = this.hot.rootDocument.createElement('div');
+    addClass(this.dropdownContainerElement, `${DROPDOWN_ELEMENT_CSS_CLASSNAME} handsontableEditor`);
+    setAttribute(this.dropdownContainerElement, [A11Y_LABEL(DROPDOWN_ARIA_LABEL), A11Y_GROUP()]);
+    _classPrivateFieldGet(_editorContainer, this).appendChild(this.dropdownContainerElement);
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(_editorContainer, this));
+    this.dropdownController = new DropdownController(this.dropdownContainerElement);
+  }
+
+  /**
+   * Prepares editor's meta data.
+   *
+   * @param {number} row The visual row index.
+   * @param {number} col The visual column index.
+   * @param {number|string} prop The column property (passed when datasource is an array of objects).
+   * @param {HTMLTableCellElement} td The rendered cell element.
+   * @param {*} value The rendered value.
+   * @param {object} cellProperties The cell meta object (see {@link Core#getCellMeta}).
+   */
+  prepare(row, col, prop, td, value, cellProperties) {
+    super.prepare(row, col, prop, td, value, cellProperties);
+    const parsedValue = parseStringifiedValue(value);
+    const valuesArray = Array.isArray(parsedValue) ? parsedValue : [parsedValue];
+    const valuesIntersection = getValuesIntersection(valuesArray, _assertClassBrand(_MultiSelectEditor_brand, this, _getSource).call(this));
+    this.dropdownController.reset();
+    if (valuesIntersection.length >= _assertClassBrand(_MultiSelectEditor_brand, this, _getEditorSetting).call(this, 'maxSelections')) {
+      _assertClassBrand(_MultiSelectEditor_brand, this, _blockNewSelections).call(this);
+    }
+    _assertClassBrand(_MultiSelectEditor_brand, this, _syncSelectedValues).call(this, valuesIntersection);
+    this.dropdownController.setSourceSortFunction(this.cellProperties.sourceSortFunction);
+    this.dropdownController.fillDropdown(_assertClassBrand(_MultiSelectEditor_brand, this, _getSource).call(this), valuesIntersection);
+    this.dropdownController.setVisibleRowsNumberSetting(_assertClassBrand(_MultiSelectEditor_brand, this, _getEditorSetting).call(this, 'visibleRows'));
+    this.dropdownController.setSearchInputVisibility(_assertClassBrand(_MultiSelectEditor_brand, this, _getEditorSetting).call(this, 'searchInput'));
+    if (cellProperties.maxSelections !== undefined) {
+      _classPrivateFieldGet(_selectedItems, this).setMaxSelectionCount(cellProperties.maxSelections);
+    }
+  }
+
+  /**
+   * Finishes editing and start saving or restoring process for editing cell.
+   *
+   * @param {boolean} restoreOriginalValue If true, then closes editor without saving value from the editor into a cell.
+   * @param {boolean} ctrlDown If true, then saveValue will save editor's value to each cell in the last selected range.
+   * @param {Function} callback The callback function, fired after editor closing.
+   */
+  finishEditing(restoreOriginalValue, ctrlDown, callback) {
+    super.finishEditing(restoreOriginalValue, ctrlDown, callback);
+  }
+
+  /**
+   * Binds events to the editor.
+   *
+   * @private
+   */
+  bindEvents() {
+    var _this = this;
+    this.dropdownController.addLocalHook('afterDropdownItemChecked', (selectedKey, selectedValue) => {
+      _assertClassBrand(_MultiSelectEditor_brand, this, _addSelectedValue).call(this, selectedKey, selectedValue);
+      if (_classPrivateFieldGet(_selectedItems, this).getSize() >= this.cellProperties.maxSelections) {
+        _assertClassBrand(_MultiSelectEditor_brand, this, _blockNewSelections).call(this);
+      }
+    });
+    this.dropdownController.addLocalHook('afterDropdownItemUnchecked', (deselectedKey, deselectedValue) => {
+      _assertClassBrand(_MultiSelectEditor_brand, this, _removeSelectedValue).call(this, deselectedKey, deselectedValue);
+      if (_classPrivateFieldGet(_selectedItems, this).getSize() < this.cellProperties.maxSelections) {
+        _assertClassBrand(_MultiSelectEditor_brand, this, _unblockNewSelections).call(this);
+      }
+    });
+    this.addHook('afterDestroy', () => this.destroy());
+    this.addHook('afterSetSourceDataAtCell', function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return _assertClassBrand(_MultiSelectEditor_brand, _this, _onAfterSetSourceDataAtCell).call(_this, ...args);
+    });
+    this.addHook('afterScrollHorizontally', () => this.refreshDimensions());
+    this.addHook('afterScrollVertically', () => this.refreshDimensions());
+    this.dropdownController.getInputController().addLocalHook('triggerFilter', value => _assertClassBrand(_MultiSelectEditor_brand, this, _filterEntries).call(this, value));
+  }
+
+  /**
+   * Opens the editor.
+   *
+   * @param {Event} event The event object.
+   */
+  open(event) {
+    if (isPrintableChar(event === null || event === void 0 ? void 0 : event.keyCode)) {
+      const character = event.key.length === 1 ? event.key : String.fromCharCode(event.keyCode);
+      if (this.dropdownController.getInputController().enabled) {
+        this.dropdownController.getInputController().setValue(character);
+        _assertClassBrand(_MultiSelectEditor_brand, this, _filterEntries).call(this, character);
+      }
+      event.preventDefault();
+      this.enableFullEditMode();
+    }
+    _assertClassBrand(_MultiSelectEditor_brand, this, _showEditableElement).call(this);
+    this.refreshDimensions();
+    this.hot.getShortcutManager().setActiveContextName('editor');
+    _assertClassBrand(_MultiSelectEditor_brand, this, _registerShortcuts).call(this);
+    this.dropdownController.getInputController().listen();
+    this.dropdownController.updateDimensions(_assertClassBrand(_MultiSelectEditor_brand, this, _getAvailableSpace).call(this));
+  }
+
+  /**
+   * Closes the editor.
+   */
+  close() {
+    _assertClassBrand(_MultiSelectEditor_brand, this, _hideEditableElement).call(this);
+    _assertClassBrand(_MultiSelectEditor_brand, this, _unregisterShortcuts).call(this);
+    this.dropdownController.getInputController().unlisten();
+  }
+
+  /**
+   * Returns the editor's value.
+   *
+   * @returns {string} The editor's value.
+   */
+  getValue() {
+    return _classPrivateFieldGet(_selectedItems, this).getItemsArray();
+  }
+
+  /**
+   * Sets the editor's value.
+   */
+  setValue() {
+    // Currently not implemented.
+    //
+    // As the MultiSelectEditor saves data after every change, there's no need to set the value when
+    // the editor is closed.
+    //
+    // TODO: discuss this behavior and consider implementing an option for the data-saving strategy.
+  }
+
+  /**
+   * Refreshes the editor's dimensions.
+   */
+  refreshDimensions() {
+    // TD is outside of the viewport.
+    if (!this.getEditedCell()) {
+      this.close();
+      return;
+    }
+    const {
+      top,
+      start,
+      height
+    } = this.getEditedCellRect();
+    const editorStyle = _classPrivateFieldGet(_editorContainer, this).style;
+    editorStyle.top = `${top + height}px`;
+    editorStyle[this.hot.isRtl() ? 'right' : 'left'] = `${start}px`;
+    addClass(_classPrivateFieldGet(_editorContainer, this), EDITOR_VISIBLE_CLASS_NAME);
+  }
+
+  /**
+   * Focuses the editor.
+   */
+  focus() {
+    if (_assertClassBrand(_MultiSelectEditor_brand, this, _getEditorSetting).call(this, 'searchInput') === false) {
+      this.dropdownController.focusFirstItem();
+    } else {
+      this.dropdownController.focusSearchInput();
+    }
+  }
+
+  /**
+   * Gets the input element.
+   *
+   * @returns {HTMLInputElement} The input element.
+   */
+  getInputElement() {
+    return this.dropdownController.getInputController().getInputElement();
+  }
+
+  /**
+   * Called when the editor is destroyed.
+   *
+   * @private
+   */
+  destroy() {
+    this.close();
+    this.dropdownController.reset();
+  }
+}
+function _getSource() {
+  var _this$cellProperties$;
+  return (_this$cellProperties$ = this.cellProperties.source) !== null && _this$cellProperties$ !== void 0 ? _this$cellProperties$ : [];
+}
+/**
+ * Register shortcuts responsible for handling editor.
+ *
+ * @private
+ */
+function _registerShortcuts() {
+  const shortcutManager = this.hot.getShortcutManager();
+  const editorContext = shortcutManager.getContext('editor');
+  editorContext.addShortcuts([{
+    keys: [['ArrowUp']],
+    callback: () => {
+      this.dropdownController.focusPreviousItem();
+    }
+  }, {
+    keys: [['ArrowDown']],
+    callback: () => {
+      if (this.hot.rootDocument.activeElement === this.getInputElement()) {
+        this.dropdownController.focusFirstItem();
+      } else {
+        this.dropdownController.focusNextItem();
+      }
+    }
+  }], {
+    group: SHORTCUTS_GROUP
+  });
+  editorContext.addShortcuts([{
+    keys: [['enter'], ['shift', 'enter'], ['control/meta', 'enter'], ['control/meta', 'shift', 'enter']],
+    runOnlyIf: () => !_assertClassBrand(_MultiSelectEditor_brand, this, _getEditorSetting).call(this, 'enterCommits'),
+    callback: event => {
+      const activeElement = this.hot.rootDocument.activeElement;
+      if (activeElement.tagName === 'INPUT' && activeElement.type === 'checkbox') {
+        activeElement.checked = !activeElement.checked;
+        activeElement.dispatchEvent(new Event('change'));
+      }
+      event.preventDefault();
+      return false;
+    }
+  }, {
+    keys: [['space']],
+    runOnlyIf: () => !_assertClassBrand(_MultiSelectEditor_brand, this, _getEditorSetting).call(this, 'enterCommits'),
+    callback: event => {
+      event.preventDefault();
+    }
+  }], {
+    group: SHORTCUTS_GROUP,
+    relativeToGroup: EDITOR_EDIT_GROUP,
+    position: 'before'
+  });
+}
+/**
+ * Unregister shortcuts responsible for handling editor.
+ *
+ * @private
+ */
+function _unregisterShortcuts() {
+  const shortcutManager = this.hot.getShortcutManager();
+  const editorContext = shortcutManager.getContext('editor');
+  editorContext.removeShortcutsByGroup(SHORTCUTS_GROUP);
+}
+/**
+ * Shows the editable element.
+ */
+function _showEditableElement() {
+  _classPrivateFieldGet(_editorContainer, this).style.display = '';
+}
+/**
+ * Hides the editable element.
+ */
+function _hideEditableElement() {
+  _classPrivateFieldGet(_editorContainer, this).style.display = 'none';
+}
+/**
+ * Blocks new selections.
+ */
+function _blockNewSelections() {
+  this.dropdownController.disableCheckboxes();
+}
+/**
+ * Unblocks new selections.
+ */
+function _unblockNewSelections() {
+  this.dropdownController.enableCheckboxes();
+}
+/**
+ * Filters the dropdown entries.
+ *
+ * @param {string} query The value of the input.
+ * @param {boolean} filterSelectedItems If true, the selected items will be filtered out of the dropdown.
+ */
+function _filterEntries(query) {
+  var _assertClassBrand$cal;
+  let filterSelectedItems = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (_assertClassBrand$cal = _assertClassBrand(_MultiSelectEditor_brand, this, _getEditorSetting).call(this, 'filterSelectedItems')) !== null && _assertClassBrand$cal !== void 0 ? _assertClassBrand$cal : true;
+  const filteredItems = _assertClassBrand(_MultiSelectEditor_brand, this, _getSource).call(this).filter(item => {
+    var _item$value;
+    const value = (_item$value = item === null || item === void 0 ? void 0 : item.value) !== null && _item$value !== void 0 ? _item$value : item;
+    if (!filterSelectedItems && _classPrivateFieldGet(_selectedItems, this).has(item)) {
+      return true;
+    }
+    if (this.cellProperties.filteringCaseSensitive) {
+      return value.includes(query);
+    }
+    return value.toLowerCase().includes(query.toLowerCase());
+  });
+  this.dropdownController.fillDropdown(filteredItems, _classPrivateFieldGet(_selectedItems, this).getItemsArray());
+  this.dropdownController.updateDimensions(_assertClassBrand(_MultiSelectEditor_brand, this, _getAvailableSpace).call(this), true);
+}
+/**
+ * Gets the available space for the dropdown.
+ *
+ * @returns {{spaceAbove: number, spaceBelow: number, cellHeight: number}} The available space.
+ */
+function _getAvailableSpace() {
+  const cellRect = this.getEditedCellRect();
+  const isVerticallyScrollableByWindow = this.hot.view.isVerticallyScrollableByWindow();
+  const workspaceHeight = this.hot.view.getWorkspaceHeight();
+  let spaceAbove = cellRect.top;
+  if (isVerticallyScrollableByWindow) {
+    const topOffset = this.hot.view.getTableOffset().top - this.hot.rootWindow.scrollY;
+    spaceAbove = Math.max(spaceAbove + topOffset, 0);
+  }
+  const spaceBelow = workspaceHeight - spaceAbove - cellRect.height;
+  return {
+    spaceAbove,
+    spaceBelow,
+    cellHeight: cellRect.height
+  };
+}
+/**
+ * Saves the current selection state to the cell without closing the editor.
+ *
+ * @private
+ */
+function _saveCurrentSelection() {
+  const value = _classPrivateFieldGet(_selectedItems, this).getItemsArray();
+  this.saveValue([[value]]);
+}
+/**
+ * Adds a value reported by the dropdown to the selection set and saves to the cell.
+ *
+ * @private
+ * @param {string} selectedKey Key of the selected value.
+ * @param {string} selectedValue Value of the selected value.
+ */
+function _addSelectedValue(selectedKey, selectedValue) {
+  if (selectedKey) {
+    _classPrivateFieldGet(_selectedItems, this).add({
+      key: selectedKey,
+      value: selectedValue
+    });
+  } else {
+    _classPrivateFieldGet(_selectedItems, this).add(selectedValue);
+  }
+  _assertClassBrand(_MultiSelectEditor_brand, this, _saveCurrentSelection).call(this);
+  this.refreshDimensions();
+}
+/**
+ * Removes a deselected dropdown value from the selection set and saves to the cell.
+ *
+ * @private
+ * @param {string} deselectedKey Key of the deselected value.
+ * @param {string} deselectedValue Value of the deselected value.
+ */
+function _removeSelectedValue(deselectedKey, deselectedValue) {
+  if (deselectedKey) {
+    _classPrivateFieldGet(_selectedItems, this).remove({
+      key: deselectedKey,
+      value: deselectedValue
+    });
+  } else {
+    _classPrivateFieldGet(_selectedItems, this).remove(deselectedValue);
+  }
+  _assertClassBrand(_MultiSelectEditor_brand, this, _saveCurrentSelection).call(this);
+  this.refreshDimensions();
+}
+/**
+ * Synchronizes the internal selection set with data deserialized from the cell value.
+ *
+ * @private
+ * @param {Array<*>} valuesArray Values decoded from the stored JSON string.
+ */
+function _syncSelectedValues(valuesArray) {
+  if (valuesArray.length > 0) {
+    _classPrivateFieldSet(_selectedItems, this, new SelectedItemsController(valuesArray));
+  } else {
+    _classPrivateFieldSet(_selectedItems, this, new SelectedItemsController());
+  }
+}
+/**
+ * Helper for reading editor-related settings directly from the cell meta.
+ *
+ * @private
+ * @param {string} settingKey Cell meta key to read.
+ * @returns {*} Returns the stored value for the provided key.
+ */
+function _getEditorSetting(settingKey) {
+  return this.cellProperties[settingKey];
+}
+/**
+ * `afterSetSourceDataAtCell` hook callback.
+ *
+ * @private
+ * @param {Array<*>} changes The changes.
+ * @param {string} source The source of the change.
+ */
+function _onAfterSetSourceDataAtCell(changes, source) {
+  if (this.isOpened() && source === `${EDITOR_TYPE}-renderer` && parseInt(changes[0][0], 10) === this.cellProperties.visualRow && parseInt(changes[0][1], 10) === this.cellProperties.visualCol) {
+    _assertClassBrand(_MultiSelectEditor_brand, this, _syncSelectedValues).call(this, changes[0][3]);
+    this.dropdownController.fillDropdown(_assertClassBrand(_MultiSelectEditor_brand, this, _getSource).call(this), _classPrivateFieldGet(_selectedItems, this).getItemsArray());
+    this.dropdownController.focusItem(0);
+    if (_classPrivateFieldGet(_selectedItems, this).getSize() >= this.cellProperties.maxSelections) {
+      _assertClassBrand(_MultiSelectEditor_brand, this, _blockNewSelections).call(this);
+    } else {
+      _assertClassBrand(_MultiSelectEditor_brand, this, _unblockNewSelections).call(this);
+    }
+  }
+}

package/editors/multiSelectEditor/utils/utils.js

@@ -0,0 +1,57 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getCheckboxElement = getCheckboxElement;
+exports.getValuesIntersection = getValuesIntersection;
+exports.includesValue = includesValue;
+exports.parseStringifiedValue = parseStringifiedValue;
+var _array = require("../../../helpers/array");
+var _object = require("../../../helpers/object");
+var _string = require("../../../helpers/string");
+/**
+ * Retrieves checkbox element from the item element.
+ *
+ * @param {HTMLLIElement} itemElement Parent element.
+ * @returns {HTMLInputElement|null}
+ */
+function getCheckboxElement(itemElement) {
+  return itemElement.querySelector('input[type="checkbox"]');
+}
+
+/**
+ * Parses a stringified value and returns a JavaScript value when possible.
+ *
+ * @param {string} value Value originating from the textarea or dataset.
+ * @returns {*}
+ */
+function parseStringifiedValue(value) {
+  return (0, _string.isJSON)(value) ? JSON.parse(value) : value;
+}
+
+/**
+ * Returns an array containing only values present in both provided arrays.
+ *
+ * @param {Array} valuesArray Values currently selected in the editor.
+ * @param {Array} source Array of available source items.
+ * @returns {Array}
+ */
+function getValuesIntersection(valuesArray, source) {
+  return (0, _array.getIntersectionOfArrays)(valuesArray, source, (a, b) => JSON.stringify(a) === JSON.stringify(b));
+}
+
+/**
+ * Checks if an array contains a value using JSON.stringify for comparison.
+ *
+ * @param {Array} array Array of values.
+ * @param {string|object} element Value to check.
+ * @returns {boolean}
+ */
+function includesValue(array, element) {
+  if ((0, _object.isKeyValueObject)(element)) {
+    return Array.isArray(array) && array.some(value => {
+      return (0, _object.isKeyValueObject)(value) ? (0, _object.isObjectEqual)(value, element) : value === element;
+    });
+  } else {
+    return array.includes(element);
+  }
+}

package/editors/multiSelectEditor/utils/utils.mjs

@@ -0,0 +1,50 @@
+import { getIntersectionOfArrays } from "../../../helpers/array.mjs";
+import { isObjectEqual, isKeyValueObject } from "../../../helpers/object.mjs";
+import { isJSON } from "../../../helpers/string.mjs";
+/**
+ * Retrieves checkbox element from the item element.
+ *
+ * @param {HTMLLIElement} itemElement Parent element.
+ * @returns {HTMLInputElement|null}
+ */
+export function getCheckboxElement(itemElement) {
+  return itemElement.querySelector('input[type="checkbox"]');
+}
+
+/**
+ * Parses a stringified value and returns a JavaScript value when possible.
+ *
+ * @param {string} value Value originating from the textarea or dataset.
+ * @returns {*}
+ */
+export function parseStringifiedValue(value) {
+  return isJSON(value) ? JSON.parse(value) : value;
+}
+
+/**
+ * Returns an array containing only values present in both provided arrays.
+ *
+ * @param {Array} valuesArray Values currently selected in the editor.
+ * @param {Array} source Array of available source items.
+ * @returns {Array}
+ */
+export function getValuesIntersection(valuesArray, source) {
+  return getIntersectionOfArrays(valuesArray, source, (a, b) => JSON.stringify(a) === JSON.stringify(b));
+}
+
+/**
+ * Checks if an array contains a value using JSON.stringify for comparison.
+ *
+ * @param {Array} array Array of values.
+ * @param {string|object} element Value to check.
+ * @returns {boolean}
+ */
+export function includesValue(array, element) {
+  if (isKeyValueObject(element)) {
+    return Array.isArray(array) && array.some(value => {
+      return isKeyValueObject(value) ? isObjectEqual(value, element) : value === element;
+    });
+  } else {
+    return array.includes(element);
+  }
+}

package/editors/passwordEditor/passwordEditor.js

@@ -1,7 +1,6 @@
 "use strict";
 
 exports.__esModule = true;
-require("core-js/modules/es.error.cause.js");
 var _textEditor = require("../textEditor");
 var _autoResize = require("../../utils/autoResize");
 var _element = require("../../helpers/dom/element");

package/editors/passwordEditor/passwordEditor.mjs

@@ -1,4 +1,3 @@
-import "core-js/modules/es.error.cause.js";
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }

package/editors/registry.js

@@ -5,9 +5,9 @@ exports.RegisteredEditor = RegisteredEditor;
 exports.getEditorInstance = exports._getEditorInstance = _getEditorInstance;
 exports.getEditor = _getItem;
 exports.registerEditor = _register;
-require("core-js/modules/es.error.cause.js");
 var _hooks = require("../core/hooks");
 var _staticRegister = require("../utils/staticRegister");
+var _errors = require("../helpers/errors");
 /**
  * Utility to register editors and common namespace for keeping reference to all editor classes.
  */
@@ -61,10 +61,10 @@ function _getEditorInstance(name, hotInstance) {
   } else if (typeof name === 'string') {
     editor = getItem(name);
   } else {
-    throw Error('Only strings and functions can be passed as "editor" parameter');
+    (0, _errors.throwWithCause)('Only strings and functions can be passed as "editor" parameter');
   }
   if (!editor) {
-    throw Error(`No editor registered under name "${name}"`);
+    (0, _errors.throwWithCause)(`No editor registered under name "${name}"`);
   }
   return editor.getInstance(hotInstance);
 }
@@ -80,7 +80,7 @@ function _getItem(name) {
     return name;
   }
   if (!hasItem(name)) {
-    throw Error(`No registered editor found under "${name}" name`);
+    (0, _errors.throwWithCause)(`No registered editor found under "${name}" name`);
   }
   return getItem(name).getConstructor();
 }

package/editors/registry.mjs

@@ -1,9 +1,9 @@
-import "core-js/modules/es.error.cause.js";
 /**
  * Utility to register editors and common namespace for keeping reference to all editor classes.
  */
 import { Hooks } from "../core/hooks/index.mjs";
 import { staticRegister } from "../utils/staticRegister.mjs";
+import { throwWithCause } from "../helpers/errors.mjs";
 const registeredEditorClasses = new WeakMap();
 const {
   register,
@@ -50,10 +50,10 @@ export function _getEditorInstance(name, hotInstance) {
   } else if (typeof name === 'string') {
     editor = getItem(name);
   } else {
-    throw Error('Only strings and functions can be passed as "editor" parameter');
+    throwWithCause('Only strings and functions can be passed as "editor" parameter');
   }
   if (!editor) {
-    throw Error(`No editor registered under name "${name}"`);
+    throwWithCause(`No editor registered under name "${name}"`);
   }
   return editor.getInstance(hotInstance);
 }
@@ -69,7 +69,7 @@ function _getItem(name) {
     return name;
   }
   if (!hasItem(name)) {
-    throw Error(`No registered editor found under "${name}" name`);
+    throwWithCause(`No registered editor found under "${name}" name`);
   }
   return getItem(name).getConstructor();
 }