@aquera/ngx-smart-table 0.0.17-patch-0.1 → 0.0.17-patch-0.3

package/esm2020/lib/editors/nile-code-editor.mjs

@@ -0,0 +1,642 @@
+/**
+ * Custom editor using NileCodeEditor from @aquera/nile-elements
+ * This provides code editing capabilities with syntax highlighting for table cells
+ */
+/**
+ * Inject global styles for nile-code-editor in table cells
+ */
+let codeEditorStylesInjected = false;
+function injectCodeEditorStyles() {
+    if (codeEditorStylesInjected)
+        return;
+    codeEditorStylesInjected = true;
+    const styleId = 'nile-code-editor-cell-styles';
+    if (document.getElementById(styleId))
+        return;
+    const style = document.createElement('style');
+    style.id = styleId;
+    style.textContent = `
+    /* Nile Code Editor cell styling */
+    nile-code-editor.st-cell-editor {
+      display: block;
+      width: 100%;
+      height: 100%;
+      font-size: inherit !important;
+      font-family: inherit !important;
+      line-height: inherit !important;
+    }
+    nile-code-editor.st-cell-editor::part(code-editor-base) {
+      border: none !important;
+      min-height: 100% !important;
+      background: transparent !important;
+      font-size: inherit !important;
+      font-family: inherit !important;
+      line-height: inherit !important;
+    }
+    /* Ensure proper sizing within table cell */
+    .st-nile-code-editor {
+      width: 100%;
+      height: 100%;
+      min-height: 28px;
+      font-size: inherit !important;
+    }
+    /* CodeMirror content should inherit font size */
+    nile-code-editor.st-cell-editor .cm-content,
+    nile-code-editor.st-cell-editor .cm-line {
+      font-size: inherit !important;
+      font-family: inherit !important;
+      line-height: inherit !important;
+    }
+    /* Container wrapper for editor + expand button */
+    .st-code-editor-wrapper {
+      display: flex;
+      align-items: center;
+      width: 100%;
+      height: 100%;
+      gap: 4px;
+    }
+    .st-code-editor-wrapper .st-code-editor-input {
+      flex: 1;
+      min-width: 0;
+      height: 100%;
+    }
+    .st-code-editor-wrapper .st-expand-button {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 24px;
+      height: 24px;
+      min-width: 24px;
+      padding: 0;
+      border: none;
+      background: transparent;
+      cursor: pointer;
+      color: var(--nile-color-neutral-500, #6b7280);
+      border-radius: 4px;
+      transition: all 0.2s;
+    }
+    .st-code-editor-wrapper .st-expand-button:hover {
+      background: var(--nile-color-neutral-100, #f3f4f6);
+      color: var(--nile-color-neutral-700, #374151);
+    }
+    /* Dialog code editor styling */
+    .st-code-editor-dialog::part(panel) {
+      max-height: var(--max-height, 80vh) !important;
+      overflow: hidden !important;
+    }
+    .st-code-editor-dialog::part(body) {
+      overflow: auto !important;
+    }
+    .st-code-editor-dialog nile-code-editor {
+      width: 100%;
+      display: block;
+    }
+    .st-code-editor-dialog nile-code-editor::part(code-editor-base) {
+      border: 1px solid var(--nile-color-neutral-200, #e5e7eb) !important;
+      border-radius: 4px !important;
+      overflow: auto !important;
+      min-height: var(--dialog-editor-min-height, 300px) !important;
+    }
+    .st-code-editor-dialog nile-code-editor .cm-editor {
+      min-height: var(--dialog-editor-min-height, 300px) !important;
+    }
+    .st-code-editor-dialog nile-code-editor .cm-content {
+      min-height: var(--dialog-editor-min-height, 300px) !important;
+    }
+  `;
+    document.head.appendChild(style);
+}
+/**
+ * Custom editor that uses NileCodeEditor component
+ * Provides code editing with syntax highlighting for table cells
+ * @template T The value type (typically string)
+ */
+export class NileCodeEditor {
+    constructor(options) {
+        this.options = options;
+        this.eventListeners = [];
+        this.dialogOpen = false;
+        this.expandButtonClicked = false;
+        this.trackedValue = null;
+    }
+    edit(context) {
+        if (!context.container) {
+            console.warn('NileCodeEditor requires a container element');
+            return;
+        }
+        this.context = context;
+        this.trackedValue = null;
+        // Inject global styles once
+        injectCodeEditorStyles();
+        // Check if we should show expand button (default: true)
+        const showExpandButton = this.options?.showExpandButton !== false;
+        if (showExpandButton) {
+            // Create wrapper for editor + expand button
+            this.wrapper = document.createElement('div');
+            this.wrapper.className = 'st-code-editor-wrapper';
+            // Create the editor container
+            const editorContainer = document.createElement('div');
+            editorContainer.className = 'st-code-editor-input';
+            // Create NileCodeEditor custom element
+            this.editor = document.createElement('nile-code-editor');
+            this.editor.value = String(context.value ?? '');
+            this.editor.className = 'st-cell-editor st-nile-code-editor';
+            this.editor.style.width = '100%';
+            this.editor.style.height = '100%';
+            this.editor.style.boxSizing = 'border-box';
+            this.editor.noborder = this.options?.noborder !== false;
+            editorContainer.appendChild(this.editor);
+            this.wrapper.appendChild(editorContainer);
+            // Create expand button
+            this.expandButton = document.createElement('button');
+            this.expandButton.className = 'st-expand-button';
+            this.expandButton.type = 'button';
+            this.expandButton.title = 'Expand editor';
+            this.expandButton.innerHTML = '<nile-icon name="expand-06" size="16"></nile-icon>';
+            // Use mousedown to set flag BEFORE blur event fires
+            this.expandButton.addEventListener('mousedown', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                this.expandButtonClicked = true;
+            });
+            this.expandButton.addEventListener('click', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                this.openDialog();
+            });
+            this.wrapper.appendChild(this.expandButton);
+            // Clear container and append wrapper
+            context.container.innerHTML = '';
+            context.container.appendChild(this.wrapper);
+        }
+        else {
+            // Create NileCodeEditor custom element without wrapper
+            this.editor = document.createElement('nile-code-editor');
+            this.editor.value = String(context.value ?? '');
+            this.editor.className = 'st-cell-editor st-nile-code-editor';
+            this.editor.style.width = '100%';
+            this.editor.style.height = '100%';
+            this.editor.style.boxSizing = 'border-box';
+            this.editor.noborder = this.options?.noborder !== false;
+            // Clear container and append editor
+            context.container.innerHTML = '';
+            context.container.appendChild(this.editor);
+        }
+        // Apply all configuration options
+        this.applyOptions();
+        // Set up event listeners
+        this.setupEventListeners(context);
+        // Auto focus - need a slight delay for nile-code-editor to fully initialize
+        if (this.options?.autoFocus !== false) {
+            // Listen for the nile-after-init event which fires when editor is ready
+            const initHandler = () => {
+                this.editor?.removeEventListener('nile-after-init', initHandler);
+                this.focusEditor();
+            };
+            this.editor.addEventListener('nile-after-init', initHandler);
+            // Fallback: also try after a delay in case the event already fired
+            setTimeout(() => {
+                this.focusEditor();
+            }, 100);
+        }
+    }
+    /**
+     * Focus the editor and place cursor
+     */
+    focusEditor() {
+        if (!this.editor)
+            return;
+        try {
+            // Call the component's focus method
+            this.editor.focus();
+            // Try to directly focus the CodeMirror content area
+            const shadowRoot = this.editor.shadowRoot;
+            if (shadowRoot) {
+                const cmContent = shadowRoot.querySelector('.cm-content');
+                if (cmContent) {
+                    cmContent.focus();
+                    // Dispatch a click event to ensure cursor placement
+                    cmContent.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+                    cmContent.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
+                }
+            }
+        }
+        catch (e) {
+            // Silently handle any errors
+        }
+    }
+    /**
+     * Read the live value directly from CodeMirror's internal state,
+     * bypassing debounced nile-change events and the possibly-stale .value property.
+     */
+    getLiveEditorValue() {
+        if (!this.editor)
+            return '';
+        try {
+            const shadowRoot = this.editor.shadowRoot;
+            if (shadowRoot) {
+                const cmEditor = shadowRoot.querySelector('.cm-editor');
+                if (cmEditor?.cmView?.view) {
+                    return cmEditor.cmView.view.state.doc.toString();
+                }
+            }
+        }
+        catch {
+            // Fall through to other methods
+        }
+        if (this.trackedValue !== null)
+            return this.trackedValue;
+        return this.editor.value ?? '';
+    }
+    /**
+     * Open the full editor dialog
+     */
+    openDialog() {
+        if (this.dialogOpen)
+            return;
+        this.dialogOpen = true;
+        this.expandButtonClicked = false; // Reset flag now that dialog is opening
+        // Create dialog with configurable dimensions
+        const dialogWidth = this.options?.dialogWidth || '600px';
+        const dialogMaxHeight = this.options?.dialogMaxHeight || '80vh';
+        const dialogEditorHeight = this.options?.dialogEditorHeight || '300px';
+        const dialogTitle = this.options?.dialogTitle || 'Edit Code';
+        this.dialog = document.createElement('nile-dialog');
+        this.dialog.className = 'st-code-editor-dialog';
+        this.dialog.label = dialogTitle;
+        this.dialog.style.setProperty('--width', dialogWidth);
+        this.dialog.style.setProperty('--max-height', dialogMaxHeight);
+        // Create dialog content
+        const content = document.createElement('div');
+        content.style.padding = '16px';
+        content.style.maxHeight = `calc(${dialogMaxHeight} - 80px)`;
+        content.style.overflow = 'auto';
+        // Create full editor
+        this.dialogEditor = document.createElement('nile-code-editor');
+        const minLines = this.options?.dialogMinLines ?? 20;
+        const currentValue = this.getLiveEditorValue();
+        const currentLineCount = (currentValue.match(/\n/g) || []).length + 1;
+        const paddingLines = Math.max(0, minLines - currentLineCount);
+        this.dialogEditor.value = currentValue + '\n'.repeat(paddingLines);
+        this.dialogEditor.multiline = true;
+        this.dialogEditor.lineNumbersMultiline = true;
+        this.dialogEditor.hasScroller = true;
+        const lineHeightPx = 20;
+        const minHeightFromLines = `${minLines * lineHeightPx}px`;
+        this.dialogEditor.style.minHeight = `max(${dialogEditorHeight}, ${minHeightFromLines})`;
+        this.dialogEditor.style.maxHeight = `calc(${dialogMaxHeight} - 120px)`;
+        content.style.setProperty('--dialog-editor-min-height', `max(${dialogEditorHeight}, ${minHeightFromLines})`);
+        // Apply same options to dialog editor
+        if (this.options?.language) {
+            this.dialogEditor.language = this.options.language;
+        }
+        if (this.options?.placeholder) {
+            this.dialogEditor.placeholder = this.options.placeholder;
+        }
+        if (this.options?.tabCompletion !== undefined) {
+            this.dialogEditor.tabCompletion = this.options.tabCompletion;
+        }
+        if (this.options?.enableSearch !== undefined) {
+            this.dialogEditor.enableSearch = this.options.enableSearch;
+        }
+        if (this.options?.enableFoldGutters !== undefined) {
+            this.dialogEditor.enableFoldGutters = this.options.enableFoldGutters;
+        }
+        if (this.options?.customAutoCompletions) {
+            this.dialogEditor.customAutoCompletions = this.options.customAutoCompletions;
+        }
+        if (this.options?.customCompletionsPaths) {
+            this.dialogEditor.customCompletionsPaths = this.options.customCompletionsPaths;
+        }
+        if (this.options?.customThemeCSS) {
+            this.dialogEditor.customThemeCSS = this.options.customThemeCSS;
+        }
+        this.dialogEditor.expandable = false;
+        // Real-time sync: Update cell editor whenever dialog editor changes
+        this.dialogEditor.addEventListener('nile-change', (e) => {
+            const dialogValue = e.detail?.value || '';
+            this.trackedValue = dialogValue;
+            if (this.editor) {
+                this.editor.value = dialogValue;
+            }
+            if (this.context) {
+                this.context.onChange(dialogValue);
+            }
+        });
+        content.appendChild(this.dialogEditor);
+        this.dialog.appendChild(content);
+        // Handle dialog close events (clicking X button - stay in edit mode)
+        this.dialog.addEventListener('nile-request-close', (e) => {
+            const customEvent = e;
+            // Check if close was triggered by overlay click (clicking outside)
+            if (customEvent.detail?.source === 'overlay') {
+                // Clicking outside the dialog - save and exit edit mode
+                this.closeDialog(true);
+            }
+            else {
+                // Clicking X button - stay in edit mode
+                this.closeDialog(false);
+            }
+        });
+        // Handle Escape key in dialog - stay in edit mode
+        this.dialog.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') {
+                e.preventDefault();
+                e.stopPropagation();
+                this.closeDialog(false);
+            }
+        });
+        // Append to body and show
+        document.body.appendChild(this.dialog);
+        // Open dialog after a tick to ensure it's in the DOM
+        setTimeout(() => {
+            if (this.dialog) {
+                this.dialog.open = true;
+                // Focus the dialog editor
+                setTimeout(() => {
+                    this.dialogEditor?.focus();
+                }, 100);
+            }
+        }, 0);
+    }
+    /**
+     * Close the dialog and optionally save/exit edit mode
+     */
+    closeDialog(saveAndExit = false) {
+        if (!this.dialogOpen)
+            return;
+        // Reset flag immediately so document click handler works
+        this.dialogOpen = false;
+        // Close and remove dialog
+        if (this.dialog) {
+            this.dialog.open = false;
+            const dialogRef = this.dialog;
+            const dialogEditorRef = this.dialogEditor;
+            this.dialog = undefined;
+            this.dialogEditor = undefined;
+            // Remove from DOM after animation
+            setTimeout(() => {
+                dialogRef?.remove();
+            }, 200);
+            if (saveAndExit && this.context) {
+                // Save and exit edit mode
+                this.context.onSave(this.getCurrentValue());
+            }
+            else {
+                // Refocus the cell editor to stay in edit mode
+                setTimeout(() => {
+                    this.focusEditor();
+                }, 50);
+            }
+        }
+    }
+    /**
+     * Apply all configuration options to the NileCodeEditor element
+     */
+    applyOptions() {
+        if (!this.editor)
+            return;
+        // Language and syntax
+        if (this.options?.language) {
+            this.editor.language = this.options.language;
+        }
+        if (this.options?.disableSyntaxHighlighting) {
+            this.editor.disableSyntaxHighlighting = this.options.disableSyntaxHighlighting;
+        }
+        // Editor appearance
+        if (this.options?.placeholder) {
+            this.editor.placeholder = this.options.placeholder;
+        }
+        if (this.options?.lineNumbers !== undefined) {
+            this.editor.lineNumbers = this.options.lineNumbers;
+        }
+        if (this.options?.lineNumbersMultiline !== undefined) {
+            this.editor.lineNumbersMultiline = this.options.lineNumbersMultiline;
+        }
+        if (this.options?.multiline !== undefined) {
+            this.editor.multiline = this.options.multiline;
+        }
+        if (this.options?.defaultFont !== undefined) {
+            this.editor.defaultFont = this.options.defaultFont;
+        }
+        // Editor behavior
+        if (this.options?.readonly !== undefined) {
+            this.editor.readonly = this.options.readonly;
+        }
+        if (this.options?.disabled !== undefined) {
+            this.editor.disabled = this.options.disabled;
+        }
+        if (this.options?.tabCompletion !== undefined) {
+            this.editor.tabCompletion = this.options.tabCompletion;
+        }
+        if (this.options?.enableSearch !== undefined) {
+            this.editor.enableSearch = this.options.enableSearch;
+        }
+        if (this.options?.enableFoldGutters !== undefined) {
+            this.editor.enableFoldGutters = this.options.enableFoldGutters;
+        }
+        if (this.options?.hasScroller !== undefined) {
+            this.editor.hasScroller = this.options.hasScroller;
+        }
+        // Expandable - default to false for cell editing
+        this.editor.expandable = this.options?.expandable ?? false;
+        if (this.options?.expandIcon) {
+            this.editor.expandIcon = this.options.expandIcon;
+        }
+        // Autocompletion
+        if (this.options?.customAutoCompletions) {
+            this.editor.customAutoCompletions = this.options.customAutoCompletions;
+        }
+        if (this.options?.customCompletionsPaths) {
+            this.editor.customCompletionsPaths = this.options.customCompletionsPaths;
+        }
+        if (this.options?.allowVariableInCustomSuggestion !== undefined) {
+            this.editor.allowVariableInCustomSuggestion = this.options.allowVariableInCustomSuggestion;
+        }
+        if (this.options?.aboveCursor !== undefined) {
+            this.editor.aboveCursor = this.options.aboveCursor;
+        }
+        if (this.options?.autoCompleteStyle) {
+            this.editor.autoCompleteStyle = this.options.autoCompleteStyle;
+        }
+        // Change handling
+        if (this.options?.debounce !== undefined) {
+            this.editor.debounce = this.options.debounce;
+        }
+        if (this.options?.debounceTimeout !== undefined) {
+            this.editor.debounceTimeout = this.options.debounceTimeout;
+        }
+        // Visual states
+        if (this.options?.error !== undefined) {
+            this.editor.error = this.options.error;
+        }
+        if (this.options?.errorMessage) {
+            this.editor.errorMessage = this.options.errorMessage;
+        }
+        // Custom theme
+        if (this.options?.customThemeCSS) {
+            this.editor.customThemeCSS = this.options.customThemeCSS;
+        }
+    }
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    setupEventListeners(context) {
+        if (!this.editor)
+            return;
+        const validateOnSave = this.options?.validateOnSave !== false;
+        // Handle keyboard events
+        const keydownHandler = (e) => {
+            const keyEvent = e;
+            // For single-line mode, Enter saves
+            if (!this.options?.multiline && keyEvent.key === 'Enter') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                this.saveValue(context, validateOnSave);
+            }
+            // Escape cancels
+            if (keyEvent.key === 'Escape') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                context.onCancel();
+            }
+        };
+        this.editor.addEventListener('keydown', keydownHandler);
+        this.eventListeners.push({ event: 'keydown', handler: keydownHandler });
+        // Use nile-blur event for saving on blur
+        const blurHandler = () => {
+            // Don't save if dialog is open
+            if (this.dialogOpen) {
+                return;
+            }
+            // Don't save if expand button was clicked (mousedown sets this flag)
+            if (this.expandButtonClicked) {
+                // Reset flag - the click handler will open the dialog
+                this.expandButtonClicked = false;
+                return;
+            }
+            // Save and exit edit mode
+            this.saveValue(context, validateOnSave);
+        };
+        this.editor.addEventListener('nile-blur', blurHandler);
+        this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });
+        // Document-level mousedown handler to detect clicks outside the editor
+        this.documentClickHandler = (e) => {
+            // Don't process if dialog is open or expand button was clicked
+            if (this.dialogOpen || this.expandButtonClicked) {
+                return;
+            }
+            // Use composedPath to handle Shadow DOM boundaries
+            const path = e.composedPath();
+            // Check if any element in the path is our wrapper, editor, or expand button
+            for (const element of path) {
+                if (element === this.wrapper || element === this.editor || element === this.expandButton) {
+                    return;
+                }
+                // Also check if it's the container (the cell)
+                if (element === context.container) {
+                    return;
+                }
+            }
+            // Click is outside - save and exit
+            this.saveValue(context, validateOnSave);
+        };
+        // Add with a small delay to avoid capturing the initial click that opened the editor
+        setTimeout(() => {
+            document.addEventListener('mousedown', this.documentClickHandler, true);
+        }, 50);
+        // Real-time value updates using nile-change
+        const changeHandler = (e) => {
+            const customEvent = e;
+            const newValue = customEvent.detail?.value ?? '';
+            this.trackedValue = newValue;
+            context.onChange(newValue);
+        };
+        this.editor.addEventListener('nile-change', changeHandler);
+        this.eventListeners.push({ event: 'nile-change', handler: changeHandler });
+        // Handle expand event if expandable
+        if (this.options?.expandable) {
+            const expandHandler = () => {
+                // Emit a custom event that the parent can listen to
+                const expandEvent = new CustomEvent('st-code-editor-expand', {
+                    bubbles: true,
+                    detail: { value: this.getCurrentValue() }
+                });
+                this.editor?.dispatchEvent(expandEvent);
+            };
+            this.editor.addEventListener('nile-expand', expandHandler);
+            this.eventListeners.push({ event: 'nile-expand', handler: expandHandler });
+        }
+    }
+    /**
+     * Save value with optional validation
+     */
+    saveValue(context, validate) {
+        if (!this.editor)
+            return;
+        // Code editor doesn't have built-in validation like input
+        // But we can check for error state
+        if (validate && this.options?.error) {
+            return;
+        }
+        const value = this.getCurrentValue();
+        context.onSave(value);
+    }
+    destroy() {
+        // Remove document click handler
+        if (this.documentClickHandler) {
+            document.removeEventListener('mousedown', this.documentClickHandler, true);
+            this.documentClickHandler = undefined;
+        }
+        // Close dialog if open
+        if (this.dialogOpen && this.dialog) {
+            this.dialog.open = false;
+            this.dialog.remove();
+            this.dialog = undefined;
+            this.dialogEditor = undefined;
+            this.dialogOpen = false;
+        }
+        // Remove all event listeners
+        if (this.editor) {
+            this.eventListeners.forEach(({ event, handler }) => {
+                this.editor?.removeEventListener(event, handler);
+            });
+            this.eventListeners = [];
+            this.editor.remove();
+            this.editor = undefined;
+        }
+        // Remove wrapper if exists
+        if (this.wrapper) {
+            this.wrapper.remove();
+            this.wrapper = undefined;
+        }
+        // Clear expand button reference
+        this.expandButton = undefined;
+        this.context = undefined;
+        this.expandButtonClicked = false;
+    }
+    focus() {
+        this.editor?.focus();
+    }
+    getCurrentValue() {
+        if (!this.editor)
+            return '';
+        const value = this.getLiveEditorValue();
+        return value.replace(/\n+$/, '');
+    }
+    /**
+     * Set value programmatically
+     */
+    setValue(value) {
+        if (this.editor) {
+            this.editor.value = String(value ?? '');
+        }
+    }
+    /**
+     * Get the CodeMirror instance (if needed for advanced usage)
+     */
+    getEditorInstance() {
+        return this.editor;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nile-code-editor.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/editors/nile-code-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom editor using NileCodeEditor from @aquera/nile-elements\n * This provides code editing capabilities with syntax highlighting for table cells\n */\n\nimport { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';\n\n/**\n * Autocompletion item configuration\n */\nexport interface CodeEditorCompletion {\n  /** The completion label shown in dropdown */\n  label: string;\n  /** The value to insert */\n  value?: string;\n  /** Optional description */\n  detail?: string;\n}\n\n/**\n * Autocomplete style configuration\n */\nexport interface AutoCompleteStyle {\n  /** Width of the autocomplete dropdown */\n  width?: string;\n  /** Enable multiline content in autocomplete */\n  multiline?: boolean;\n}\n\n/**\n * Options interface for NileCodeEditor\n */\nexport interface NileCodeEditorOptions {\n  // Language and syntax\n  /** Language mode for syntax highlighting */\n  language?: 'javascript' | 'sql' | 'json' | 'html';\n  /** Disable syntax highlighting */\n  disableSyntaxHighlighting?: boolean;\n\n  // Editor appearance\n  /** Placeholder text when empty */\n  placeholder?: string;\n  /** Show line numbers (single-line mode) */\n  lineNumbers?: boolean;\n  /** Show line numbers in multiline mode */\n  lineNumbersMultiline?: boolean;\n  /** Allow multi-line editing */\n  multiline?: boolean;\n  /** Render without border */\n  noborder?: boolean;\n  /** Use default font instead of inherit */\n  defaultFont?: boolean;\n\n  // Editor behavior\n  /** Auto focus on edit */\n  autoFocus?: boolean;\n  /** Read-only mode */\n  readonly?: boolean;\n  /** Disabled state */\n  disabled?: boolean;\n  /** Enable Tab-to-complete */\n  tabCompletion?: boolean;\n  /** Enable search keymap */\n  enableSearch?: boolean;\n  /** Show code folding gutters */\n  enableFoldGutters?: boolean;\n  /** Internal scroll container */\n  hasScroller?: boolean;\n  /** Show expand control (native nile-code-editor expand) */\n  expandable?: boolean;\n  /** Icon for expand control */\n  expandIcon?: string;\n  \n  // Dialog expand feature\n  /** Show expand button to open full editor dialog (default: true) */\n  showExpandButton?: boolean;\n  /** Dialog title (default: 'Edit Code') */\n  dialogTitle?: string;\n  /** Dialog width (default: '600px') */\n  dialogWidth?: string;\n  /** Dialog max height (default: '80vh') */\n  dialogMaxHeight?: string;\n  /** Dialog editor min height (default: '300px') */\n  dialogEditorHeight?: string;\n  /** Minimum number of visible lines in the dialog editor (default: 20) */\n  dialogMinLines?: number;\n\n  // Autocompletion\n  /** Inline completion dataset */\n  customAutoCompletions?: Record<string, CodeEditorCompletion[]> | CodeEditorCompletion[];\n  /** Paths to fetch completion datasets from */\n  customCompletionsPaths?: string[];\n  /** Enable variables in suggestions */\n  allowVariableInCustomSuggestion?: boolean;\n  /** Show autocomplete above cursor */\n  aboveCursor?: boolean;\n  /** Style config for autocomplete dropdown */\n  autoCompleteStyle?: AutoCompleteStyle;\n\n  // Change handling\n  /** Debounce change events */\n  debounce?: boolean;\n  /** Debounce delay in ms */\n  debounceTimeout?: number;\n\n  // Visual states\n  /** Error state */\n  error?: boolean;\n  /** Error message to display */\n  errorMessage?: string;\n\n  // Custom theme\n  /** Custom theme CSS object */\n  customThemeCSS?: Record<string, Record<string, string>>;\n\n  // Validation behavior\n  /** Validate before saving (default: true) */\n  validateOnSave?: boolean;\n}\n\n/**\n * Inject global styles for nile-code-editor in table cells\n */\nlet codeEditorStylesInjected = false;\nfunction injectCodeEditorStyles(): void {\n  if (codeEditorStylesInjected) return;\n  codeEditorStylesInjected = true;\n\n  const styleId = 'nile-code-editor-cell-styles';\n  if (document.getElementById(styleId)) return;\n\n  const style = document.createElement('style');\n  style.id = styleId;\n  style.textContent = `\n    /* Nile Code Editor cell styling */\n    nile-code-editor.st-cell-editor {\n      display: block;\n      width: 100%;\n      height: 100%;\n      font-size: inherit !important;\n      font-family: inherit !important;\n      line-height: inherit !important;\n    }\n    nile-code-editor.st-cell-editor::part(code-editor-base) {\n      border: none !important;\n      min-height: 100% !important;\n      background: transparent !important;\n      font-size: inherit !important;\n      font-family: inherit !important;\n      line-height: inherit !important;\n    }\n    /* Ensure proper sizing within table cell */\n    .st-nile-code-editor {\n      width: 100%;\n      height: 100%;\n      min-height: 28px;\n      font-size: inherit !important;\n    }\n    /* CodeMirror content should inherit font size */\n    nile-code-editor.st-cell-editor .cm-content,\n    nile-code-editor.st-cell-editor .cm-line {\n      font-size: inherit !important;\n      font-family: inherit !important;\n      line-height: inherit !important;\n    }\n    /* Container wrapper for editor + expand button */\n    .st-code-editor-wrapper {\n      display: flex;\n      align-items: center;\n      width: 100%;\n      height: 100%;\n      gap: 4px;\n    }\n    .st-code-editor-wrapper .st-code-editor-input {\n      flex: 1;\n      min-width: 0;\n      height: 100%;\n    }\n    .st-code-editor-wrapper .st-expand-button {\n      display: flex;\n      align-items: center;\n      justify-content: center;\n      width: 24px;\n      height: 24px;\n      min-width: 24px;\n      padding: 0;\n      border: none;\n      background: transparent;\n      cursor: pointer;\n      color: var(--nile-color-neutral-500, #6b7280);\n      border-radius: 4px;\n      transition: all 0.2s;\n    }\n    .st-code-editor-wrapper .st-expand-button:hover {\n      background: var(--nile-color-neutral-100, #f3f4f6);\n      color: var(--nile-color-neutral-700, #374151);\n    }\n    /* Dialog code editor styling */\n    .st-code-editor-dialog::part(panel) {\n      max-height: var(--max-height, 80vh) !important;\n      overflow: hidden !important;\n    }\n    .st-code-editor-dialog::part(body) {\n      overflow: auto !important;\n    }\n    .st-code-editor-dialog nile-code-editor {\n      width: 100%;\n      display: block;\n    }\n    .st-code-editor-dialog nile-code-editor::part(code-editor-base) {\n      border: 1px solid var(--nile-color-neutral-200, #e5e7eb) !important;\n      border-radius: 4px !important;\n      overflow: auto !important;\n      min-height: var(--dialog-editor-min-height, 300px) !important;\n    }\n    .st-code-editor-dialog nile-code-editor .cm-editor {\n      min-height: var(--dialog-editor-min-height, 300px) !important;\n    }\n    .st-code-editor-dialog nile-code-editor .cm-content {\n      min-height: var(--dialog-editor-min-height, 300px) !important;\n    }\n  `;\n  document.head.appendChild(style);\n}\n\n/**\n * Custom editor that uses NileCodeEditor component\n * Provides code editing with syntax highlighting for table cells\n * @template T The value type (typically string)\n */\nexport class NileCodeEditor<T = string> implements CellEditor<T> {\n  private editor?: any;\n  private wrapper?: HTMLDivElement;\n  private expandButton?: HTMLButtonElement;\n  private dialog?: any;\n  private dialogEditor?: any;\n  private eventListeners: Array<{ event: string; handler: EventListener }> = [];\n  private context?: CellEditorContext<T>;\n  private dialogOpen = false;\n  private expandButtonClicked = false;\n  private documentClickHandler?: (e: MouseEvent) => void;\n  private trackedValue: string | null = null;\n\n  constructor(private readonly options?: NileCodeEditorOptions) {}\n\n  edit(context: CellEditorContext<T>): void {\n    if (!context.container) {\n      console.warn('NileCodeEditor requires a container element');\n      return;\n    }\n\n    this.context = context;\n    this.trackedValue = null;\n\n    // Inject global styles once\n    injectCodeEditorStyles();\n\n    // Check if we should show expand button (default: true)\n    const showExpandButton = this.options?.showExpandButton !== false;\n\n    if (showExpandButton) {\n      // Create wrapper for editor + expand button\n      this.wrapper = document.createElement('div');\n      this.wrapper.className = 'st-code-editor-wrapper';\n\n      // Create the editor container\n      const editorContainer = document.createElement('div');\n      editorContainer.className = 'st-code-editor-input';\n\n      // Create NileCodeEditor custom element\n      this.editor = document.createElement('nile-code-editor');\n      this.editor.value = String(context.value ?? '');\n      this.editor.className = 'st-cell-editor st-nile-code-editor';\n      this.editor.style.width = '100%';\n      this.editor.style.height = '100%';\n      this.editor.style.boxSizing = 'border-box';\n      this.editor.noborder = this.options?.noborder !== false;\n\n      editorContainer.appendChild(this.editor);\n      this.wrapper.appendChild(editorContainer);\n\n      // Create expand button\n      this.expandButton = document.createElement('button');\n      this.expandButton.className = 'st-expand-button';\n      this.expandButton.type = 'button';\n      this.expandButton.title = 'Expand editor';\n      this.expandButton.innerHTML = '<nile-icon name=\"expand-06\" size=\"16\"></nile-icon>';\n      \n      // Use mousedown to set flag BEFORE blur event fires\n      this.expandButton.addEventListener('mousedown', (e) => {\n        e.preventDefault();\n        e.stopPropagation();\n        this.expandButtonClicked = true;\n      });\n      \n      this.expandButton.addEventListener('click', (e) => {\n        e.preventDefault();\n        e.stopPropagation();\n        this.openDialog();\n      });\n      this.wrapper.appendChild(this.expandButton);\n\n      // Clear container and append wrapper\n      context.container.innerHTML = '';\n      context.container.appendChild(this.wrapper);\n    } else {\n      // Create NileCodeEditor custom element without wrapper\n      this.editor = document.createElement('nile-code-editor');\n      this.editor.value = String(context.value ?? '');\n      this.editor.className = 'st-cell-editor st-nile-code-editor';\n      this.editor.style.width = '100%';\n      this.editor.style.height = '100%';\n      this.editor.style.boxSizing = 'border-box';\n      this.editor.noborder = this.options?.noborder !== false;\n\n      // Clear container and append editor\n      context.container.innerHTML = '';\n      context.container.appendChild(this.editor);\n    }\n\n    // Apply all configuration options\n    this.applyOptions();\n\n    // Set up event listeners\n    this.setupEventListeners(context);\n\n    // Auto focus - need a slight delay for nile-code-editor to fully initialize\n    if (this.options?.autoFocus !== false) {\n      // Listen for the nile-after-init event which fires when editor is ready\n      const initHandler = () => {\n        this.editor?.removeEventListener('nile-after-init', initHandler);\n        this.focusEditor();\n      };\n      this.editor.addEventListener('nile-after-init', initHandler);\n      \n      // Fallback: also try after a delay in case the event already fired\n      setTimeout(() => {\n        this.focusEditor();\n      }, 100);\n    }\n  }\n\n  /**\n   * Focus the editor and place cursor\n   */\n  private focusEditor(): void {\n    if (!this.editor) return;\n    \n    try {\n      // Call the component's focus method\n      this.editor.focus();\n      \n      // Try to directly focus the CodeMirror content area\n      const shadowRoot = this.editor.shadowRoot;\n      if (shadowRoot) {\n        const cmContent = shadowRoot.querySelector('.cm-content') as HTMLElement;\n        if (cmContent) {\n          cmContent.focus();\n          // Dispatch a click event to ensure cursor placement\n          cmContent.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));\n          cmContent.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));\n        }\n      }\n    } catch (e) {\n      // Silently handle any errors\n    }\n  }\n\n  /**\n   * Read the live value directly from CodeMirror's internal state,\n   * bypassing debounced nile-change events and the possibly-stale .value property.\n   */\n  private getLiveEditorValue(): string {\n    if (!this.editor) return '';\n\n    try {\n      const shadowRoot = this.editor.shadowRoot;\n      if (shadowRoot) {\n        const cmEditor = shadowRoot.querySelector('.cm-editor') as any;\n        if (cmEditor?.cmView?.view) {\n          return cmEditor.cmView.view.state.doc.toString();\n        }\n      }\n    } catch {\n      // Fall through to other methods\n    }\n\n    if (this.trackedValue !== null) return this.trackedValue;\n    return this.editor.value ?? '';\n  }\n\n  /**\n   * Open the full editor dialog\n   */\n  private openDialog(): void {\n    if (this.dialogOpen) return;\n    this.dialogOpen = true;\n    this.expandButtonClicked = false; // Reset flag now that dialog is opening\n\n    // Create dialog with configurable dimensions\n    const dialogWidth = this.options?.dialogWidth || '600px';\n    const dialogMaxHeight = this.options?.dialogMaxHeight || '80vh';\n    const dialogEditorHeight = this.options?.dialogEditorHeight || '300px';\n    const dialogTitle = this.options?.dialogTitle || 'Edit Code';\n\n    this.dialog = document.createElement('nile-dialog');\n    this.dialog.className = 'st-code-editor-dialog';\n    this.dialog.label = dialogTitle;\n    this.dialog.style.setProperty('--width', dialogWidth);\n    this.dialog.style.setProperty('--max-height', dialogMaxHeight);\n\n    // Create dialog content\n    const content = document.createElement('div');\n    content.style.padding = '16px';\n    content.style.maxHeight = `calc(${dialogMaxHeight} - 80px)`;\n    content.style.overflow = 'auto';\n\n    // Create full editor\n    this.dialogEditor = document.createElement('nile-code-editor');\n    const minLines = this.options?.dialogMinLines ?? 20;\n    const currentValue = this.getLiveEditorValue();\n    const currentLineCount = (currentValue.match(/\\n/g) || []).length + 1;\n    const paddingLines = Math.max(0, minLines - currentLineCount);\n    this.dialogEditor.value = currentValue + '\\n'.repeat(paddingLines);\n    this.dialogEditor.multiline = true;\n    this.dialogEditor.lineNumbersMultiline = true;\n    this.dialogEditor.hasScroller = true;\n    const lineHeightPx = 20;\n    const minHeightFromLines = `${minLines * lineHeightPx}px`;\n    this.dialogEditor.style.minHeight = `max(${dialogEditorHeight}, ${minHeightFromLines})`;\n    this.dialogEditor.style.maxHeight = `calc(${dialogMaxHeight} - 120px)`;\n    content.style.setProperty('--dialog-editor-min-height', `max(${dialogEditorHeight}, ${minHeightFromLines})`);\n\n    // Apply same options to dialog editor\n    if (this.options?.language) {\n      this.dialogEditor.language = this.options.language;\n    }\n    if (this.options?.placeholder) {\n      this.dialogEditor.placeholder = this.options.placeholder;\n    }\n    if (this.options?.tabCompletion !== undefined) {\n      this.dialogEditor.tabCompletion = this.options.tabCompletion;\n    }\n    if (this.options?.enableSearch !== undefined) {\n      this.dialogEditor.enableSearch = this.options.enableSearch;\n    }\n    if (this.options?.enableFoldGutters !== undefined) {\n      this.dialogEditor.enableFoldGutters = this.options.enableFoldGutters;\n    }\n    if (this.options?.customAutoCompletions) {\n      this.dialogEditor.customAutoCompletions = this.options.customAutoCompletions;\n    }\n    if (this.options?.customCompletionsPaths) {\n      this.dialogEditor.customCompletionsPaths = this.options.customCompletionsPaths;\n    }\n    if (this.options?.customThemeCSS) {\n      this.dialogEditor.customThemeCSS = this.options.customThemeCSS;\n    }\n\n    this.dialogEditor.expandable = false;\n\n    // Real-time sync: Update cell editor whenever dialog editor changes\n    this.dialogEditor.addEventListener('nile-change', (e: CustomEvent) => {\n      const dialogValue = e.detail?.value || '';\n      this.trackedValue = dialogValue;\n      if (this.editor) {\n        this.editor.value = dialogValue;\n      }\n      if (this.context) {\n        this.context.onChange(dialogValue as T);\n      }\n    });\n\n    content.appendChild(this.dialogEditor);\n    this.dialog.appendChild(content);\n\n    // Handle dialog close events (clicking X button - stay in edit mode)\n    this.dialog.addEventListener('nile-request-close', (e: Event) => {\n      const customEvent = e as CustomEvent;\n      // Check if close was triggered by overlay click (clicking outside)\n      if (customEvent.detail?.source === 'overlay') {\n        // Clicking outside the dialog - save and exit edit mode\n        this.closeDialog(true);\n      } else {\n        // Clicking X button - stay in edit mode\n        this.closeDialog(false);\n      }\n    });\n\n    // Handle Escape key in dialog - stay in edit mode\n    this.dialog.addEventListener('keydown', (e: KeyboardEvent) => {\n      if (e.key === 'Escape') {\n        e.preventDefault();\n        e.stopPropagation();\n        this.closeDialog(false);\n      }\n    });\n\n    // Append to body and show\n    document.body.appendChild(this.dialog);\n    \n    // Open dialog after a tick to ensure it's in the DOM\n    setTimeout(() => {\n      if (this.dialog) {\n        this.dialog.open = true;\n        // Focus the dialog editor\n        setTimeout(() => {\n          this.dialogEditor?.focus();\n        }, 100);\n      }\n    }, 0);\n  }\n\n  /**\n   * Close the dialog and optionally save/exit edit mode\n   */\n  private closeDialog(saveAndExit: boolean = false): void {\n    if (!this.dialogOpen) return;\n\n    // Reset flag immediately so document click handler works\n    this.dialogOpen = false;\n\n    // Close and remove dialog\n    if (this.dialog) {\n      this.dialog.open = false;\n      const dialogRef = this.dialog;\n      const dialogEditorRef = this.dialogEditor;\n      this.dialog = undefined;\n      this.dialogEditor = undefined;\n      \n      // Remove from DOM after animation\n      setTimeout(() => {\n        dialogRef?.remove();\n      }, 200);\n      \n      if (saveAndExit && this.context) {\n        // Save and exit edit mode\n        this.context.onSave(this.getCurrentValue());\n      } else {\n        // Refocus the cell editor to stay in edit mode\n        setTimeout(() => {\n          this.focusEditor();\n        }, 50);\n      }\n    }\n  }\n\n  /**\n   * Apply all configuration options to the NileCodeEditor element\n   */\n  private applyOptions(): void {\n    if (!this.editor) return;\n\n    // Language and syntax\n    if (this.options?.language) {\n      this.editor.language = this.options.language;\n    }\n\n    if (this.options?.disableSyntaxHighlighting) {\n      this.editor.disableSyntaxHighlighting = this.options.disableSyntaxHighlighting;\n    }\n\n    // Editor appearance\n    if (this.options?.placeholder) {\n      this.editor.placeholder = this.options.placeholder;\n    }\n\n    if (this.options?.lineNumbers !== undefined) {\n      this.editor.lineNumbers = this.options.lineNumbers;\n    }\n\n    if (this.options?.lineNumbersMultiline !== undefined) {\n      this.editor.lineNumbersMultiline = this.options.lineNumbersMultiline;\n    }\n\n    if (this.options?.multiline !== undefined) {\n      this.editor.multiline = this.options.multiline;\n    }\n\n    if (this.options?.defaultFont !== undefined) {\n      this.editor.defaultFont = this.options.defaultFont;\n    }\n\n    // Editor behavior\n    if (this.options?.readonly !== undefined) {\n      this.editor.readonly = this.options.readonly;\n    }\n\n    if (this.options?.disabled !== undefined) {\n      this.editor.disabled = this.options.disabled;\n    }\n\n    if (this.options?.tabCompletion !== undefined) {\n      this.editor.tabCompletion = this.options.tabCompletion;\n    }\n\n    if (this.options?.enableSearch !== undefined) {\n      this.editor.enableSearch = this.options.enableSearch;\n    }\n\n    if (this.options?.enableFoldGutters !== undefined) {\n      this.editor.enableFoldGutters = this.options.enableFoldGutters;\n    }\n\n    if (this.options?.hasScroller !== undefined) {\n      this.editor.hasScroller = this.options.hasScroller;\n    }\n\n    // Expandable - default to false for cell editing\n    this.editor.expandable = this.options?.expandable ?? false;\n\n    if (this.options?.expandIcon) {\n      this.editor.expandIcon = this.options.expandIcon;\n    }\n\n    // Autocompletion\n    if (this.options?.customAutoCompletions) {\n      this.editor.customAutoCompletions = this.options.customAutoCompletions;\n    }\n\n    if (this.options?.customCompletionsPaths) {\n      this.editor.customCompletionsPaths = this.options.customCompletionsPaths;\n    }\n\n    if (this.options?.allowVariableInCustomSuggestion !== undefined) {\n      this.editor.allowVariableInCustomSuggestion = this.options.allowVariableInCustomSuggestion;\n    }\n\n    if (this.options?.aboveCursor !== undefined) {\n      this.editor.aboveCursor = this.options.aboveCursor;\n    }\n\n    if (this.options?.autoCompleteStyle) {\n      this.editor.autoCompleteStyle = this.options.autoCompleteStyle;\n    }\n\n    // Change handling\n    if (this.options?.debounce !== undefined) {\n      this.editor.debounce = this.options.debounce;\n    }\n\n    if (this.options?.debounceTimeout !== undefined) {\n      this.editor.debounceTimeout = this.options.debounceTimeout;\n    }\n\n    // Visual states\n    if (this.options?.error !== undefined) {\n      this.editor.error = this.options.error;\n    }\n\n    if (this.options?.errorMessage) {\n      this.editor.errorMessage = this.options.errorMessage;\n    }\n\n    // Custom theme\n    if (this.options?.customThemeCSS) {\n      this.editor.customThemeCSS = this.options.customThemeCSS;\n    }\n  }\n\n  /**\n   * Set up all event listeners with proper cleanup tracking\n   */\n  private setupEventListeners(context: CellEditorContext<T>): void {\n    if (!this.editor) return;\n\n    const validateOnSave = this.options?.validateOnSave !== false;\n\n    // Handle keyboard events\n    const keydownHandler = (e: Event) => {\n      const keyEvent = e as KeyboardEvent;\n      \n      // For single-line mode, Enter saves\n      if (!this.options?.multiline && keyEvent.key === 'Enter') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        this.saveValue(context, validateOnSave);\n      }\n      \n      // Escape cancels\n      if (keyEvent.key === 'Escape') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        context.onCancel();\n      }\n    };\n    this.editor.addEventListener('keydown', keydownHandler);\n    this.eventListeners.push({ event: 'keydown', handler: keydownHandler });\n\n    // Use nile-blur event for saving on blur\n    const blurHandler = () => {\n      // Don't save if dialog is open\n      if (this.dialogOpen) {\n        return;\n      }\n      \n      // Don't save if expand button was clicked (mousedown sets this flag)\n      if (this.expandButtonClicked) {\n        // Reset flag - the click handler will open the dialog\n        this.expandButtonClicked = false;\n        return;\n      }\n      \n      // Save and exit edit mode\n      this.saveValue(context, validateOnSave);\n    };\n    this.editor.addEventListener('nile-blur', blurHandler);\n    this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });\n\n    // Document-level mousedown handler to detect clicks outside the editor\n    this.documentClickHandler = (e: MouseEvent) => {\n      // Don't process if dialog is open or expand button was clicked\n      if (this.dialogOpen || this.expandButtonClicked) {\n        return;\n      }\n\n      // Use composedPath to handle Shadow DOM boundaries\n      const path = e.composedPath();\n      \n      // Check if any element in the path is our wrapper, editor, or expand button\n      for (const element of path) {\n        if (element === this.wrapper || element === this.editor || element === this.expandButton) {\n          return;\n        }\n        // Also check if it's the container (the cell)\n        if (element === context.container) {\n          return;\n        }\n      }\n\n      // Click is outside - save and exit\n      this.saveValue(context, validateOnSave);\n    };\n\n    // Add with a small delay to avoid capturing the initial click that opened the editor\n    setTimeout(() => {\n      document.addEventListener('mousedown', this.documentClickHandler!, true);\n    }, 50);\n\n    // Real-time value updates using nile-change\n    const changeHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      const newValue = customEvent.detail?.value ?? '';\n      this.trackedValue = newValue;\n      context.onChange(newValue as T);\n    };\n    this.editor.addEventListener('nile-change', changeHandler);\n    this.eventListeners.push({ event: 'nile-change', handler: changeHandler });\n\n    // Handle expand event if expandable\n    if (this.options?.expandable) {\n      const expandHandler = () => {\n        // Emit a custom event that the parent can listen to\n        const expandEvent = new CustomEvent('st-code-editor-expand', {\n          bubbles: true,\n          detail: { value: this.getCurrentValue() }\n        });\n        this.editor?.dispatchEvent(expandEvent);\n      };\n      this.editor.addEventListener('nile-expand', expandHandler);\n      this.eventListeners.push({ event: 'nile-expand', handler: expandHandler });\n    }\n  }\n\n  /**\n   * Save value with optional validation\n   */\n  private saveValue(context: CellEditorContext<T>, validate: boolean): void {\n    if (!this.editor) return;\n\n    // Code editor doesn't have built-in validation like input\n    // But we can check for error state\n    if (validate && this.options?.error) {\n      return;\n    }\n\n    const value = this.getCurrentValue();\n    context.onSave(value);\n  }\n\n  destroy(): void {\n    // Remove document click handler\n    if (this.documentClickHandler) {\n      document.removeEventListener('mousedown', this.documentClickHandler, true);\n      this.documentClickHandler = undefined;\n    }\n\n    // Close dialog if open\n    if (this.dialogOpen && this.dialog) {\n      this.dialog.open = false;\n      this.dialog.remove();\n      this.dialog = undefined;\n      this.dialogEditor = undefined;\n      this.dialogOpen = false;\n    }\n\n    // Remove all event listeners\n    if (this.editor) {\n      this.eventListeners.forEach(({ event, handler }) => {\n        this.editor?.removeEventListener(event, handler);\n      });\n      this.eventListeners = [];\n\n      this.editor.remove();\n      this.editor = undefined;\n    }\n\n    // Remove wrapper if exists\n    if (this.wrapper) {\n      this.wrapper.remove();\n      this.wrapper = undefined;\n    }\n\n    // Clear expand button reference\n    this.expandButton = undefined;\n    this.context = undefined;\n    this.expandButtonClicked = false;\n  }\n\n  focus(): void {\n    this.editor?.focus();\n  }\n\n  getCurrentValue(): T {\n    if (!this.editor) return '' as unknown as T;\n    const value = this.getLiveEditorValue();\n    return value.replace(/\\n+$/, '') as unknown as T;\n  }\n\n  /**\n   * Set value programmatically\n   */\n  setValue(value: T): void {\n    if (this.editor) {\n      this.editor.value = String(value ?? '');\n    }\n  }\n\n  /**\n   * Get the CodeMirror instance (if needed for advanced usage)\n   */\n  getEditorInstance(): any {\n    return this.editor;\n  }\n}\n"]}