@xplortech/apollo-core 2.10.0 → 2.12.0

package/dist/esm/xpl-dropdown_4.entry.js

@@ -0,0 +1,572 @@
+import { r as registerInstance, c as createEvent, h, H as Host, g as getElement } from './index-ukZKsqqq.js';
+import { a as autoUpdate, c as computePosition, o as offset, f as flip, b as size, h as hide } from './floating-ui.dom-1M1pu0C2.js';
+import { i as isBrowser } from './lifecycle-Dqb1pIRo.js';
+
+function getSide(placement) {
+    return placement.split('-')[0];
+}
+function startFloating(reference, floating, options) {
+    if (!isBrowser()) {
+        return {
+            update: async () => { },
+            stop: () => { },
+        };
+    }
+    const { placement, strategy, middleware, onPosition, onReferenceHidden, onError } = options;
+    let generation = 0;
+    let cleanup = null;
+    let active = true;
+    const run = async () => {
+        if (!active) {
+            return;
+        }
+        const myGen = generation;
+        try {
+            const result = await computePosition(reference, floating, {
+                placement,
+                strategy,
+                middleware,
+            });
+            if (!active || myGen !== generation) {
+                return;
+            }
+            if (result.middlewareData.hide?.referenceHidden) {
+                if (onReferenceHidden?.() === true) {
+                    return;
+                }
+            }
+            onPosition(result);
+        }
+        catch (err) {
+            if (!active || myGen !== generation) {
+                return;
+            }
+            onError?.(err);
+        }
+    };
+    cleanup = autoUpdate(reference, floating, run);
+    return {
+        update: run,
+        stop: () => {
+            active = false;
+            generation += 1;
+            if (cleanup) {
+                cleanup();
+                cleanup = null;
+            }
+        },
+    };
+}
+const DEFAULT_DROPDOWN_OFFSET_PX = 4;
+function dropdownMiddleware(opts) {
+    const { offsetPx = DEFAULT_DROPDOWN_OFFSET_PX, flipFallbackPlacements, sizeApply } = opts;
+    return [
+        offset(offsetPx),
+        flip(flipFallbackPlacements && flipFallbackPlacements.length > 0
+            ? { fallbackPlacements: flipFallbackPlacements }
+            : {}),
+        size({ apply: sizeApply }),
+        hide(),
+    ];
+}
+
+const VIRTUAL_LIST = {
+    rowHeight: 45,
+    overscan: 20,
+    virtualizeFrom: 200,
+};
+function renderOption(option, virtualIndex) {
+    const { groupName, options: opts, subtitle, ...properties } = option;
+    if (groupName) {
+        return (h("xpl-dropdown-group", { groupName: groupName, options: opts, ...properties }));
+    }
+    const isVirtual = virtualIndex !== undefined;
+    return (h("xpl-dropdown-option", { class: isVirtual ? 'xpl-dropdown-option--virtual' : undefined, style: isVirtual
+            ? { transform: `translateY(${virtualIndex * VIRTUAL_LIST.rowHeight}px)` }
+            : undefined, subtitle: subtitle, ...properties }));
+}
+const Dropdown = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.isOpenChange = createEvent(this, "isOpenChange", 7);
+        this.virtualEnd = 0;
+        this.virtualStart = 0;
+        this.isOpen = false;
+        this.closeOnSelect = true;
+        this.mode = 'single';
+        this.anchorToTrigger = false;
+        this.placement = 'bottom-start';
+        this.selectOnFocus = false;
+        this.floating = null;
+        this.virtualScrollRaf = null;
+        this.openAlignmentRaf = null;
+        this.previousOptionCount = 0;
+        this.handleClickOutside = ({ target }) => {
+            const { triggerId } = this;
+            const triggerElement = triggerId ? document.getElementById(triggerId) : null;
+            const isTriggerOrChild = triggerElement?.contains(target);
+            const isInside = this.hostElement.contains(target);
+            if (!isInside && !isTriggerOrChild && this.isOpen) {
+                this.isOpen = false;
+            }
+        };
+        this.handleKeyDown = (e) => {
+            if (e.key === 'Escape' && this.isOpen) {
+                this.isOpen = false;
+            }
+        };
+        this.handleVirtualScroll = () => {
+            if (this.virtualScrollRaf !== null)
+                return;
+            this.virtualScrollRaf = requestAnimationFrame(() => {
+                this.virtualScrollRaf = null;
+                this.updateVirtualRange();
+            });
+        };
+        this.setListEl = (el) => {
+            if (el === this.listEl)
+                return;
+            this.listEl = el;
+            this.listResizeObserver?.disconnect();
+            if (el && typeof ResizeObserver !== 'undefined') {
+                this.listResizeObserver ?? (this.listResizeObserver = new ResizeObserver(() => {
+                    if (this.isVirtualized)
+                        this.handleVirtualScroll();
+                }));
+                this.listResizeObserver.observe(el);
+            }
+        };
+        this.scheduleOpenAlignment = () => {
+            if (this.openAlignmentRaf !== null)
+                return;
+            this.openAlignmentRaf = requestAnimationFrame(() => {
+                this.openAlignmentRaf = null;
+                this.scrollSelectedIntoView();
+                this.updateVirtualRange();
+            });
+        };
+    }
+    onOptionsChanged() {
+        const total = this.options?.length ?? 0;
+        const listReplaced = total !== this.previousOptionCount;
+        this.previousOptionCount = total;
+        if (!this.isVirtualized) {
+            this.virtualStart = 0;
+            this.virtualEnd = 0;
+            return;
+        }
+        const list = this.listEl;
+        if (list) {
+            const maxScroll = Math.max(0, total * VIRTUAL_LIST.rowHeight - list.clientHeight);
+            if (list.scrollTop > maxScroll) {
+                list.scrollTop = maxScroll;
+            }
+            if (this.isOpen && listReplaced) {
+                const selectedIndex = this.options?.findIndex((option) => option.isSelected) ?? -1;
+                const outOfWindow = selectedIndex >= 0 &&
+                    (selectedIndex < this.virtualStart || selectedIndex >= this.virtualEnd);
+                if (outOfWindow) {
+                    this.scrollSelectedIntoView();
+                }
+            }
+        }
+        this.updateVirtualRange();
+    }
+    onAnchorToTriggerChanged() {
+        if (this.isOpen) {
+            this.startPositioning();
+        }
+    }
+    onFlipFallbackPlacementsChanged() {
+        if (this.isOpen && this.anchorToTrigger) {
+            this.startPositioning();
+        }
+    }
+    onPlacementChanged() {
+        if (this.isOpen && this.anchorToTrigger) {
+            this.startPositioning();
+        }
+    }
+    onTriggerIdChanged() {
+        if (this.isOpen) {
+            this.startPositioning();
+        }
+    }
+    onSelectedValuesChanged(newValues, initialRender = false) {
+        if (this.options && this.options.length > 0) {
+            const flatOptions = this.options.flatMap((curr) => curr.groupName && curr.options ? curr.options : [curr]);
+            flatOptions.forEach((option) => {
+                const optionValue = option.value || option.label || '';
+                if (this.mode === 'single') {
+                    option.isSelected = optionValue === newValues;
+                }
+                else {
+                    const selectedArray = Array.isArray(newValues) ? newValues : [];
+                    option.isSelected = selectedArray.includes(optionValue);
+                }
+            });
+            const mapOptions = (option) => {
+                option.options = option.groupName ? option.options?.map(mapOptions) : undefined;
+                return option;
+            };
+            this.options = this.options.map(mapOptions);
+            if (this.update && !initialRender) {
+                this.update(null, { component: this });
+            }
+        }
+    }
+    onIsOpenStateChange(newValue) {
+        this.isOpenChange.emit(newValue);
+        if (newValue) {
+            this.startPositioning();
+            this.alignOnOpen();
+        }
+        else {
+            this.stopPositioning();
+            this.cancelVirtualScroll();
+            this.virtualStart = 0;
+            this.virtualEnd = 0;
+        }
+    }
+    connectedCallback() {
+        if (!isBrowser()) {
+            return;
+        }
+        document.addEventListener('mousedown', this.handleClickOutside);
+        document.addEventListener('keydown', this.handleKeyDown);
+    }
+    disconnectedCallback() {
+        document.removeEventListener('mousedown', this.handleClickOutside);
+        document.removeEventListener('keydown', this.handleKeyDown);
+        this.stopPositioning();
+        this.cancelVirtualScroll();
+        this.listResizeObserver?.disconnect();
+    }
+    componentWillLoad() {
+        this.handleSelect = this.handleSelect.bind(this);
+        if (this.selectedValues) {
+            this.onSelectedValuesChanged(this.selectedValues, true);
+        }
+        this.previousOptionCount = this.options?.length ?? 0;
+    }
+    componentDidLoad() {
+        if (this.isOpen) {
+            this.startPositioning();
+            this.alignOnOpen();
+        }
+    }
+    async handleSelect(e, { component }) {
+        const { hostElement, mode, options, update } = this;
+        const isSingle = mode === 'single';
+        const isMulti = mode === 'multi';
+        if (options) {
+            const targetValue = component.hostElement.value || component.hostElement.label;
+            const hasGroups = options.some((option) => option.groupName);
+            if (!hasGroups) {
+                options.forEach((option) => {
+                    const isMatch = (option.value || option.label) === targetValue;
+                    if (isSingle) {
+                        option.isSelected = isMatch;
+                        if (isMatch)
+                            component.hostElement.isSelected = true;
+                    }
+                    else if (isMulti && isMatch) {
+                        option.isSelected = !option.isSelected;
+                        component.hostElement.isSelected = option.isSelected;
+                    }
+                });
+                this.options = [...options];
+            }
+            else {
+                const flatOptions = options.flatMap((curr) => curr.groupName && curr.options ? curr.options : [curr]);
+                flatOptions.forEach((option) => {
+                    const isMatch = (option.value || option.label) === targetValue;
+                    if (isSingle) {
+                        option.isSelected = isMatch;
+                        component.hostElement.isSelected = true;
+                    }
+                    else if (isMulti && isMatch) {
+                        option.isSelected = !option.isSelected;
+                        component.hostElement.isSelected = option.isSelected;
+                    }
+                });
+                const mapOptions = (option) => {
+                    option.options = option.groupName ? option.options?.map(mapOptions) : undefined;
+                    return option;
+                };
+                this.options = options.map(mapOptions);
+            }
+        }
+        else if (isSingle) {
+            const optionNodes = Array.from(hostElement.querySelectorAll('xpl-dropdown-option'));
+            optionNodes.forEach((node) => {
+                node.isSelected = node === component.hostElement;
+            });
+        }
+        else if (isMulti) {
+            component.isSelected = !component.isSelected;
+        }
+        if (update)
+            update(e, { component: this });
+    }
+    startPositioning() {
+        if (!this.anchorToTrigger || !this.triggerId) {
+            return;
+        }
+        const triggerEl = document.getElementById(this.triggerId);
+        if (!triggerEl)
+            return;
+        this.stopPositioning();
+        this.floating = startFloating(triggerEl, this.hostElement, {
+            placement: this.placement,
+            strategy: 'fixed',
+            middleware: dropdownMiddleware({
+                flipFallbackPlacements: this.flipFallbackPlacements,
+                sizeApply: ({ availableHeight, rects }) => {
+                    const listEl = this.hostElement.querySelector('.xpl-dropdown-list');
+                    let usedBeforeList = 0;
+                    if (listEl) {
+                        const children = Array.from(this.hostElement.children);
+                        const listIndex = children.indexOf(listEl);
+                        children.slice(0, listIndex).forEach((child) => {
+                            if (child instanceof HTMLElement) {
+                                usedBeforeList += child.offsetHeight;
+                            }
+                        });
+                    }
+                    const cs = getComputedStyle(this.hostElement);
+                    const hostVerticalChrome = parseFloat(cs.paddingTop) +
+                        parseFloat(cs.paddingBottom) +
+                        parseFloat(cs.borderTopWidth) +
+                        parseFloat(cs.borderBottomWidth);
+                    const cssMaxHeight = listEl
+                        ? parseFloat(getComputedStyle(listEl).getPropertyValue('--xpl-dropdown-list-max-height'))
+                        : Infinity;
+                    const listMaxHeight = Math.min(cssMaxHeight, Math.max(0, availableHeight - usedBeforeList - hostVerticalChrome));
+                    Object.assign(this.hostElement.style, {
+                        width: `${rects.reference.width}px`,
+                    });
+                    if (listEl) {
+                        listEl.style.maxHeight = `${listMaxHeight}px`;
+                    }
+                },
+            }),
+            onPosition: ({ x, y, placement: resolvedPlacement }) => {
+                if (!this.floating) {
+                    return;
+                }
+                const isAbove = getSide(resolvedPlacement) === 'top';
+                Object.assign(this.hostElement.style, {
+                    left: `${x}px`,
+                    top: `${y}px`,
+                });
+                this.hostElement.classList.toggle('xpl-dropdown--above', isAbove);
+                this.hostElement.classList.toggle('xpl-dropdown--below', !isAbove);
+            },
+            onReferenceHidden: () => {
+                this.isOpen = false;
+                return true;
+            },
+        });
+    }
+    stopPositioning() {
+        this.floating?.stop();
+        this.floating = null;
+        this.hostElement.style.left = '';
+        this.hostElement.style.top = '';
+        this.hostElement.style.width = '';
+        this.hostElement
+            .querySelector('.xpl-dropdown-list')
+            ?.style.removeProperty('max-height');
+        this.hostElement.classList.remove('xpl-dropdown--above', 'xpl-dropdown--below');
+    }
+    cancelVirtualScroll() {
+        if (this.virtualScrollRaf !== null) {
+            cancelAnimationFrame(this.virtualScrollRaf);
+            this.virtualScrollRaf = null;
+        }
+        if (this.openAlignmentRaf !== null) {
+            cancelAnimationFrame(this.openAlignmentRaf);
+            this.openAlignmentRaf = null;
+        }
+    }
+    alignOnOpen() {
+        this.scrollSelectedIntoView();
+        this.updateVirtualRange();
+        this.scheduleOpenAlignment();
+    }
+    scrollSelectedIntoView() {
+        const { listEl: list, options } = this;
+        if (!list || !options?.length || !this.isVirtualized)
+            return;
+        const selectedIndex = options.findIndex((option) => option.isSelected);
+        if (selectedIndex < 0)
+            return;
+        const { rowHeight } = VIRTUAL_LIST;
+        const centered = selectedIndex * rowHeight - (list.clientHeight - rowHeight) / 2;
+        const maxScroll = Math.max(0, options.length * rowHeight - list.clientHeight);
+        list.scrollTop = Math.max(0, Math.min(centered, maxScroll));
+    }
+    updateVirtualRange() {
+        const list = this.listEl;
+        const total = this.options?.length ?? 0;
+        if (!list || !total)
+            return;
+        const { rowHeight, overscan } = VIRTUAL_LIST;
+        const firstVisible = Math.floor(list.scrollTop / rowHeight);
+        const visibleCount = Math.ceil(list.clientHeight / rowHeight) || 1;
+        const start = Math.max(0, firstVisible - overscan);
+        const end = Math.min(total, firstVisible + visibleCount + overscan);
+        if (start !== this.virtualStart || end !== this.virtualEnd) {
+            this.virtualStart = start;
+            this.virtualEnd = end;
+        }
+    }
+    get isVirtualized() {
+        const { options } = this;
+        return (!!options &&
+            options.length > VIRTUAL_LIST.virtualizeFrom &&
+            options.every((option) => !option.groupName && !option.subtitle));
+    }
+    render() {
+        const { isOpen, mode, options } = this;
+        const hasOptions = !!(options && options.length);
+        const shouldVirtualize = this.isVirtualized;
+        let listContent;
+        if (!hasOptions) {
+            listContent = h("slot", { key: '97760aa46be9b95b750cd5db5453a9229a258182', name: "options" });
+        }
+        else if (shouldVirtualize) {
+            const { rowHeight, overscan } = VIRTUAL_LIST;
+            const total = options.length;
+            const start = Math.min(this.virtualStart, total);
+            const fallbackEnd = Math.min(total, Math.ceil(300 / rowHeight) + overscan * 2);
+            const end = this.virtualEnd > start ? this.virtualEnd : fallbackEnd;
+            listContent = (h("li", { key: 'e26d99dc6d29290d64e6408c19b3357b590cffe3', class: "xpl-dropdown__virtual-sizer", style: { height: `${total * rowHeight}px` } }, options.slice(start, end).map((option, i) => renderOption(option, start + i))));
+        }
+        else {
+            listContent = options.map((option) => renderOption(option));
+        }
+        return (h(Host, { key: '564b912fee05be97c27e1d791593066793ea5cf4', "aria-expanded": isOpen ? 'true' : 'false', class: {
+                'xpl-dropdown': true,
+                'xpl-dropdown--multi': mode === 'multi',
+                'xpl-dropdown--open': isOpen,
+                'xpl-dropdown--anchor-to-trigger': this.anchorToTrigger,
+                'xpl-dropdown--virtualized': shouldVirtualize,
+            }, role: "listbox" }, h("slot", { key: '1f84f1ce175fc1affae09ad93ed7c2b349b900ba', name: "header" }), h("ul", { key: '933fac0a3585043bf66fcb59525ca1d6874bc2c3', class: "xpl-dropdown-list", ref: (el) => {
+                this.setListEl(el);
+            }, onScroll: shouldVirtualize ? this.handleVirtualScroll : undefined }, listContent)));
+    }
+    get hostElement() { return getElement(this); }
+    static get watchers() { return {
+        "options": [{
+                "onOptionsChanged": 0
+            }],
+        "anchorToTrigger": [{
+                "onAnchorToTriggerChanged": 0
+            }],
+        "flipFallbackPlacements": [{
+                "onFlipFallbackPlacementsChanged": 0
+            }],
+        "placement": [{
+                "onPlacementChanged": 0
+            }],
+        "triggerId": [{
+                "onTriggerIdChanged": 0
+            }],
+        "selectedValues": [{
+                "onSelectedValuesChanged": 0
+            }],
+        "isOpen": [{
+                "onIsOpenStateChange": 0
+            }]
+    }; }
+};
+
+const DropdownGroup = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+    }
+    render() {
+        const { groupName, options } = this;
+        const hasOptions = options && options.length;
+        const mappedOptions = hasOptions &&
+            options.map(({ groupName: optsGroupName, ...properties }) => optsGroupName ? (h("xpl-dropdown-group", { label: optsGroupName, ...properties })) : (h("xpl-dropdown-option", { ...properties })));
+        return (h(Host, { key: '6834fa4acc5c15d3256a0289013deb4821d22d57', role: "group", "aria-label": groupName }, h("li", { key: 'bed8042f619a729e9eb8c4e365e1b87dd1ea93cb', class: "xpl-dropdown-list-item" }, h("xpl-dropdown-heading", { key: '7171c8e2dcc007ece292dde758abf27b17cf2a7c', label: groupName }), h("ul", { key: 'a1e2a330759007328ad5b9d7f0ac6f920e5f6eec', class: "xpl-dropdown-list" }, mappedOptions || h("slot", { key: 'ea8ea2987afe4decda1e78607d843c68e9285029', name: "options" })))));
+    }
+};
+
+const DropdownHeading = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+    }
+    render() {
+        return (h(Host, { key: '71b62b60d09869f77af7a6975a54a58116c002a6', class: { 'xpl-dropdown-heading': true }, role: "presentation" }, h("span", { key: 'ad7614e31b405ff4a9043334716eb1ff546a5c03' }, this.label || h("slot", { key: 'b0a0d0b2a6f96d9b8b2d16ee5e289bb3592e5d42', name: "heading" }))));
+    }
+};
+
+const DropdownOptionCpnt = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.dropdown = null;
+    }
+    componentWillLoad() {
+        this.dropdown = this.hostElement.closest('xpl-dropdown');
+    }
+    handleClick(ev) {
+        if (!this.dropdown) {
+            return;
+        }
+        const { closeOnSelect, mode } = this.dropdown;
+        if (ev.x && ev.y) {
+            this.dropdown.handleSelect(ev, { component: this });
+            if (mode === 'single' && closeOnSelect)
+                this.dropdown.isOpen = false;
+        }
+    }
+    handleKeyup(ev) {
+        if (!this.dropdown) {
+            return;
+        }
+        const { dropdown } = this;
+        const navigationKeys = ['ArrowDown', 'ArrowLeft', 'ArrowRight', 'ArrowUp', 'Tab'];
+        const { closeOnSelect, mode, selectOnFocus } = this.dropdown;
+        if (selectOnFocus && navigationKeys.includes(ev.key)) {
+            const { activeElement } = document;
+            const hostElement = activeElement?.closest('xpl-dropdown-option') ?? null;
+            const component = {
+                component: { hostElement },
+            };
+            dropdown.handleSelect(ev, component);
+            if (mode === 'single' && closeOnSelect)
+                this.dropdown.isOpen = false;
+            return;
+        }
+        const selectionKeys = ['Escape', 'Enter'];
+        if (selectionKeys.includes(ev.key)) {
+            dropdown.handleSelect(ev, { component: this });
+            if (ev.key === 'Escape' || (this.dropdown.closeOnSelect && ev.key === 'Enter')) {
+                this.dropdown.isOpen = false;
+            }
+        }
+    }
+    connectedCallback() {
+        this.hostElement.addEventListener('click', this.handleClick.bind(this));
+        this.hostElement.addEventListener('keyup', this.handleKeyup.bind(this));
+    }
+    disconnectedCallback() {
+        this.hostElement.removeEventListener('click', this.handleClick);
+        this.hostElement.removeEventListener('keyup', this.handleKeyup);
+    }
+    render() {
+        const { label, isSelected, isDisabled, value, subtitle, icon } = this;
+        return (h(Host, { key: 'cfdd7c14ccd6996d9e4e540b3364201d78f68ee8', class: {
+                'xpl-dropdown-option': true,
+                'xpl-dropdown-option--disabled': !!isDisabled,
+                'xpl-dropdown-option--selected': !!isSelected,
+            }, role: "option", "aria-checked": isSelected, "aria-disabled": isDisabled, "aria-selected": isSelected, value: value }, h("li", { key: 'f562da32ddf9725e696659abf6f245d1e9b1f787', class: "xpl-dropdown-list-item" }, icon && (h("xpl-icon", { key: '10426bcc6a8a88db580eb04b3f83ad5d9316fc73', class: "xpl-dropdown-list-item__icon", icon: icon, size: 20 })), label || h("slot", { key: '5f67b98ef75350ca860e96b5dd0c5375447bf09f', name: "option" }), subtitle && h("span", { key: '6240790bbe44e43d612245bd052ed2a54fa409e1', class: "xpl-dropdown-list-item__subtitle" }, subtitle))));
+    }
+    get hostElement() { return getElement(this); }
+};
+
+export { Dropdown as xpl_dropdown, DropdownGroup as xpl_dropdown_group, DropdownHeading as xpl_dropdown_heading, DropdownOptionCpnt as xpl_dropdown_option };

package/dist/esm/xpl-dynamic-table-cell.entry.js

@@ -1,4 +1,4 @@
-import { r as registerInstance, h, H as Host, g as getElement } from './index-CXkZUm1c.js';
+import { r as registerInstance, h, H as Host, g as getElement } from './index-ukZKsqqq.js';
 
 const DynamicTableCell = class {
     constructor(hostRef) {
@@ -12,7 +12,7 @@ const DynamicTableCell = class {
         this.updateSlottedComponentsWhenDisabled();
     }
     updateSlottedComponentsWhenDisabled() {
-        const slottedElements = this.hostElement.querySelectorAll('*');
+        const slottedElements = this.hostElement?.querySelectorAll('*') ?? [];
         slottedElements.forEach((element) => {
             if ('disabled' in element) {
                 element.disabled = this.disabled;
@@ -20,10 +20,12 @@ const DynamicTableCell = class {
         });
     }
     render() {
-        const colIndex = Array.from(this.el.parentElement.children).indexOf(this.el) + 1;
-        return (h(Host, { key: 'e6e9a3695c9d8ca3743b188284bc8e69f50f3397', role: "gridcell", "aria-colindex": colIndex, class: "xpl-dynamic-table-cell", ref: (el) => {
-                this.hostElement = el;
-            } }, h("slot", { key: 'abfa632a3ac88d663acaaacbc431d07c9da4b375' })));
+        const colIndex = this.el.parentElement
+            ? Array.from(this.el.parentElement.children).indexOf(this.el) + 1
+            : 0;
+        return (h(Host, { key: 'c2cfd05197952dd882bb3cf138dcbbc556e34583', role: "gridcell", "aria-colindex": colIndex, class: "xpl-dynamic-table-cell", ref: (el) => {
+                this.hostElement = el ?? undefined;
+            } }, h("slot", { key: 'bb48fdae37888679b567f842e7343091c851318a' })));
     }
     get el() { return getElement(this); }
 };

package/dist/esm/xpl-dynamic-table-row.entry.js

@@ -1,4 +1,4 @@
-import { r as registerInstance, h, H as Host } from './index-CXkZUm1c.js';
+import { r as registerInstance, h, H as Host } from './index-ukZKsqqq.js';
 
 const DynamicTableRow = class {
     constructor(hostRef) {
@@ -17,7 +17,7 @@ const DynamicTableRow = class {
         this.updateRowCellsDisabledState();
     }
     updateRowCellsDisabledState() {
-        const cells = this.hostElement.querySelectorAll('xpl-dynamic-table-cell');
+        const cells = this.hostElement?.querySelectorAll('xpl-dynamic-table-cell') ?? [];
         cells.forEach((cell) => {
             cell.disabled = this.isDisabled;
         });
@@ -26,9 +26,9 @@ const DynamicTableRow = class {
         const classList = `xpl-dynamic-table-row
             ${this.isDisabled ? 'disabled' : ''}
             ${this.selected ? 'selected' : ''}`;
-        return (h(Host, { key: 'e070f32db6cee0bcbf0dd84e41e13e6d3b88e8a1', role: "row", class: classList, ref: (el) => {
-                this.hostElement = el;
-            } }, h("slot", { key: '78ea8e02e97e0017dc4aa35af4883446d4e4c4bf' })));
+        return (h(Host, { key: '385be648a5890a43b63bf78e5cdbb08ded40b350', role: "row", class: classList, ref: (el) => {
+                this.hostElement = el ?? undefined;
+            } }, h("slot", { key: 'aa2519e69e547492a25d9fbf18c4dc5b090fbded' })));
     }
 };