@six-group/ui-library 0.0.0-insider.e5360cd → 0.0.0-insider.e8b5a11

package/dist/esm/six-item-picker.entry.js

@@ -1,334 +1,450 @@
-import { r as registerInstance, c as createEvent, h, g as getElement } from './index-8a74f992.js';
-import { I as ItemPickerType, a as ItemPickerPaddingDirection } from './types-59b455aa.js';
-import { D as DEFAULT_DEBOUNCE_FAST, b as DEFAULT_DEBOUNCE_INSANELY_FAST, a as debounce } from './execution-control-e0892a05.js';
-import { E as EventListeners } from './event-listeners-f6e5b0ab.js';
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-BF09Gr5y.js';
+import { I as ItemPickerType, a as ItemPickerPaddingDirection } from './types-WA6V9mN8.js';
+import { D as DEFAULT_DEBOUNCE_FAST, b as DEFAULT_DEBOUNCE_INSANELY_FAST, a as debounce } from './execution-control-CKhg9ibv.js';
+import { E as EventListeners } from './event-listeners-C4h4qpGl.js';
 
-const sixItemPickerCss = ".item_picker__container{width:2.5em;display:flex;flex-wrap:wrap;justify-content:center}.item_picker__content{font-size:1.5rem}.item_picker__btn{cursor:pointer;width:2.5em;height:2.5em;display:flex;vertical-align:middle;align-items:center;justify-content:center;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;color:var(--six-color-web-rock-500)}.item_picker__btn:hover{background-color:var(--six-color-web-rock-100);border-radius:100%}.item_picker__btn:active{color:var(--six-color-web-rock-400)}.item_picker__btn--disabled{color:var(--six-color-web-rock-300);cursor:not-allowed}.item_picker__btn--disabled:hover{background-color:initial}.item_picker__btn--disabled:active{color:var(--six-color-web-rock-300)}";
+const sixItemPickerCss = ".item_picker__container{width:2.5em;display:flex;flex-wrap:wrap;justify-content:center}.item_picker__container:focus-visible{outline:var(--six-focus-ring);outline-offset:0}.item_picker__content{font-size:1.5rem}.item_picker__btn{cursor:pointer;width:2.5em;height:2.5em;display:flex;vertical-align:middle;align-items:center;justify-content:center;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;color:var(--six-color-web-rock-500)}.item_picker__btn:hover{background-color:var(--six-color-web-rock-100);border-radius:100%}.item_picker__btn:active{color:var(--six-color-web-rock-400)}.item_picker__btn--disabled{color:var(--six-color-web-rock-300);cursor:not-allowed}.item_picker__btn--disabled:hover{background-color:initial}.item_picker__btn--disabled:active{color:var(--six-color-web-rock-300)}.item_picker__btn:focus-visible{outline:var(--six-focus-ring);outline-offset:0}";
 
 const uppercaseLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
 const upperAndLowercaseLetters = [...uppercaseLetters].flatMap((c) => [c, c.toLowerCase()]);
 const ALPHABET = {
-  alphabet: upperAndLowercaseLetters,
-  letterIndexes: Object.fromEntries(upperAndLowercaseLetters.map((c, i) => [c, i])),
+    alphabet: upperAndLowercaseLetters,
+    letterIndexes: Object.fromEntries(upperAndLowercaseLetters.map((c, i) => [c, i])),
 };
 const CAPITAL_ALPHABET = {
-  alphabet: [...uppercaseLetters].flatMap((c) => [c]),
-  letterIndexes: Object.fromEntries([...uppercaseLetters].map((c, i) => [c, i])),
+    alphabet: [...uppercaseLetters].flatMap((c) => [c]),
+    letterIndexes: Object.fromEntries([...uppercaseLetters].map((c, i) => [c, i])),
 };
 const LOWERCASE_ALPHABET = {
-  alphabet: [...uppercaseLetters.toLowerCase()].flatMap((c) => [c]),
-  letterIndexes: Object.fromEntries([...uppercaseLetters.toLowerCase()].map((c, i) => [c, i])),
+    alphabet: [...uppercaseLetters.toLowerCase()].flatMap((c) => [c]),
+    letterIndexes: Object.fromEntries([...uppercaseLetters.toLowerCase()].map((c, i) => [c, i])),
 };
 const createItemIndexes = (arr) => {
-  return Object.fromEntries([...arr].map((c, i) => [c, i]));
+    return Object.fromEntries([...arr].map((c, i) => [c, i]));
 };
 const TAG = `[SIX-ITEM-PICKER]`;
 const subtract = (a, b) => a - b;
 const add = (a, b) => a + b;
 const DEBOUNCE_ITEM_PICKER_LISTENER = 'debounced-item-picker';
 const SixItemPicker = class {
-  constructor(hostRef) {
-    registerInstance(this, hostRef);
-    this.sixChange = createEvent(this, "six-item-picker-change", 7);
-    this.sixChangeDebounced = createEvent(this, "six-item-picker-change-debounced", 7);
-    this.eventListeners = new EventListeners();
-    this.handleSixItemPickerChangeDebounced = () => {
-      this.sixChangeDebounced.emit(this.value);
-    };
-    this.value = '';
-    this.type = ItemPickerType.NUMBER;
-    this.min = undefined;
-    this.max = undefined;
-    this.roundtrip = true;
-    this.step = 1;
-    this.items = undefined;
-    this.padded = false;
-    this.paddingLength = 2;
-    this.paddingChar = '0';
-    this.paddingDirection = ItemPickerPaddingDirection.BEFORE;
-    this.timeout = DEFAULT_DEBOUNCE_FAST;
-    this.interval = DEFAULT_DEBOUNCE_INSANELY_FAST;
-    this.debounce = DEFAULT_DEBOUNCE_FAST;
-    this._items = [];
-    this._itemIndexes = {};
-  }
-  handleValueChange() {
-    this.setup();
-  }
-  debounceChanged() {
-    this.eventListeners.removeByIdentifier(DEBOUNCE_ITEM_PICKER_LISTENER);
-    this.eventListeners.add(this.host, 'six-item-picker-change', debounce(this.handleSixItemPickerChangeDebounced, this.debounce), DEBOUNCE_ITEM_PICKER_LISTENER);
-  }
-  handleSetChange() {
-    this.setup();
-    this.min = this._items[0];
-    this.max = this.getLastStringItem();
-  }
-  componentWillLoad() {
-    this.setup();
-  }
-  componentDidLoad() {
-    this.eventListeners.add(this.host, 'six-item-picker-change', debounce(this.handleSixItemPickerChangeDebounced, this.debounce), DEBOUNCE_ITEM_PICKER_LISTENER);
-  }
-  disconnectedCallback() {
-    this.eventListeners.removeAll();
-  }
-  setup() {
-    if (this.isNumber()) {
-      this.setupNumberItems();
-    }
-    else {
-      this.setUpStringItems();
-    }
-  }
-  setupNumberItems() {
-    var _a;
-    if (this.isInvalidNumber()) {
-      console.warn(`${TAG} Expected number but value is not a number: "${this.value}"`);
-      console.info(`${TAG} Will set value to either minimum or if not provided to zero.`);
-      this.value = (_a = this.min) !== null && _a !== void 0 ? _a : 0;
-    }
-  }
-  setUpStringItems() {
-    this._items = this.getStringItems();
-    this._itemIndexes = this.getItemIndexes();
-    const itemsMissValue = this._items.find((i) => String(i) === String(this.value)) === undefined;
-    if (itemsMissValue) {
-      console.warn(`${TAG} Expected item from item set but value was not found in set: "${this.value}"`);
-      console.info(`${TAG} Will set value to either minimum or if not provided to "${this._items[0]}".`);
-      this.value = this._items[0];
-    }
-    if (this.min === undefined) {
-      if (!this.roundtrip) {
-        console.warn(`${TAG} Expected a min value`);
-        console.info(`${TAG} Will set min value to ${this._items[0]}`);
-      }
-      this.min = this._items[0];
-    }
-    if (this.max === undefined) {
-      const maxItem = this.getLastStringItem();
-      if (!this.roundtrip) {
-        console.warn(`${TAG} Expected a min value if roundtrip is enabled`);
-        console.info(`${TAG} Will set min value to ${maxItem}`);
-      }
-      this.max = maxItem;
-    }
-  }
-  getLastStringItem() {
-    return this._items[this._items.length - 1];
-  }
-  getStringItems() {
-    switch (this.type) {
-      case ItemPickerType.NUMBER:
-        console.warn(`${TAG}: unexpected type ${this.type}`);
-        return [];
-      case ItemPickerType.LETTER:
-        return ALPHABET.alphabet;
-      case ItemPickerType.CAPITAL_LETTER:
-        return CAPITAL_ALPHABET.alphabet;
-      case ItemPickerType.LOWER_LETTER:
-        return LOWERCASE_ALPHABET.alphabet;
-      case ItemPickerType.CUSTOM:
-        if (this.items == null || this.items.length === 0) {
-          console.warn(`${TAG}: no items defined for type ${this.type}`);
-          return [];
-        }
-        return this.items;
-    }
-  }
-  getItemIndexes() {
-    switch (this.type) {
-      case ItemPickerType.NUMBER:
-        console.warn(`${TAG}: unexpected type ${this.type}`);
-        return {};
-      case ItemPickerType.LETTER:
-        return ALPHABET.letterIndexes;
-      case ItemPickerType.CAPITAL_LETTER:
-        return CAPITAL_ALPHABET.letterIndexes;
-      case ItemPickerType.LOWER_LETTER:
-        return LOWERCASE_ALPHABET.letterIndexes;
-      case ItemPickerType.CUSTOM:
-        return createItemIndexes(this._items);
-    }
-  }
-  previousItem() {
-    if (this.isNumber()) {
-      this.previousNumber();
-    }
-    else {
-      this.previousStringItem();
-    }
-    this.sixChange.emit(this.value);
-  }
-  previousNumber() {
-    this.changeValue({
-      isNextItemAllowed: () => !this.isPreviousNumberDisabled(),
-      getNextItem: () => Number(this.value) - this.step,
-      getRoundtripItem: () => Number(this.max),
-      isRoundtripPossible: () => this.max === undefined && this.roundtrip,
-    });
-  }
-  previousStringItem() {
-    const value = String(this.value);
-    const minLetter = String(this.min);
-    this.changeValue({
-      isNextItemAllowed: () => minLetter === undefined || this.getStringItemIndex(value) > this.getStringItemIndex(minLetter),
-      getNextItem: () => this.getNextItemByOperation(subtract),
-      getRoundtripItem: () => String(this.max),
-      isRoundtripPossible: () => this.max == null && this.roundtrip,
-    });
-  }
-  nextItem() {
-    if (this.isNumber()) {
-      this.nextNumber();
-    }
-    else {
-      this.nextStringItem();
-    }
-    this.sixChange.emit(this.value);
-  }
-  nextNumber() {
-    this.changeValue({
-      isNextItemAllowed: () => !this.isNextNumberDisabled(),
-      getNextItem: () => Number(this.value) + this.step,
-      getRoundtripItem: () => Number(this.min),
-      isRoundtripPossible: () => this.min === undefined && this.roundtrip,
-    });
-  }
-  getStringItemIndex(char) {
-    return this._itemIndexes[char];
-  }
-  nextStringItem() {
-    const value = String(this.value);
-    const maxLetter = String(this.max);
-    this.changeValue({
-      isNextItemAllowed: () => maxLetter === undefined || this.getStringItemIndex(value) < this.getStringItemIndex(maxLetter),
-      getNextItem: () => this.getNextItemByOperation(add),
-      getRoundtripItem: () => String(this.min),
-      isRoundtripPossible: () => this.min === undefined && this.roundtrip,
-    });
-  }
-  getNextItemByOperation(operation) {
-    const value = String(this.value);
-    const nextIndexCandidate = operation(this.getStringItemIndex(value), this.step);
-    const numberOfItems = this._items.length;
-    const nextIndex = ((nextIndexCandidate % numberOfItems) + numberOfItems) % numberOfItems;
-    return this._items[nextIndex];
-  }
-  changeValue(params) {
-    if (params.isNextItemAllowed()) {
-      this.value = params.getNextItem();
-      return;
-    }
-    if (params.isRoundtripPossible()) {
-      console.error(`${TAG} Item picker is expected to perform a roundtrip, but either max or min value is missing so a roundtrip is not possible`);
-      return;
-    }
-    if (this.roundtrip) {
-      this.value = params.getRoundtripItem();
-      return;
-    }
-    console.warn(`${TAG} Roundtrip is not allowed, but was still triggered, please report this issue to the developer of six-item-picker`);
-  }
-  isNumber() {
-    return this.type === ItemPickerType.NUMBER;
-  }
-  isInvalidNumber() {
-    return this.value === '' || isNaN(this.value);
-  }
-  isNextDisabled() {
-    if (this.roundtrip) {
-      return false;
-    }
-    if (this.isNumber()) {
-      return this.isNextNumberDisabled();
-    }
-    else {
-      return this._itemIndexes[String(this.value)] + this.step > this._itemIndexes[String(this.max)];
-    }
-  }
-  isNextNumberDisabled() {
-    var _a;
-    return Number(this.value) + this.step > Number((_a = this.max) !== null && _a !== void 0 ? _a : Infinity);
-  }
-  isPrevDisabled() {
-    if (this.roundtrip) {
-      return false;
-    }
-    if (this.isNumber()) {
-      return this.isPreviousNumberDisabled();
-    }
-    else {
-      return this._itemIndexes[String(this.value)] - this.step < this._itemIndexes[String(this.min)];
-    }
-  }
-  isPreviousNumberDisabled() {
-    var _a;
-    return Number(this.value) - this.step < Number((_a = this.min) !== null && _a !== void 0 ? _a : -Infinity);
-  }
-  onMouseDownNext() {
-    if (this.isNextDisabled()) {
-      return;
-    }
-    this.nextItem();
-    this._timeoutNext = setTimeout(() => {
-      this._intervalNext = setInterval(() => {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.sixChange = createEvent(this, "six-item-picker-change");
+        this.sixChangeDebounced = createEvent(this, "six-item-picker-change-debounced");
+        this.eventListeners = new EventListeners();
+        /** The item picker's value attribute. */
+        this.value = '';
+        /** The type of items you want to rotate through. */
+        this.type = ItemPickerType.NUMBER;
+        /** Define whether the picker should to a roundtrip i.e. start at max when reaching min and vice versa. */
+        // eslint-disable-next-line @stencil-community/ban-default-true
+        this.roundtrip = true;
+        /** Defines how many steps should be taken when navigating */
+        this.step = 1;
+        /** Defines whether the items should be padded */
+        this.padded = false;
+        /** Defines the length of the padded area */
+        this.paddingLength = 2;
+        /** Defines the character used for padding */
+        this.paddingChar = '0';
+        /** Defines whether the padding should be before or after the value. You can either use 'before' or 'after'. By default,
+         * before is selected */
+        this.paddingDirection = ItemPickerPaddingDirection.BEFORE;
+        /**
+         * Set the amount of time, in milliseconds, to wait to trigger faster switching between items.
+         */
+        this.timeout = DEFAULT_DEBOUNCE_FAST;
+        /**
+         * Set the amount of time, in milliseconds, to wait between switching to next item when mouse button is held pressed.
+         */
+        this.interval = DEFAULT_DEBOUNCE_INSANELY_FAST;
+        /**
+         * Set the amount of time, in milliseconds, to wait to trigger the `six-item-picker-change-debounced` event.
+         * If you want your change debounce event to not trigger when keeping the nav button pressed before, make sure debounce
+         * is a bit bigger than timeout, otherwise keeping the button pressed will trigger the event twice: once you click
+         * (and keep pressed) and once you release
+         */
+        this.debounce = DEFAULT_DEBOUNCE_FAST;
+        this._items = [];
+        this._itemIndexes = {};
+        this.handleSixItemPickerChangeDebounced = () => {
+            this.sixChangeDebounced.emit(this.value);
+        };
+    }
+    handleValueChange() {
+        this.setup();
+    }
+    debounceChanged() {
+        this.eventListeners.removeByIdentifier(DEBOUNCE_ITEM_PICKER_LISTENER);
+        this.eventListeners.add(this.host, 'six-item-picker-change', debounce(this.handleSixItemPickerChangeDebounced, this.debounce), DEBOUNCE_ITEM_PICKER_LISTENER);
+    }
+    handleSetChange() {
+        this.setup();
+        this.min = this._items[0];
+        this.max = this.getLastStringItem();
+    }
+    componentWillLoad() {
+        this.setup();
+    }
+    componentDidLoad() {
+        this.eventListeners.add(this.host, 'six-item-picker-change', debounce(this.handleSixItemPickerChangeDebounced, this.debounce), DEBOUNCE_ITEM_PICKER_LISTENER);
+    }
+    disconnectedCallback() {
+        this.eventListeners.removeAll();
+    }
+    setup() {
+        if (this.isNumber()) {
+            this.setupNumberItems();
+        }
+        else {
+            this.setUpStringItems();
+        }
+    }
+    setupNumberItems() {
+        var _a;
+        if (this.isInvalidNumber()) {
+            console.warn(`${TAG} Expected number but value is not a number: "${this.value}"`);
+            console.info(`${TAG} Will set value to either minimum or if not provided to zero.`);
+            this.value = (_a = this.min) !== null && _a !== void 0 ? _a : 0;
+        }
+    }
+    setUpStringItems() {
+        this._items = this.getStringItems();
+        this._itemIndexes = this.getItemIndexes();
+        const itemsMissValue = this._items.find((i) => String(i) === String(this.value)) === undefined;
+        if (itemsMissValue) {
+            console.warn(`${TAG} Expected item from item set but value was not found in set: "${this.value}"`);
+            console.info(`${TAG} Will set value to either minimum or if not provided to "${this._items[0]}".`);
+            this.value = this._items[0];
+        }
+        if (this.min === undefined) {
+            if (!this.roundtrip) {
+                console.warn(`${TAG} Expected a min value`);
+                console.info(`${TAG} Will set min value to ${this._items[0]}`);
+            }
+            this.min = this._items[0];
+        }
+        if (this.max === undefined) {
+            const maxItem = this.getLastStringItem();
+            if (!this.roundtrip) {
+                console.warn(`${TAG} Expected a min value if roundtrip is enabled`);
+                console.info(`${TAG} Will set min value to ${maxItem}`);
+            }
+            this.max = maxItem;
+        }
+    }
+    getLastStringItem() {
+        return this._items[this._items.length - 1];
+    }
+    getStringItems() {
+        switch (this.type) {
+            case ItemPickerType.NUMBER:
+                console.warn(`${TAG}: unexpected type ${this.type}`);
+                return [];
+            case ItemPickerType.LETTER:
+                return ALPHABET.alphabet;
+            case ItemPickerType.CAPITAL_LETTER:
+                return CAPITAL_ALPHABET.alphabet;
+            case ItemPickerType.LOWER_LETTER:
+                return LOWERCASE_ALPHABET.alphabet;
+            case ItemPickerType.CUSTOM:
+                if (this.items == null || this.items.length === 0) {
+                    console.warn(`${TAG}: no items defined for type ${this.type}`);
+                    return [];
+                }
+                return this.items;
+        }
+    }
+    getItemIndexes() {
+        switch (this.type) {
+            case ItemPickerType.NUMBER:
+                console.warn(`${TAG}: unexpected type ${this.type}`);
+                return {};
+            case ItemPickerType.LETTER:
+                return ALPHABET.letterIndexes;
+            case ItemPickerType.CAPITAL_LETTER:
+                return CAPITAL_ALPHABET.letterIndexes;
+            case ItemPickerType.LOWER_LETTER:
+                return LOWERCASE_ALPHABET.letterIndexes;
+            case ItemPickerType.CUSTOM:
+                return createItemIndexes(this._items);
+        }
+    }
+    previousItem() {
+        if (this.isNumber()) {
+            this.previousNumber();
+        }
+        else {
+            this.previousStringItem();
+        }
+        this.sixChange.emit(this.value);
+    }
+    previousNumber() {
+        this.changeValue({
+            isNextItemAllowed: () => !this.isPreviousNumberDisabled(),
+            getNextItem: () => Number(this.value) - this.step,
+            getRoundtripItem: () => Number(this.max),
+            isRoundtripPossible: () => this.max === undefined && this.roundtrip,
+        });
+    }
+    previousStringItem() {
+        const value = String(this.value);
+        const minLetter = String(this.min);
+        this.changeValue({
+            isNextItemAllowed: () => minLetter === undefined || this.getStringItemIndex(value) > this.getStringItemIndex(minLetter),
+            getNextItem: () => this.getNextItemByOperation(subtract),
+            getRoundtripItem: () => String(this.max),
+            isRoundtripPossible: () => this.max == null && this.roundtrip,
+        });
+    }
+    nextItem() {
+        if (this.isNumber()) {
+            this.nextNumber();
+        }
+        else {
+            this.nextStringItem();
+        }
+        this.sixChange.emit(this.value);
+    }
+    nextNumber() {
+        this.changeValue({
+            isNextItemAllowed: () => !this.isNextNumberDisabled(),
+            getNextItem: () => Number(this.value) + this.step,
+            getRoundtripItem: () => Number(this.min),
+            isRoundtripPossible: () => this.min === undefined && this.roundtrip,
+        });
+    }
+    getStringItemIndex(char) {
+        return this._itemIndexes[char];
+    }
+    nextStringItem() {
+        const value = String(this.value);
+        const maxLetter = String(this.max);
+        this.changeValue({
+            isNextItemAllowed: () => maxLetter === undefined || this.getStringItemIndex(value) < this.getStringItemIndex(maxLetter),
+            getNextItem: () => this.getNextItemByOperation(add),
+            getRoundtripItem: () => String(this.min),
+            isRoundtripPossible: () => this.min === undefined && this.roundtrip,
+        });
+    }
+    getNextItemByOperation(operation, increment = this.step) {
+        const value = String(this.value);
+        const nextIndexCandidate = operation(this.getStringItemIndex(value), increment);
+        const numberOfItems = this._items.length;
+        const nextIndex = ((nextIndexCandidate % numberOfItems) + numberOfItems) % numberOfItems;
+        return this._items[nextIndex];
+    }
+    changeValue(params) {
+        if (params.isNextItemAllowed()) {
+            this.value = params.getNextItem();
+            return;
+        }
+        if (params.isRoundtripPossible()) {
+            console.error(`${TAG} Item picker is expected to perform a roundtrip, but either max or min value is missing so a roundtrip is not possible`);
+            return;
+        }
+        if (this.roundtrip) {
+            this.value = params.getRoundtripItem();
+            return;
+        }
+        console.warn(`${TAG} Roundtrip is not allowed, but was still triggered, please report this issue to the developer of six-item-picker`);
+        this.sixChange.emit(this.value);
+    }
+    isNumber() {
+        return this.type === ItemPickerType.NUMBER;
+    }
+    isInvalidNumber() {
+        return this.value === '' || isNaN(this.value);
+    }
+    isNextDisabled() {
+        if (this.roundtrip) {
+            return false;
+        }
+        if (this.isNumber()) {
+            return this.isNextNumberDisabled();
+        }
+        else {
+            return this._itemIndexes[String(this.value)] + this.step > this._itemIndexes[String(this.max)];
+        }
+    }
+    isNextNumberDisabled() {
+        var _a;
+        return Number(this.value) + this.step > Number((_a = this.max) !== null && _a !== void 0 ? _a : Infinity);
+    }
+    isPrevDisabled() {
+        if (this.roundtrip) {
+            return false;
+        }
+        if (this.isNumber()) {
+            return this.isPreviousNumberDisabled();
+        }
+        else {
+            return this._itemIndexes[String(this.value)] - this.step < this._itemIndexes[String(this.min)];
+        }
+    }
+    isPreviousNumberDisabled() {
+        var _a;
+        return Number(this.value) - this.step < Number((_a = this.min) !== null && _a !== void 0 ? _a : -Infinity);
+    }
+    onMouseDownNext() {
+        if (this.isNextDisabled()) {
+            return;
+        }
         this.nextItem();
-      }, this.interval);
-    }, this.timeout);
-  }
-  onMouseUpNext() {
-    clearTimeout(this._timeoutNext);
-    clearInterval(this._intervalNext);
-  }
-  onMouseDownPrev() {
-    if (this.isPrevDisabled()) {
-      return;
-    }
-    this.previousItem();
-    this._timeoutPrev = setTimeout(() => {
-      this._intervalPrev = setInterval(() => {
+        this._timeoutNext = setTimeout(() => {
+            this._intervalNext = setInterval(() => {
+                this.nextItem();
+            }, this.interval);
+        }, this.timeout);
+    }
+    onMouseUpNext() {
+        clearTimeout(this._timeoutNext);
+        clearInterval(this._intervalNext);
+    }
+    onMouseDownPrev() {
+        if (this.isPrevDisabled()) {
+            return;
+        }
         this.previousItem();
-      }, this.interval);
-    }, this.timeout);
-  }
-  onMouseUpPrev() {
-    clearTimeout(this._timeoutPrev);
-    clearInterval(this._intervalPrev);
-  }
-  getFormattedValue() {
-    if (this.value === undefined || this.value === null) {
-      return this.value;
-    }
-    if (!this.padded) {
-      return this.value;
-    }
-    if (this.paddingDirection === ItemPickerPaddingDirection.BEFORE) {
-      return String(this.value).padStart(this.paddingLength, this.paddingChar);
-    }
-    else if (this.paddingDirection === ItemPickerPaddingDirection.AFTER) {
-      return String(this.value).padEnd(this.paddingLength, this.paddingChar);
-    }
-    return this.value;
-  }
-  render() {
-    return (h("div", { part: "container", class: "item_picker__container" }, h("div", { part: "up", class: {
-        item_picker__btn: true,
-        'item_picker__btn--disabled': this.isNextDisabled(),
-      }, onMouseDown: () => this.onMouseDownNext(), onMouseUp: () => this.onMouseUpNext() }, h("six-icon", { size: "large" }, "expand_less")), h("div", { part: "content", class: "item_picker__content" }, this.getFormattedValue()), h("div", { part: "down", class: {
-        item_picker__btn: true,
-        'item_picker__btn--disabled': this.isPrevDisabled(),
-      }, onMouseDown: () => this.onMouseDownPrev(), onMouseUp: () => this.onMouseUpPrev() }, h("six-icon", { size: "large" }, "expand_more"))));
-  }
-  get host() { return getElement(this); }
-  static get watchers() { return {
-    "value": ["handleValueChange"],
-    "debounce": ["debounceChanged"],
-    "items": ["handleSetChange"]
-  }; }
+        this._timeoutPrev = setTimeout(() => {
+            this._intervalPrev = setInterval(() => {
+                this.previousItem();
+            }, this.interval);
+        }, this.timeout);
+    }
+    onMouseUpPrev() {
+        clearTimeout(this._timeoutPrev);
+        clearInterval(this._intervalPrev);
+    }
+    getFormattedValue() {
+        if (this.value === undefined || this.value === null) {
+            return this.value;
+        }
+        if (!this.padded) {
+            return this.value;
+        }
+        if (this.paddingDirection === ItemPickerPaddingDirection.BEFORE) {
+            return String(this.value).padStart(this.paddingLength, this.paddingChar);
+        }
+        else if (this.paddingDirection === ItemPickerPaddingDirection.AFTER) {
+            return String(this.value).padEnd(this.paddingLength, this.paddingChar);
+        }
+        return this.value;
+    }
+    handleKeyPress(event) {
+        if (event.key === 'Enter') {
+            event.preventDefault();
+            if (event.target === this.upButton) {
+                this.nextItem();
+            }
+            else if (event.target === this.downButton) {
+                this.previousItem();
+            }
+        }
+        else if (event.key === 'ArrowUp') {
+            event.preventDefault();
+            this.nextItem();
+        }
+        else if (event.key === 'ArrowDown') {
+            event.preventDefault();
+            this.previousItem();
+        }
+        else if (event.key === 'PageUp') {
+            event.preventDefault();
+            this.pageUp();
+        }
+        else if (event.key === 'PageDown') {
+            event.preventDefault();
+            this.pageDown();
+        }
+        else if (event.key === 'Home') {
+            event.preventDefault();
+            this.goToMin();
+        }
+        else if (event.key === 'End') {
+            event.preventDefault();
+            this.goToMax();
+        }
+    }
+    pageUp() {
+        if (this.isNumber()) {
+            this.changeValue({
+                isNextItemAllowed: () => !this.isNextNumberDisabled(),
+                getNextItem: () => Number(this.value) + 5 * this.step,
+                getRoundtripItem: () => Number(this.min),
+                isRoundtripPossible: () => this.min === undefined && this.roundtrip,
+            });
+        }
+        else {
+            const value = String(this.value);
+            const minLetter = String(this.min);
+            this.changeValue({
+                isNextItemAllowed: () => minLetter === undefined || this.getStringItemIndex(value) > this.getStringItemIndex(minLetter),
+                getNextItem: () => this.getNextItemByOperation(add, 5),
+                getRoundtripItem: () => String(this.min),
+                isRoundtripPossible: () => this.min === undefined && this.roundtrip,
+            });
+        }
+    }
+    pageDown() {
+        if (this.isNumber()) {
+            this.changeValue({
+                isNextItemAllowed: () => !this.isPreviousNumberDisabled(),
+                getNextItem: () => Number(this.value) - 5 * this.step,
+                getRoundtripItem: () => Number(this.max),
+                isRoundtripPossible: () => this.max === undefined && this.roundtrip,
+            });
+        }
+        else {
+            const value = String(this.value);
+            const maxLetter = String(this.max);
+            this.changeValue({
+                isNextItemAllowed: () => maxLetter === undefined || this.getStringItemIndex(value) < this.getStringItemIndex(maxLetter),
+                getNextItem: () => this.getNextItemByOperation(subtract, 5),
+                getRoundtripItem: () => String(this.max),
+                isRoundtripPossible: () => this.max == null && this.roundtrip,
+            });
+        }
+    }
+    goToMin() {
+        var _a;
+        if (this.isNumber()) {
+            this.value = (_a = this.min) !== null && _a !== void 0 ? _a : 0;
+        }
+        else {
+            this.value = this._items[0];
+        }
+        this.sixChange.emit(this.value);
+    }
+    goToMax() {
+        var _a;
+        if (this.isNumber()) {
+            this.value = (_a = this.max) !== null && _a !== void 0 ? _a : Infinity;
+        }
+        else {
+            this.value = this.getLastStringItem();
+        }
+        this.sixChange.emit(this.value);
+    }
+    render() {
+        return (h("div", { key: '9696809f37fa9db9f3b3212ea6c21cccb648ccab', part: "container", class: "item_picker__container", onKeyDown: (event) => this.handleKeyPress(event), tabindex: "0" }, h("div", { key: '5864af2b6f193d090e3411c8cd54842f58fe6609', ref: (el) => (this.upButton = el), part: "up", class: {
+                item_picker__btn: true,
+                'item_picker__btn--disabled': this.isNextDisabled(),
+            }, onMouseDown: () => this.onMouseDownNext(), onMouseUp: () => this.onMouseUpNext(), tabindex: "-1" }, h("six-icon", { key: '37ac08eea928d8eaa2b3113879bd48a422261bb2', size: "large" }, "expand_less")), h("div", { key: '54948f29b05477d73228d00825c0b10b2f62d8bb', part: "content", class: "item_picker__content" }, this.getFormattedValue()), h("div", { key: '911a69c54e9151dd508d962867642e38eb8f0652', ref: (el) => (this.downButton = el), part: "down", class: {
+                item_picker__btn: true,
+                'item_picker__btn--disabled': this.isPrevDisabled(),
+            }, onMouseDown: () => this.onMouseDownPrev(), onMouseUp: () => this.onMouseUpPrev(), tabindex: "-1" }, h("six-icon", { key: '86785c1389e748d3a3c54dd09d5b8fc892882ee8', size: "large" }, "expand_more"))));
+    }
+    get host() { return getElement(this); }
+    static get watchers() { return {
+        "value": ["handleValueChange"],
+        "debounce": ["debounceChanged"],
+        "items": ["handleSetChange"]
+    }; }
 };
 SixItemPicker.style = sixItemPickerCss;
 
 export { SixItemPicker as six_item_picker };
+//# sourceMappingURL=six-item-picker.entry.js.map
 
 //# sourceMappingURL=six-item-picker.entry.js.map