@watermarkinsights/ripple 0.0.1 → 0.1.0-alpha.0

package/dist/collection/components/wm-action-menu/wm-action-menu.js

@@ -0,0 +1,610 @@
+import { h, Host } from "@stencil/core";
+import { debounce, getTextDir, hideTooltip, showTooltip, findAllScrollableParents } from "../../global/functions";
+export class ActionMenu {
+    constructor() {
+        this.openUp = false;
+        this.scrollableParents = [];
+        this.hasAnchor = CSS.supports("top", "anchor(bottom)");
+        this.keysSoFar = "";
+        this.searchIndex = 0;
+        this.debouncedClearKeysSoFar = debounce(() => {
+            this.keysSoFar = "";
+        }, 500);
+        this.isExpanded = false;
+        this.isTabbing = false;
+        this.isHidden = false;
+        this.tooltipPosition = undefined;
+        this.actionMenuType = "icon";
+        this.buttonText = undefined;
+        this.disabled = false;
+        this.tooltip = undefined;
+        this.labelForIdenticalButtons = undefined;
+        this.darkMode = undefined;
+    }
+    get horizontalPosition() {
+        var _a, _b, _c;
+        const rect = (_a = this.menubtnEl) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+        const spaceLeft = rect === null || rect === void 0 ? void 0 : rect.left;
+        const spaceRight = document.documentElement.clientWidth - (rect === null || rect === void 0 ? void 0 : rect.right);
+        const pos = ((_b = this.dropdownEl) === null || _b === void 0 ? void 0 : _b.clientWidth) > spaceLeft && ((_c = this.dropdownEl) === null || _c === void 0 ? void 0 : _c.clientWidth) <= spaceRight ? "right" : "left";
+        return pos || "left";
+    }
+    get childItems() {
+        return Array.from(this.el.querySelectorAll("wm-menuitem"));
+    }
+    get internalButtonType() {
+        return this.actionMenuType === "icon" || this.actionMenuType === "text"
+            ? this.actionMenuType + "only"
+            : this.actionMenuType;
+    }
+    handleTabbingOn() {
+        this.isTabbing = true;
+    }
+    handleTabbingOff() {
+        this.isTabbing = false;
+    }
+    handleWindowScroll() {
+        hideTooltip();
+    }
+    handleClickedItem() {
+        this.close();
+    }
+    handleKeyUp(ev) {
+        this.moveUp(ev.target);
+    }
+    handleKeyDown(ev) {
+        this.moveDown(ev.detail);
+    }
+    handleHomeKey() {
+        this.focusFirstItem();
+    }
+    handleEndKey() {
+        this.focusLastItem();
+    }
+    handleTabKey() {
+        if (this.isExpanded) {
+            this.close();
+        }
+    }
+    handleEscKey() {
+        this.close();
+        this.menubtnEl.focus();
+    }
+    handleKey(ev) {
+        switch (ev.key) {
+            case "ArrowDown":
+                if (!this.isExpanded) {
+                    ev.preventDefault();
+                    this.elToFocus = "next";
+                    this.open();
+                }
+                break;
+            case "ArrowUp":
+                if (!this.isExpanded) {
+                    ev.preventDefault();
+                    this.elToFocus = "previous";
+                    this.open();
+                }
+                break;
+        }
+    }
+    handleMenuitemBlur(ev) {
+        const toElOrChild = ev.detail.relatedTarget === this.el || this.el.contains(ev.detail.relatedTarget);
+        // if the Menuitem is blurred to something other than the component, emit a blur event with the appropriate relatedTarget
+        // keeps our component's blur events accurate, and closes when focusing browser address bar
+        if (!toElOrChild) {
+            const event = new CustomEvent("blur");
+            // @ts-ignore
+            event.relatedTarget = ev.detail.relatedTarget;
+            this.el.dispatchEvent(event);
+        }
+    }
+    handleButtonBlur(ev) {
+        const toElOrChild = ev.relatedTarget === this.el || this.el.contains(ev.relatedTarget);
+        if (toElOrChild) {
+            // do not emit a blur event when opening the dropdown and focusing the Menuitems
+            ev.stopPropagation();
+        }
+    }
+    handleScroll() {
+        if (!this.hasAnchor && this.isExpanded) {
+            this.close();
+        }
+    }
+    componentWillLoad() {
+        if (!this.hasAnchor) {
+            this.isHidden = true;
+        }
+    }
+    componentDidLoad() {
+        if (this.actionMenuType !== "icon" && !this.buttonText) {
+            console.error("wm-action-menu should have a valid button-text property when action-menu-type is set to 'text' or 'selector'");
+        }
+        if (this.actionMenuType === "icon" && !this.tooltip) {
+            console.error("wm-action-menu should have a valid tooltip when action-menu-type is set to 'icon'");
+        }
+        if (document.body.classList.contains("wmcl-user-is-tabbing")) {
+            this.isTabbing = true;
+        }
+        if (!this.hasAnchor) {
+            this.scrollableParents = findAllScrollableParents(this.el);
+            // Add scroll listeners to all scrollable parents
+            this.scrollableParents.forEach((parent) => {
+                if (parent === document.documentElement) {
+                    // For document element, listen to window scroll event
+                    window.addEventListener("scroll", () => this.handleScroll());
+                }
+                else {
+                    // For regular elements, listen to their scroll event
+                    parent.addEventListener("scroll", () => this.handleScroll());
+                }
+            });
+        }
+        this.wmActionMenuLoaded.emit();
+        this.menuLoaded.emit(); // deprecated
+    }
+    disconnectedCallback() {
+        if (!this.hasAnchor) {
+            this.scrollableParents.forEach((parent) => {
+                if (parent === document.documentElement) {
+                    window.removeEventListener("scroll", () => this.handleScroll());
+                }
+                else {
+                    parent.removeEventListener("scroll", () => this.handleScroll());
+                }
+            });
+        }
+    }
+    moveUp(el) {
+        const index = this.childItems.indexOf(el);
+        if (index === 0) {
+            this.focusLastItem();
+        }
+        else {
+            this.childItems[index - 1].focus();
+        }
+    }
+    moveDown(el) {
+        const index = this.childItems.indexOf(el);
+        if (index === this.childItems.length - 1) {
+            this.focusFirstItem();
+        }
+        else {
+            this.childItems[index + 1].focus();
+        }
+    }
+    open() {
+        if (!this.disabled) {
+            this.dropdownEl.showPopover();
+        }
+    }
+    close(returnFocus = true) {
+        this.dropdownEl.hidePopover();
+        // see onOpen
+        document.documentElement.style.overflowY = this.initialHtmlOverflowY || "";
+        this.dropdownEl.style.position = "fixed";
+        window.setTimeout(() => {
+            // if dev omits to assign focus after an action is triggered,
+            // the component brings the focus back on the button
+            // Focus will only be lost (and go to the body) once the menuitem
+            // is not visible anymore, so we need to wait for the transition to
+            // finish and the hidden class to be applied.
+            // also checking if focus stayed on the menuitem
+            if (returnFocus &&
+                (document.activeElement.tagName === "BODY" || document.activeElement.tagName === "WM-MENUITEM")) {
+                this.menubtnEl.focus();
+            }
+        }, 250);
+    }
+    positionDropdown() {
+        // only for browsers not supporting anchor
+        const rect = this.menubtnEl.getBoundingClientRect();
+        const spaceAbove = rect.top;
+        const spaceBelow = document.documentElement.clientHeight - rect.bottom;
+        const spaceLeft = rect === null || rect === void 0 ? void 0 : rect.left;
+        const spaceRight = document.documentElement.clientWidth - (rect === null || rect === void 0 ? void 0 : rect.right);
+        const dropdownHeight = this.dropdownEl.clientHeight;
+        const dropdownWidth = this.dropdownEl.clientWidth;
+        // Clear any previously set positioning properties
+        this.el.style.removeProperty("--dropdown-translate-y");
+        this.el.style.removeProperty("--dropdown-max-height");
+        this.el.style.removeProperty("--dropdown-max-width");
+        this.el.style.removeProperty("--dropdown-left");
+        // HORIZONTAL POSITION
+        // action menu usually is on the right side of the screen,
+        // so dropdown opens to the left by default (is anchored on the right corner)
+        const left = this.horizontalPosition === "right"
+            ? // not enough room left and enough room right: opens to the right
+                rect.left
+            : // default:
+                rect.right - this.dropdownEl.clientWidth;
+        this.el.style.setProperty("--dropdown-left", left + "px");
+        // exception: if there's not enough space to display the dropdown, show where there's the most space and constrain it.
+        if (dropdownWidth > spaceLeft && dropdownWidth > spaceRight) {
+            if (spaceLeft >= spaceRight) {
+                this.el.style.setProperty("--dropdown-left", 0 + "px");
+                this.el.style.setProperty("--dropdown-max-width", (spaceLeft + dropdownWidth) + "px");
+            }
+            else {
+                this.el.style.setProperty("--dropdown-left", spaceLeft + "px");
+                this.el.style.setProperty("--dropdown-max-width", spaceRight + "px");
+            }
+        }
+        // VERTICAL POSITION
+        if (dropdownHeight <= spaceBelow) {
+            // Case 1: Enough space below - position dropdown below the button
+            this.el.style.setProperty("--dropdown-translate-y", rect.bottom + "px");
+        }
+        else if (dropdownHeight <= spaceAbove) {
+            // Case 2: Not enough space below, but enough above - position dropdown above the button
+            this.el.style.setProperty("--dropdown-translate-y", rect.top - dropdownHeight + "px");
+        }
+        else {
+            // Case 3: Not enough space in either direction - use the larger available space and constrain height
+            if (spaceBelow >= spaceAbove) {
+                // Use space below and constrain dropdown height
+                this.el.style.setProperty("--dropdown-translate-y", rect.bottom + "px");
+                this.el.style.setProperty("--dropdown-max-height", spaceBelow + "px");
+            }
+            else {
+                // Use space above and constrain dropdown height
+                this.el.style.setProperty("--dropdown-translate-y", "0px");
+                this.el.style.setProperty("--dropdown-max-height", spaceAbove + "px");
+            }
+        }
+        this.isHidden = false;
+    }
+    handleToggle(ev) {
+        if (ev.newState === "open") {
+            if (!this.hasAnchor) {
+                this.positionDropdown();
+            }
+            requestAnimationFrame(() => {
+                if (this.hasAnchor) {
+                    const anchorRect = this.menubtnEl.getBoundingClientRect();
+                    const hasSpaceBelow = this.dropdownEl.offsetHeight <= document.documentElement.clientHeight - anchorRect.bottom;
+                    const hasSpaceAbove = this.dropdownEl.offsetHeight <= anchorRect.top;
+                    this.openUp = !hasSpaceBelow && hasSpaceAbove;
+                    if (!hasSpaceBelow && !hasSpaceAbove) {
+                        // dropdown will open downwards but doesn't have enough space
+                        // it needs to be absolutely positioned + html has to have overflow-y auto
+                        // (the default, but could have been overriden)
+                        // in order to ensure the options can be scrolled to
+                        // (would already be possible if the page has content below. this is in case select was at bottom of page)
+                        this.initialHtmlOverflowY = document.documentElement.style.overflowY;
+                        document.documentElement.style.overflowY = "auto";
+                        this.dropdownEl.style.position = "absolute";
+                    }
+                }
+                this.isExpanded = true;
+            });
+            setTimeout(() => {
+                // focusing doesn't work when within requestAnimationFrame
+                this.elToFocus === "previous" ? this.focusLastItem() : this.focusFirstItem();
+                this.elToFocus = undefined;
+            }, 50);
+        }
+        else {
+            this.isExpanded = false;
+            if (!this.hasAnchor) {
+                this.isHidden = true;
+            }
+        }
+    }
+    focusFirstItem() {
+        this.childItems[0].focus();
+    }
+    focusLastItem() {
+        this.childItems[this.childItems.length - 1].focus();
+    }
+    findAndFocusItem(ev) {
+        if (!this.keysSoFar && ev.detail == " ") {
+            // if the first key entered is space, treat as a click. Otherwise include in
+            ev.target.click();
+        }
+        else {
+            const character = ev.detail.toLowerCase();
+            this.focusFirstItem();
+            if (!this.keysSoFar) {
+                this.childItems.forEach((item, idx) => {
+                    if (item === document.activeElement) {
+                        this.searchIndex = idx;
+                    }
+                });
+            }
+            this.keysSoFar += character;
+            let nextMatch = this.findMatchInRange(this.childItems, this.searchIndex + 1, this.childItems.length);
+            if (!nextMatch) {
+                nextMatch = this.findMatchInRange(this.childItems, 0, this.searchIndex);
+            }
+            if (nextMatch) {
+                nextMatch.focus();
+            }
+            this.debouncedClearKeysSoFar();
+        }
+    }
+    findMatchInRange(list, startIndex, endIndex) {
+        // Find the first item starting with the keysSoFar substring, searching in
+        // the specified range of items
+        for (var n = startIndex; n < endIndex; n++) {
+            var label = list[n].textContent;
+            if (label && label.toLowerCase().indexOf(this.keysSoFar) === 0) {
+                return list[n];
+            }
+        }
+        return null;
+    }
+    render() {
+        return (h(Host, { key: '69913d953807a3170a37c14ec90374fb9b1d06f5', onBlur: () => this.close(false) }, h("div", { key: '7331521a42c349f0a8d413a8a5de1fc8c1cf669d', class: getTextDir() }, h("button", { key: '7e0f1be8ab511c85cf157610df71c31eaf3476b0', ref: (el) => (this.menubtnEl = el), id: "menubtn", class: `wm-button -${this.internalButtonType}${this.darkMode ? " dark" : ""}${this.isTabbing ? " user-is-tabbing" : ""}`, disabled: this.disabled, "aria-label": this.internalButtonType === "icononly"
+                ? this.labelForIdenticalButtons || this.tooltip
+                : this.labelForIdenticalButtons || undefined, "aria-expanded": this.isExpanded ? "true" : "false", "aria-haspopup": "menu", popoverTarget: "menu", popoverTargetAction: "toggle", onMouseEnter: () => this.actionMenuType === "icon" &&
+                showTooltip(this.tooltipPosition || this.horizontalPosition, this.menubtnEl, this.tooltip), onMouseLeave: () => hideTooltip(), onFocus: () => this.isTabbing &&
+                this.actionMenuType === "icon" &&
+                showTooltip(this.tooltipPosition || this.horizontalPosition, this.menubtnEl, this.tooltip), onBlur: (ev) => {
+                hideTooltip();
+                this.handleButtonBlur(ev);
+            } }, this.actionMenuType === "icon" && (h("span", { key: '20f9b04965a29040eedc9101888b4f19e2404a04', class: "svg-icon svg-more-options", style: { "--icon-size": "24px" } })), this.actionMenuType !== "icon" && h("span", { key: '1d621e6a8e82afba51b8ad517aa2305d96fb195c', class: "button-text" }, this.buttonText), (this.actionMenuType === "selector" || this.actionMenuType === "selector-primary") && (h("div", { key: 'f074e4b5dd035dec5414e6dd376bb4cc99de26e9', class: "selector-icon svg-icon svg-expand-more" }))), h("div", { key: 'b56cf79575ba14b6b79b297d96b0419368821273', class: `dropdown ${this.isExpanded ? "is-open" : ""} ${this.isHidden ? "hidden" : ""} ${this.openUp ? "open-up" : ""} ${this.horizontalPosition}`, id: "menu", popover: "auto", tabindex: -1, role: "menu", ref: (el) => (this.dropdownEl = el),
+            // @ts-ignore -- don't tell typescript but we're in the future
+            onToggle: (ev) => this.handleToggle(ev) }, h("slot", { key: '54889dffdec22f8a353698b51b6036324b9adc3b' })))));
+    }
+    static get is() { return "wm-action-menu"; }
+    static get encapsulation() { return "shadow"; }
+    static get delegatesFocus() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["wm-action-menu.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["wm-action-menu.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "tooltipPosition": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "| \"top\"\n    | \"bottom\"\n    | \"left\"\n    | \"right\"\n    | \"bottom-left\"\n    | \"bottom-right\"\n    | \"top-right\"\n    | \"top-left\"",
+                    "resolved": "\"bottom\" | \"bottom-left\" | \"bottom-right\" | \"left\" | \"right\" | \"top\" | \"top-left\" | \"top-right\" | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "tooltip-position",
+                "reflect": false
+            },
+            "actionMenuType": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "\"icon\" | \"text\" | \"selector\" | \"selector-primary\"",
+                    "resolved": "\"icon\" | \"selector\" | \"selector-primary\" | \"text\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "action-menu-type",
+                "reflect": false,
+                "defaultValue": "\"icon\""
+            },
+            "buttonText": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "button-text",
+                "reflect": false
+            },
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "disabled",
+                "reflect": true,
+                "defaultValue": "false"
+            },
+            "tooltip": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "tooltip",
+                "reflect": false
+            },
+            "labelForIdenticalButtons": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "label-for-identical-buttons",
+                "reflect": false
+            },
+            "darkMode": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean | undefined",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "dark-mode",
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isExpanded": {},
+            "isTabbing": {},
+            "isHidden": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "wmActionMenuLoaded",
+                "name": "wmActionMenuLoaded",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "menuLoaded",
+                "name": "menuLoaded",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }];
+    }
+    static get elementRef() { return "el"; }
+    static get listeners() {
+        return [{
+                "name": "wmUserIsTabbing",
+                "method": "handleTabbingOn",
+                "target": "window",
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmUserIsNotTabbing",
+                "method": "handleTabbingOff",
+                "target": "window",
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "scroll",
+                "method": "handleWindowScroll",
+                "target": "window",
+                "capture": true,
+                "passive": true
+            }, {
+                "name": "wmMenuitemClicked",
+                "method": "handleClickedItem",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmKeyUpPressed",
+                "method": "handleKeyUp",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmKeyDownPressed",
+                "method": "handleKeyDown",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmHomeKeyPressed",
+                "method": "handleHomeKey",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmEndKeyPressed",
+                "method": "handleEndKey",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmTabKeyPressed",
+                "method": "handleTabKey",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmEscKeyPressed",
+                "method": "handleEscKey",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keydown",
+                "method": "handleKey",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmMenuitemBlurred",
+                "method": "handleMenuitemBlur",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "wmLetterPressed",
+                "method": "findAndFocusItem",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}