@aquera/ngx-smart-table 0.0.17-patch-0.7 → 0.0.17-patch-0.8

package/fesm2020/aquera-ngx-smart-table.mjs

@@ -3889,15 +3889,128 @@ class NileSelectEditor {
         // Clear container and append select
         context.container.innerHTML = '';
         context.container.appendChild(this.select);
-        // Focus the select after render
+        // Focus after mount; open dropdown only once nile-popup exists (avoids null this.popup in nile-select)
+        const openOnEdit = this.options.openDropdownOnEdit !== false;
         setTimeout(() => {
+            void this.activateSelectAfterMount(openOnEdit);
+        }, 50);
+    }
+    async activateSelectAfterMount(openOnEdit) {
+        try {
+            this.select?.focus();
+        }
+        catch {
+            // ignore
+        }
+        if (!openOnEdit || !this.select || this.options.disabled) {
+            return;
+        }
+        await this.openNileSelectDropdownSafely();
+    }
+    /** Lit @query('nile-popup') / .select — must exist before handleOpenChange touches this.popup.popup */
+    isNileSelectPopupMounted(select) {
+        return !!select.shadowRoot?.querySelector('nile-popup');
+    }
+    async invokeShowHandlingPromise(host) {
+        if (typeof host.show !== 'function') {
+            return;
+        }
+        try {
+            const out = host.show();
+            if (out != null && typeof out.then === 'function') {
+                await out.catch(() => undefined);
+            }
+        }
+        catch {
+            // sync throw from show()
+        }
+    }
+    async openNileSelectDropdownSafely() {
+        const select = this.select;
+        if (!select) {
+            return;
+        }
+        try {
+            await customElements.whenDefined('nile-select');
+        }
+        catch {
+            // ignore
+        }
+        if (this.options.enableVirtualScroll) {
             try {
-                this.select?.focus();
+                await customElements.whenDefined('nile-virtual-select');
             }
-            catch (e) {
-                // Ignore errors
+            catch {
+                // ignore — not registered in all environments
+            }
+            // Same idea as nile-popup: inner host may not exist until Lit finishes a pass (or several).
+            const maxVirtualWaitPasses = 50;
+            for (let i = 0; i < maxVirtualWaitPasses; i++) {
+                const vs = select.shadowRoot?.querySelector('nile-virtual-select');
+                if (vs) {
+                    await this.invokeShowHandlingPromise(vs);
+                    return;
+                }
+                const lit = select;
+                if (lit.updateComplete?.then) {
+                    try {
+                        await lit.updateComplete;
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                await new Promise(resolve => requestAnimationFrame(() => resolve()));
             }
-        }, 50);
+            return;
+        }
+        const maxWaitPasses = 50;
+        for (let i = 0; i < maxWaitPasses; i++) {
+            if (this.isNileSelectPopupMounted(select)) {
+                break;
+            }
+            const lit = select;
+            if (lit.updateComplete?.then) {
+                try {
+                    await lit.updateComplete;
+                }
+                catch {
+                    // ignore
+                }
+            }
+            await new Promise(resolve => requestAnimationFrame(() => resolve()));
+        }
+        if (!this.isNileSelectPopupMounted(select)) {
+            return;
+        }
+        const host = select;
+        for (let attempt = 0; attempt < 5; attempt++) {
+            if (!this.isNileSelectPopupMounted(select)) {
+                return;
+            }
+            try {
+                if (typeof host.show === 'function') {
+                    await this.invokeShowHandlingPromise(host);
+                }
+                else {
+                    host.open = true;
+                }
+                return;
+            }
+            catch {
+                // ignore
+            }
+            await new Promise(resolve => setTimeout(resolve, 40));
+            const lit = select;
+            if (lit.updateComplete?.then) {
+                try {
+                    await lit.updateComplete;
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
     }
     /**
      * Set the initial value for the select
@@ -6384,8 +6497,14 @@ class StCellComponent {
         }
     }
     onCellClick() {
-        // Single click now only focuses, doesn't start editing
-        // Focus is handled by parent st-table component
+        // First click: parent <td> focuses this cell (bubbles after this handler).
+        // Second click while already focused: enter edit (spreadsheet-style).
+        if (this.isEditable &&
+            !this.cellLoading &&
+            !this.cell.isEditing() &&
+            this.cell.isFocused()) {
+            this.startEdit();
+        }
     }
     onCellDoubleClick() {
         // Double-click starts editing regardless of EditMode (Excel-like behavior)