genesys-spark-components 4.105.4 → 4.106.0

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-action/gux-rich-text-editor-action-rich-style/gux-rich-text-editor-action-rich-style.js

@@ -0,0 +1,259 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { h, forceUpdate } from "@stencil/core";
+import { trackComponent } from "../../../../../utils/tracking/usage";
+import { hasDisabledParent } from "../../gux-rich-text-editor.service";
+import { OnClickOutside } from "../../../../../utils/decorator/on-click-outside";
+import { afterNextRender } from "../../../../../utils/dom/after-next-render";
+import { buildI18nForComponent } from "../../../../../i18n/index";
+import translationResources from "../i18n/en.json";
+/**
+@slot - for a collection of gux-rich-style-list-item elements.
+*/
+export class GuxRichTextEditorActionRichStyle {
+    constructor() {
+        this.value = undefined;
+        this.expanded = false;
+        this.disabled = false;
+    }
+    onClickOutside() {
+        this.expanded = false;
+    }
+    watchValue(newValue) {
+        this.validateValue(newValue, this.listElement);
+    }
+    watchDisabled(disabled) {
+        if (disabled) {
+            this.expanded = false;
+        }
+    }
+    onInternallistitemsupdated(event) {
+        event.stopPropagation();
+        forceUpdate(this.root);
+    }
+    handleKeydown(event) {
+        const isButtonEvent = event.composedPath().includes(this.actionButton);
+        const isListEvent = event.composedPath().includes(this.listElement);
+        switch (event.key) {
+            case 'Escape':
+                if (isListEvent) {
+                    event.preventDefault();
+                    this.expanded = false;
+                    this.actionButton.focus();
+                }
+                break;
+            case 'ArrowDown':
+            case 'Enter': {
+                if (isButtonEvent && !this.expanded) {
+                    event.preventDefault();
+                    this.expanded = true;
+                    this.focusFirstListItem();
+                }
+                break;
+            }
+            case 'Tab':
+                this.expanded = false;
+                break;
+            case 'ArrowUp':
+                if (isButtonEvent && !this.expanded) {
+                    event.preventDefault();
+                    this.expanded = true;
+                    this.focusLastListItem();
+                }
+        }
+    }
+    handleKeyup(event) {
+        switch (event.key) {
+            case ' ': {
+                if (event.composedPath().includes(this.actionButton)) {
+                    event.preventDefault();
+                    this.expanded = true;
+                    this.focusFirstListItem();
+                }
+                break;
+            }
+        }
+    }
+    focusFirstListItem() {
+        afterNextRender(() => {
+            void this.listElement.guxFocusFirstItem();
+        });
+    }
+    focusLastListItem() {
+        afterNextRender(() => {
+            void this.listElement.guxFocusLastItem();
+        });
+    }
+    async componentWillLoad() {
+        trackComponent(this.root);
+        this.i18n = await buildI18nForComponent(this.root, translationResources);
+    }
+    componentWillRender() {
+        if (this === null || this === void 0 ? void 0 : this.listElement) {
+            this.validateValue(this.value, this.listElement);
+        }
+    }
+    validateValue(newValue, listElement) {
+        if (newValue === undefined) {
+            listElement.value = newValue;
+            return;
+        }
+        const selectedListItem = this.getListItemElementByValue(newValue);
+        if (selectedListItem) {
+            listElement.value = newValue;
+            return;
+        }
+    }
+    get listItemElements() {
+        const slot = this.listElement.querySelector('slot');
+        if (slot) {
+            return Array.from(slot.assignedElements());
+        }
+    }
+    getListItemElementByValue(value) {
+        return this.listItemElements.find(itemElement => {
+            return itemElement.value === value;
+        });
+    }
+    renderTargetDisplay() {
+        if (this === null || this === void 0 ? void 0 : this.listElement) {
+            const selectedListItemElement = this.getListItemElementByValue(this.value);
+            if (selectedListItemElement) {
+                return (h("span", null, this.renderListItem(selectedListItemElement)));
+            }
+        }
+    }
+    renderListItem(item) {
+        return (h("gux-truncate", { "max-lines": 1 }, item.textContent));
+    }
+    onActionButtonClick() {
+        this.expanded = !this.expanded;
+        if (this.expanded) {
+            this.focusFirstListItem();
+        }
+    }
+    updateValue(newValue) {
+        if (this.value !== newValue) {
+            this.value = newValue;
+        }
+    }
+    onListClick(event) {
+        // Ensure we get the closest `gux-rich-style-list-item` if the click is on a nested element eg h1,h2,h3.
+        const listItem = event.target.closest('gux-rich-style-list-item');
+        if (listItem) {
+            this.expanded = false;
+            this.updateValue(listItem.value);
+            this.actionButton.focus();
+        }
+    }
+    renderPopup() {
+        return (h("div", { class: "gux-list-container", slot: "popup" }, h("gux-rich-text-editor-list", { ref: el => (this.listElement = el), onClick: e => this.onListClick(e) }, h("slot", null))));
+    }
+    renderTarget() {
+        return (h("gux-button-slot", { accent: "ghost", slot: "target" }, h("button", { type: "button", ref: el => (this.actionButton = el), class: { 'gux-is-pressed': this.expanded }, onClick: () => this.onActionButtonClick(), disabled: this.disabled || hasDisabledParent(this.root), "aria-haspopup": "true", "aria-expanded": this.expanded.toString() }, this.renderTargetDisplay(), h("gux-icon", { "icon-name": this.expanded
+                ? 'custom/chevron-up-small-regular'
+                : 'custom/chevron-down-small-regular', "screenreader-text": this.i18n('richStyleDropdown') }))));
+    }
+    render() {
+        return (h("gux-popup", { key: 'ead5e0b9266ba91cb3d455621081794c3439cd4f', expanded: this.expanded, exceedTargetWidth: true, placement: "bottom-start" }, this.renderTarget(), this.renderPopup()));
+    }
+    static get is() { return "gux-rich-text-editor-action-rich-style"; }
+    static get encapsulation() { return "shadow"; }
+    static get delegatesFocus() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["gux-rich-text-editor-action-rich-style.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["gux-rich-text-editor-action-rich-style.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "value": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "value",
+                "reflect": false
+            },
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "disabled",
+                "reflect": false,
+                "defaultValue": "false"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "expanded": {}
+        };
+    }
+    static get elementRef() { return "root"; }
+    static get watchers() {
+        return [{
+                "propName": "value",
+                "methodName": "watchValue"
+            }, {
+                "propName": "disabled",
+                "methodName": "watchDisabled"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "internallistitemsupdated",
+                "method": "onInternallistitemsupdated",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keydown",
+                "method": "handleKeydown",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keyup",
+                "method": "handleKeyup",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}
+__decorate([
+    OnClickOutside({ triggerEvents: 'mousedown' })
+], GuxRichTextEditorActionRichStyle.prototype, "onClickOutside", null);

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-action/gux-rich-text-editor-action.css

@@ -6,7 +6,7 @@ gux-button-slot {
   inline-size: var(--gse-ui-button-iconOnly-width);
   block-size: var(--gse-ui-button-default-height);
 }
-gux-button-slot button.gux-is-active {
+gux-button-slot button.gux-is-pressed {
   color: var(--gse-ui-button-ghost-active-foregroundColor);
   background-color: var(--gse-ui-button-ghost-active-backgroundColor);
 }

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-action/gux-rich-text-editor-action.js

@@ -2,7 +2,7 @@ import { h } from "@stencil/core";
 import { trackComponent } from "../../../../utils/tracking/usage";
 import { buildI18nForComponent } from "../../../../i18n/index";
 import translationResources from "./i18n/en.json";
-import { calculateDisabledState, returnActionTypeIcon } from "../gux-rich-text-editor.service";
+import { hasDisabledParent, returnActionTypeIcon } from "../gux-rich-text-editor.service";
 export class GuxRichTextEditorAction {
     constructor() {
         this.action = undefined;
@@ -12,7 +12,6 @@ export class GuxRichTextEditorAction {
     async componentWillLoad() {
         trackComponent(this.root, { variant: this.action });
         this.i18n = await buildI18nForComponent(this.root, translationResources);
-        this.disabled = calculateDisabledState(this.root);
     }
     renderTooltip() {
         if (!this.disabled) {
@@ -20,7 +19,7 @@ export class GuxRichTextEditorAction {
         }
     }
     renderActionButton() {
-        return (h("gux-button-slot", { accent: "ghost", "icon-only": true }, h("button", { type: "button", disabled: this.disabled, class: { 'gux-is-active': this.isActive }, "aria-pressed": this.isActive.toString() }, h("gux-icon", { "icon-name": returnActionTypeIcon(this.action), "screenreader-text": this.i18n(this.action) })), this.renderTooltip()));
+        return (h("gux-button-slot", { accent: "ghost", "icon-only": true }, h("button", { type: "button", disabled: this.disabled || hasDisabledParent(this.root), class: { 'gux-is-pressed': this.isActive }, "aria-pressed": this.isActive.toString() }, h("gux-icon", { "icon-name": returnActionTypeIcon(this.action), "screenreader-text": this.i18n(this.action) })), this.renderTooltip()));
     }
     render() {
         return this.renderActionButton();
@@ -64,7 +63,7 @@ export class GuxRichTextEditorAction {
             },
             "disabled": {
                 "type": "boolean",
-                "mutable": true,
+                "mutable": false,
                 "complexType": {
                     "original": "boolean",
                     "resolved": "boolean",

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-action-group/gux-rich-text-editor-action-group.js

@@ -12,7 +12,7 @@ export class GuxRichTextEditorActionGroup {
         }
     }
     render() {
-        return (h(Host, { key: '031a1f2892b46409c272804d96d320fdce1b8776' }, h("div", { key: '8966532264cd6124fd123a05ebb429e7a97f8c41', class: "gux-action-group-container" }, h("slot", { key: '00a35806cdf7e5e98dec58147262400e7ac59db4' })), this.renderActionGroupDivider()));
+        return (h(Host, { key: '2422c0033a6a55bf6f24e13b17423a694055a3c1' }, h("div", { key: '55abdcfe3509f92b5fc7f59fd74c7231ba2092aa', class: "gux-action-group-container" }, h("slot", { key: 'a9012112cc1a1b3909be863466102ed6079131c6' })), this.renderActionGroupDivider()));
     }
     static get is() { return "gux-rich-text-editor-action-group"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-beta.js

@@ -34,10 +34,10 @@ export class GuxRichTextEditor {
         return this.renderSlot('global-action', 'gux-global-action-container');
     }
     render() {
-        return (h("div", { key: '6fc5d8f521df5df2178ad338a8d91d339378c74c', class: {
+        return (h("div", { key: '1df220d4192bc1e04cd74c7283ee90421f0ce2e0', class: {
                 'gux-rich-text-editor-container': true,
                 'gux-disabled': this.disabled
-            } }, h("div", { key: 'eb0173d434352148e9def109cab57539b5768543', class: "gux-rich-text-editor-toolbar-container" }, this.renderTypographicalEmphasis(), this.renderTextStyling(), this.renderListsIndentation(), this.renderInserting(), this.renderGlobalAction()), h("slot", { key: '2337bf2949d055f3987ab5a8916df139102b7251', name: "editor" })));
+            } }, h("div", { key: '8cb67dbf9f8f8eba7f48a838ad88835681100d62', class: "gux-rich-text-editor-toolbar-container" }, this.renderTypographicalEmphasis(), this.renderTextStyling(), this.renderListsIndentation(), this.renderInserting(), this.renderGlobalAction()), h("slot", { key: 'ef749f768106064cf77217139f0b191a3d07f35f', name: "editor" })));
     }
     static get is() { return "gux-rich-text-editor-beta"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-list/gux-rich-style-list-item/gux-rich-style-list-item.css

@@ -0,0 +1,61 @@
+:host {
+  inline-size: 100%;
+  text-align: start;
+  outline: none;
+}
+
+:host([disabled]) {
+  pointer-events: none;
+}
+
+:host([disabled=false]) {
+  pointer-events: auto;
+}
+
+::slotted(gux-icon) {
+  inline-size: var(--gse-ui-menu-option-startIcon-height);
+  block-size: var(--gse-ui-menu-option-startIcon-height);
+  margin-inline-end: var(--gse-ui-menu-option-gap);
+  vertical-align: middle;
+}
+
+button {
+  all: unset;
+  box-sizing: border-box;
+  inline-size: 100%;
+  min-block-size: var(--gse-ui-menu-option-height);
+  padding: var(--gse-ui-menu-option-padding);
+  font-family: var(--gse-ui-menu-option-label-default-text-fontFamily);
+  font-size: var(--gse-ui-menu-option-label-default-text-fontSize);
+  font-weight: var(--gse-ui-menu-option-label-default-text-fontWeight);
+  line-height: var(--gse-ui-menu-option-label-default-text-lineHeight);
+  color: var(--gse-ui-menu-option-label-foregroundColor);
+  word-wrap: break-word;
+  cursor: pointer;
+  background-color: var(--gse-ui-menu-option-default-backgroundColor);
+  border: none;
+  outline: none;
+  outline-offset: calc(var(--gse-ui-menu-option-focus-border-width) * -1);
+}
+button:focus-visible:not(:disabled) {
+  border-radius: var(--gse-semantic-focusOutline-sm-borderRadius);
+  outline: var(--gse-ui-menu-option-focus-border-width) var(--gse-ui-menu-option-focus-border-style) var(--gse-ui-menu-option-focus-border-color);
+}
+button:hover:not(:disabled) {
+  background: var(--gse-ui-menu-option-hover-backgroundColor);
+}
+button:active:not(:disabled) {
+  font-family: var(--gse-ui-menu-option-label-active-text-fontFamily);
+  font-size: var(--gse-ui-menu-option-label-active-text-fontSize);
+  font-weight: var(--gse-ui-menu-option-label-active-text-fontWeight);
+  line-height: var(--gse-ui-menu-option-label-active-text-lineHeight);
+  background: var(--gse-ui-menu-option-selected-backgroundColor);
+}
+button:disabled {
+  cursor: default;
+  opacity: var(--gse-ui-menu-option-disabled-opacity);
+}
+
+::slotted(*) {
+  margin: 0;
+}

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-list/gux-rich-style-list-item/gux-rich-style-list-item.js

@@ -0,0 +1,101 @@
+import { h, Host } from "@stencil/core";
+import { trackComponent } from "../../../../../utils/tracking/usage";
+import { getClosestElement } from "../../../../../utils/dom/get-closest-element";
+/**
+ * @slot - text
+ */
+export class GuxRichStyleListItem {
+    constructor() {
+        this.disabled = false;
+        this.value = undefined;
+    }
+    onMouseUp() {
+        this.focusParentList();
+    }
+    onMouseOver() {
+        this.focusParentList();
+    }
+    focusParentList() {
+        const parentList = getClosestElement('gux-rich-text-editor-list', this.root);
+        if (parentList && parentList.shadowRoot.activeElement === null) {
+            this.root.blur();
+            parentList.focus({
+                preventScroll: true
+            });
+        }
+    }
+    componentWillLoad() {
+        trackComponent(this.root);
+    }
+    render() {
+        return (h(Host, { key: '6dc607e4a0056690a26c91a6331de686902859c0', role: "listitem" }, h("button", { key: '0cdfdd84992f119f429daff01062ae3c07a8e49b', type: "button", tabIndex: -1, disabled: this.disabled }, h("slot", { key: 'a9f637910c0a06ab2030e16bc3abfbc692391014' }))));
+    }
+    static get is() { return "gux-rich-style-list-item"; }
+    static get encapsulation() { return "shadow"; }
+    static get delegatesFocus() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["gux-rich-style-list-item.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["gux-rich-style-list-item.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "disabled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "disabled",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "value": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "value",
+                "reflect": false
+            }
+        };
+    }
+    static get elementRef() { return "root"; }
+    static get listeners() {
+        return [{
+                "name": "mouseup",
+                "method": "onMouseUp",
+                "target": undefined,
+                "capture": false,
+                "passive": true
+            }, {
+                "name": "mouseover",
+                "method": "onMouseOver",
+                "target": undefined,
+                "capture": false,
+                "passive": true
+            }];
+    }
+}

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-list/gux-rich-text-editor-list.css

@@ -0,0 +1,8 @@
+:host {
+  display: flex;
+  flex-direction: column;
+  flex-wrap: nowrap;
+  place-content: stretch flex-start;
+  align-items: flex-start;
+  padding: var(--gse-ui-menu-padding);
+}

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor-list/gux-rich-text-editor-list.js

@@ -0,0 +1,171 @@
+import { Host, h } from "@stencil/core";
+import { trackComponent } from "../../../../utils/tracking/usage";
+import { first, last, next, previous } from "../../../stable/gux-list/gux-list.service";
+/**
+ * @slot - collection of gux-rich-style-list-item elements
+ */
+const validFocusableItems = ['gux-rich-style-list-item'];
+export class GuxRichTextEditorList {
+    constructor() {
+        this.value = undefined;
+        this.listItems = [];
+    }
+    get listItemsSlot() {
+        return this.root.querySelector('slot');
+    }
+    get listItemElements() {
+        var _a;
+        const assignedElements = (_a = this.listItemsSlot) === null || _a === void 0 ? void 0 : _a.assignedElements();
+        if (assignedElements) {
+            return Array.from(assignedElements);
+        }
+        return [];
+    }
+    setListItems() {
+        this.listItems = this.listItemElements;
+        this.internallistitemsupdated.emit();
+    }
+    async componentWillLoad() {
+        trackComponent(this.root);
+        this.setListItems();
+    }
+    onKeyDown(event) {
+        switch (event.key) {
+            case 'ArrowUp':
+                event.preventDefault();
+                previous(this.root, validFocusableItems);
+                break;
+            case 'Home':
+                event.preventDefault();
+                first(this.root, validFocusableItems);
+                break;
+            case 'ArrowDown':
+                event.preventDefault();
+                next(this.root, validFocusableItems);
+                break;
+            case 'End':
+                event.preventDefault();
+                last(this.root, validFocusableItems);
+                break;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async guxFocusFirstItem() {
+        first(this.root, validFocusableItems);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async guxFocusLastItem() {
+        last(this.root, validFocusableItems);
+    }
+    renderFocusTarget() {
+        return (h("span", { tabindex: "-1", "aria-hidden": "true" }));
+    }
+    render() {
+        return (h(Host, { key: '61bed89946e7b346628a8dd15ac69c81dd5461d3', role: "list" }, this.renderFocusTarget(), h("slot", { key: '8db5456231fa27cc4792c06ab644d0361af38f3e', onSlotchange: () => this.setListItems() })));
+    }
+    static get is() { return "gux-rich-text-editor-list"; }
+    static get encapsulation() { return "shadow"; }
+    static get delegatesFocus() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["gux-rich-text-editor-list.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["gux-rich-text-editor-list.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "value": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "value",
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "listItems": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "internallistitemsupdated",
+                "name": "internallistitemsupdated",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "guxFocusFirstItem": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "guxFocusLastItem": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "root"; }
+    static get listeners() {
+        return [{
+                "name": "keydown",
+                "method": "onKeyDown",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}

package/dist/collection/components/beta/gux-rich-text-editor/gux-rich-text-editor.service.js

@@ -1,7 +1,7 @@
 import { getClosestElement } from "../../../genesys-spark-utils/get-closest-element";
-export function calculateDisabledState(root) {
+export function hasDisabledParent(root) {
     const getParent = getClosestElement(root, 'gux-rich-text-editor-beta');
-    return !!((getParent === null || getParent === void 0 ? void 0 : getParent.disabled) || (root === null || root === void 0 ? void 0 : root.hasAttribute('disabled')));
+    return getParent === null || getParent === void 0 ? void 0 : getParent.disabled;
 }
 export function returnActionTypeIcon(action) {
     switch (action) {