@aquera/ngx-smart-table 0.0.17-patch-0.4 → 0.0.17-patch-0.6

package/esm2020/lib/editors/index.mjs

@@ -6,5 +6,6 @@ export { NileSelectEditor } from './nile-select-editor';
 export { NileAutoCompleteEditor } from './nile-autocomplete-editor';
 export { NileCalendarEditor } from './nile-calendar-editor';
 export { NileDatePickerEditor } from './nile-date-picker-editor';
+export { NileChipEditor } from './nile-chip-editor';
 export { NileCodeEditor } from './nile-code-editor';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC10YWJsZS9zcmMvbGliL2VkaXRvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUEwQixNQUFNLHFCQUFxQixDQUFDO0FBQzlFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBeUMsTUFBTSxzQkFBc0IsQ0FBQztBQUMvRixPQUFPLEVBQUUsc0JBQXNCLEVBQXFELE1BQU0sNEJBQTRCLENBQUM7QUFDdkgsT0FBTyxFQUFFLGtCQUFrQixFQUFnRCxNQUFNLHdCQUF3QixDQUFDO0FBQzFHLE9BQU8sRUFBRSxvQkFBb0IsRUFBMEMsTUFBTSwyQkFBMkIsQ0FBQztBQUN6RyxPQUFPLEVBQUUsY0FBYyxFQUFrRSxNQUFNLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXN0b20gY2VsbCBlZGl0b3JzIGZvciBuZ3gtc21hcnQtdGFibGVcbiAqL1xuXG5leHBvcnQgeyBOaWxlSW5wdXRFZGl0b3IsIE5pbGVJbnB1dEVkaXRvck9wdGlvbnMgfSBmcm9tICcuL25pbGUtaW5wdXQtZWRpdG9yJztcbmV4cG9ydCB7IE5pbGVTZWxlY3RFZGl0b3IsIE5pbGVTZWxlY3RFZGl0b3JPcHRpb25zLCBTZWxlY3RPcHRpb24gfSBmcm9tICcuL25pbGUtc2VsZWN0LWVkaXRvcic7XG5leHBvcnQgeyBOaWxlQXV0b0NvbXBsZXRlRWRpdG9yLCBOaWxlQXV0b0NvbXBsZXRlRWRpdG9yT3B0aW9ucywgQXV0b0NvbXBsZXRlT3B0aW9uIH0gZnJvbSAnLi9uaWxlLWF1dG9jb21wbGV0ZS1lZGl0b3InO1xuZXhwb3J0IHsgTmlsZUNhbGVuZGFyRWRpdG9yLCBOaWxlQ2FsZW5kYXJFZGl0b3JPcHRpb25zLCBBbGxvd2VkRGF0ZXNSYW5nZSB9IGZyb20gJy4vbmlsZS1jYWxlbmRhci1lZGl0b3InO1xuZXhwb3J0IHsgTmlsZURhdGVQaWNrZXJFZGl0b3IsIE5pbGVEYXRlUGlja2VyRWRpdG9yT3B0aW9ucywgRGF0ZVJhbmdlIH0gZnJvbSAnLi9uaWxlLWRhdGUtcGlja2VyLWVkaXRvcic7XG5leHBvcnQgeyBOaWxlQ29kZUVkaXRvciwgTmlsZUNvZGVFZGl0b3JPcHRpb25zLCBDb2RlRWRpdG9yQ29tcGxldGlvbiwgQXV0b0NvbXBsZXRlU3R5bGUgfSBmcm9tICcuL25pbGUtY29kZS1lZGl0b3InO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC10YWJsZS9zcmMvbGliL2VkaXRvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUEwQixNQUFNLHFCQUFxQixDQUFDO0FBQzlFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBeUMsTUFBTSxzQkFBc0IsQ0FBQztBQUMvRixPQUFPLEVBQUUsc0JBQXNCLEVBQXFELE1BQU0sNEJBQTRCLENBQUM7QUFDdkgsT0FBTyxFQUFFLGtCQUFrQixFQUFnRCxNQUFNLHdCQUF3QixDQUFDO0FBQzFHLE9BQU8sRUFBRSxvQkFBb0IsRUFBMEMsTUFBTSwyQkFBMkIsQ0FBQztBQUN6RyxPQUFPLEVBQUUsY0FBYyxFQUFxQyxNQUFNLG9CQUFvQixDQUFDO0FBQ3ZGLE9BQU8sRUFBRSxjQUFjLEVBQWtFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEN1c3RvbSBjZWxsIGVkaXRvcnMgZm9yIG5neC1zbWFydC10YWJsZVxuICovXG5cbmV4cG9ydCB7IE5pbGVJbnB1dEVkaXRvciwgTmlsZUlucHV0RWRpdG9yT3B0aW9ucyB9IGZyb20gJy4vbmlsZS1pbnB1dC1lZGl0b3InO1xuZXhwb3J0IHsgTmlsZVNlbGVjdEVkaXRvciwgTmlsZVNlbGVjdEVkaXRvck9wdGlvbnMsIFNlbGVjdE9wdGlvbiB9IGZyb20gJy4vbmlsZS1zZWxlY3QtZWRpdG9yJztcbmV4cG9ydCB7IE5pbGVBdXRvQ29tcGxldGVFZGl0b3IsIE5pbGVBdXRvQ29tcGxldGVFZGl0b3JPcHRpb25zLCBBdXRvQ29tcGxldGVPcHRpb24gfSBmcm9tICcuL25pbGUtYXV0b2NvbXBsZXRlLWVkaXRvcic7XG5leHBvcnQgeyBOaWxlQ2FsZW5kYXJFZGl0b3IsIE5pbGVDYWxlbmRhckVkaXRvck9wdGlvbnMsIEFsbG93ZWREYXRlc1JhbmdlIH0gZnJvbSAnLi9uaWxlLWNhbGVuZGFyLWVkaXRvcic7XG5leHBvcnQgeyBOaWxlRGF0ZVBpY2tlckVkaXRvciwgTmlsZURhdGVQaWNrZXJFZGl0b3JPcHRpb25zLCBEYXRlUmFuZ2UgfSBmcm9tICcuL25pbGUtZGF0ZS1waWNrZXItZWRpdG9yJztcbmV4cG9ydCB7IE5pbGVDaGlwRWRpdG9yLCBOaWxlQ2hpcEVkaXRvck9wdGlvbnMsIENoaXBPcHRpb24gfSBmcm9tICcuL25pbGUtY2hpcC1lZGl0b3InO1xuZXhwb3J0IHsgTmlsZUNvZGVFZGl0b3IsIE5pbGVDb2RlRWRpdG9yT3B0aW9ucywgQ29kZUVkaXRvckNvbXBsZXRpb24sIEF1dG9Db21wbGV0ZVN0eWxlIH0gZnJvbSAnLi9uaWxlLWNvZGUtZWRpdG9yJztcbiJdfQ==

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

@@ -0,0 +1,293 @@
+/**
+ * Custom editor using NileChip from @aquera/nile-elements
+ * Renders the chip input in a floating popover below the cell to avoid row height mismatch.
+ *
+ * @see https://nile.aqueralabs.com/1.6.3/chip?theme=enterprise
+ */
+let chipStylesInjected = false;
+function injectChipStyles() {
+    if (chipStylesInjected)
+        return;
+    chipStylesInjected = true;
+    const styleId = 'nile-chip-editor-styles';
+    if (document.getElementById(styleId))
+        return;
+    const style = document.createElement('style');
+    style.id = styleId;
+    style.textContent = `
+    .st-chip-popover {
+      position: fixed;
+      z-index: 10000;
+      background: var(--nile-colors-white-base, #fff);
+      border: 1px solid var(--nile-colors-neutral-200, #e2e8f0);
+      border-radius: 6px;
+      box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);
+      padding: 8px;
+      box-sizing: border-box;
+      max-height: 200px;
+      overflow-y: auto;
+    }
+    .st-chip-popover nile-chip {
+      width: 100%;
+    }
+    .st-chip-popover nile-chip::part(base) {
+      border: none !important;
+      box-shadow: none !important;
+      min-height: 32px;
+    }
+    .st-chip-popover nile-chip::part(input) {
+      font-size: var(--nile-font-size-small, 13px);
+    }
+  `;
+    document.head.appendChild(style);
+}
+/**
+ * Custom editor that uses NileChip (tag input) component.
+ * Renders in a floating popover below the cell to avoid expanding row height.
+ *
+ * Cell value is expected to be `string[]` (array of tag strings).
+ */
+export class NileChipEditor {
+    constructor(options) {
+        this.options = options;
+        this.acceptsInitialKeypress = false;
+        this.eventListeners = [];
+        this.trackedValues = [];
+    }
+    edit(context) {
+        if (!context.container) {
+            console.warn('NileChipEditor requires a container element');
+            return;
+        }
+        injectChipStyles();
+        this.cellContainer = context.container;
+        // Create the floating popover
+        this.popover = document.createElement('div');
+        this.popover.className = 'st-chip-popover';
+        // Create nile-chip inside the popover
+        this.chip = document.createElement('nile-chip');
+        this.chip.className = 'st-cell-editor st-nile-chip-editor';
+        this.setInitialValue(context.value);
+        this.applyOptions();
+        this.popover.appendChild(this.chip);
+        // Apply custom max-height if provided
+        if (this.options?.popoverMaxHeight) {
+            this.popover.style.maxHeight = `${this.options.popoverMaxHeight}px`;
+        }
+        // Append popover to body and position it
+        document.body.appendChild(this.popover);
+        this.positionPopover();
+        this.setupEventListeners(context);
+        if (this.options?.autoFocus !== false) {
+            setTimeout(() => {
+                try {
+                    this.chip?.focus();
+                }
+                catch { /* ignore */ }
+            }, 0);
+        }
+    }
+    positionPopover() {
+        if (!this.popover || !this.cellContainer)
+            return;
+        const rect = this.cellContainer.getBoundingClientRect();
+        const minWidth = this.options?.popoverMinWidth ?? rect.width;
+        const popoverWidth = Math.max(minWidth, rect.width);
+        this.popover.style.top = `${rect.bottom + 2}px`;
+        this.popover.style.left = `${rect.left}px`;
+        this.popover.style.width = `${popoverWidth}px`;
+        // After rendering, check if it goes off-screen bottom and flip above if needed
+        requestAnimationFrame(() => {
+            if (!this.popover)
+                return;
+            const popRect = this.popover.getBoundingClientRect();
+            if (popRect.bottom > window.innerHeight) {
+                this.popover.style.top = `${rect.top - popRect.height - 2}px`;
+            }
+        });
+    }
+    setInitialValue(value) {
+        if (!this.chip)
+            return;
+        if (Array.isArray(value)) {
+            this.trackedValues = [...value];
+            this.chip.value = this.trackedValues;
+        }
+        else if (typeof value === 'string' && value) {
+            this.trackedValues = [value];
+            this.chip.value = this.trackedValues;
+        }
+        else {
+            this.trackedValues = [];
+            this.chip.value = [];
+        }
+    }
+    applyOptions() {
+        if (!this.chip || !this.options)
+            return;
+        if (this.options.placeholder) {
+            this.chip.placeholder = this.options.placeholder;
+        }
+        if (this.options.label) {
+            this.chip.label = this.options.label;
+        }
+        if (this.options.helpText) {
+            this.chip.helpText = this.options.helpText;
+        }
+        if (this.options.disabled !== undefined) {
+            this.chip.disabled = this.options.disabled;
+        }
+        if (this.options.readonly !== undefined) {
+            this.chip.readonly = this.options.readonly;
+        }
+        if (this.options.acceptUserInput !== undefined) {
+            this.chip.acceptUserInput = this.options.acceptUserInput;
+        }
+        if (this.options.noDuplicates !== undefined) {
+            this.chip.noDuplicates = this.options.noDuplicates;
+        }
+        if (this.options.clearable !== undefined) {
+            this.chip.clearable = this.options.clearable;
+        }
+        if (this.options.noWrap !== undefined) {
+            this.chip.noWrap = this.options.noWrap;
+        }
+        if (this.options.noAutoComplete !== undefined) {
+            this.chip.noAutoComplete = this.options.noAutoComplete;
+        }
+        if (this.options.enableVirtualScroll !== undefined) {
+            this.chip.enableVirtualScroll = this.options.enableVirtualScroll;
+        }
+        if (this.options.openDropdownOnFocus !== undefined) {
+            this.chip.openDropdownOnFocus = this.options.openDropdownOnFocus;
+        }
+        if (this.options.loading !== undefined) {
+            this.chip.loading = this.options.loading;
+        }
+        // Visual states
+        if (this.options.warning !== undefined) {
+            this.chip.warning = this.options.warning;
+        }
+        if (this.options.error !== undefined) {
+            this.chip.error = this.options.error;
+        }
+        if (this.options.success !== undefined) {
+            this.chip.success = this.options.success;
+        }
+        if (this.options.errorMessage) {
+            this.chip.errorMessage = this.options.errorMessage;
+        }
+        if (this.options.errorIndexes) {
+            this.chip.errorIndexes = this.options.errorIndexes;
+        }
+        // Autocomplete options
+        if (this.options.autoCompleteOptions) {
+            const opts = this.options.autoCompleteOptions;
+            const stringOpts = opts.map(o => typeof o === 'string' ? o : (o.label ?? o.value));
+            this.chip.autoCompleteOptions = stringOpts;
+        }
+        if (this.options.filterFunction) {
+            this.chip.filterFunction = this.options.filterFunction;
+        }
+        if (this.options.renderItemFunction) {
+            this.chip.renderItemFunction = this.options.renderItemFunction;
+        }
+    }
+    addListener(element, event, handler, capture) {
+        element.addEventListener(event, handler, capture);
+        this.eventListeners.push({ element, event, handler, capture });
+    }
+    setupEventListeners(context) {
+        if (!this.chip)
+            return;
+        // Track chip changes
+        this.addListener(this.chip, 'nile-chip-change', (e) => {
+            const detail = e.detail;
+            const newValue = Array.isArray(detail?.value) ? [...detail.value] : (this.chip?.value ? [...this.chip.value] : []);
+            this.trackedValues = newValue;
+            context.onChange(newValue);
+        });
+        // Keyboard handling on the chip element
+        this.addListener(this.chip, 'keydown', (e) => {
+            const keyEvent = e;
+            if (keyEvent.key === 'Enter') {
+                keyEvent.stopPropagation();
+            }
+            else if (keyEvent.key === 'Escape') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                context.onCancel();
+            }
+            else if (keyEvent.key === 'Tab') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                context.onSave(this.getCurrentValue());
+            }
+        });
+        // Click-outside: save when clicking anywhere outside the popover
+        let saveTriggered = false;
+        const mousedownHandler = (e) => {
+            if (saveTriggered)
+                return;
+            if (!this.popover)
+                return;
+            const path = e.composedPath();
+            for (const el of path) {
+                if (el === this.popover)
+                    return;
+                if (el === this.chip)
+                    return;
+                if (el instanceof HTMLElement) {
+                    if (el.tagName?.toLowerCase() === 'nile-chip')
+                        return;
+                    if (el.className && typeof el.className === 'string' && el.className.includes('nile-chip'))
+                        return;
+                }
+            }
+            saveTriggered = true;
+            context.onSave(this.getCurrentValue());
+        };
+        document.addEventListener('mousedown', mousedownHandler, true);
+        this._documentMousedownHandler = mousedownHandler;
+        // Reposition on scroll/resize so popover stays aligned with the cell
+        const reposition = () => this.positionPopover();
+        this.addListener(window, 'resize', reposition);
+        this.addListener(window, 'scroll', reposition, true);
+    }
+    destroy() {
+        // Remove document mousedown handler
+        if (this._documentMousedownHandler) {
+            document.removeEventListener('mousedown', this._documentMousedownHandler, true);
+            delete this._documentMousedownHandler;
+        }
+        // Remove all tracked listeners
+        for (const { element, event, handler, capture } of this.eventListeners) {
+            element.removeEventListener(event, handler, capture);
+        }
+        this.eventListeners = [];
+        // Remove the popover from the DOM
+        if (this.popover) {
+            this.popover.remove();
+            this.popover = undefined;
+        }
+        this.chip = undefined;
+        this.cellContainer = undefined;
+        this.trackedValues = [];
+    }
+    focus() {
+        try {
+            this.chip?.focus();
+        }
+        catch { /* ignore */ }
+    }
+    getCurrentValue() {
+        if (this.trackedValues.length > 0) {
+            return [...this.trackedValues];
+        }
+        if (!this.chip)
+            return [];
+        const val = this.chip.value;
+        return Array.isArray(val) ? [...val] : [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nile-chip-editor.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/editors/nile-chip-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom editor using NileChip from @aquera/nile-elements\n * Renders the chip input in a floating popover below the cell to avoid row height mismatch.\n *\n * @see https://nile.aqueralabs.com/1.6.3/chip?theme=enterprise\n */\n\nimport { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';\n\n/**\n * Chip option for autocomplete suggestions\n */\nexport interface ChipOption {\n  /** The option's value */\n  value: string;\n  /** Display label for the option (defaults to value if omitted) */\n  label?: string;\n}\n\n/**\n * Options interface for NileChipEditor\n */\nexport interface NileChipEditorOptions {\n  /** Autocomplete suggestion list (full set) */\n  autoCompleteOptions?: ChipOption[] | string[];\n\n  /** Placeholder text shown inside the input area */\n  placeholder?: string;\n\n  /** Allow users to type custom values not present in the suggestion list */\n  acceptUserInput?: boolean;\n\n  /** Prevent duplicate chip values */\n  noDuplicates?: boolean;\n\n  /** Disable the chip input */\n  disabled?: boolean;\n\n  /** Make the chip input readonly */\n  readonly?: boolean;\n\n  /** Show a clear-all button */\n  clearable?: boolean;\n\n  /** Prevent chip tags from wrapping to multiple lines */\n  noWrap?: boolean;\n\n  /** Remove the autocomplete dropdown entirely */\n  noAutoComplete?: boolean;\n\n  /** Enable virtual scrolling in the suggestion dropdown */\n  enableVirtualScroll?: boolean;\n\n  /** Control whether the dropdown opens on focus — 'true' | 'false' | 'always' */\n  openDropdownOnFocus?: string;\n\n  /** Show loading spinner inside the dropdown */\n  loading?: boolean;\n\n  // Visual states\n  /** Warning state styling */\n  warning?: boolean;\n  /** Error state styling */\n  error?: boolean;\n  /** Success state styling */\n  success?: boolean;\n  /** Error message shown below the input */\n  errorMessage?: string;\n  /** Help text shown below the input */\n  helpText?: string;\n  /** Label text for the chip input */\n  label?: string;\n  /** Indexes of chips to highlight as errors */\n  errorIndexes?: number[];\n\n  /** Custom filter function for autocomplete */\n  filterFunction?: (query: string, option: string) => boolean;\n\n  /** Custom render function for dropdown items */\n  renderItemFunction?: (option: string) => string;\n\n  /** Auto-focus the input when editor opens (default: true) */\n  autoFocus?: boolean;\n\n  /** Minimum width of the popover in px (default: width of the cell) */\n  popoverMinWidth?: number;\n\n  /** Maximum height of the popover in px before it scrolls (default: 200) */\n  popoverMaxHeight?: number;\n}\n\nlet chipStylesInjected = false;\nfunction injectChipStyles(): void {\n  if (chipStylesInjected) return;\n  chipStylesInjected = true;\n\n  const styleId = 'nile-chip-editor-styles';\n  if (document.getElementById(styleId)) return;\n\n  const style = document.createElement('style');\n  style.id = styleId;\n  style.textContent = `\n    .st-chip-popover {\n      position: fixed;\n      z-index: 10000;\n      background: var(--nile-colors-white-base, #fff);\n      border: 1px solid var(--nile-colors-neutral-200, #e2e8f0);\n      border-radius: 6px;\n      box-shadow: 0 4px 16px rgba(0, 0, 0, 0.12);\n      padding: 8px;\n      box-sizing: border-box;\n      max-height: 200px;\n      overflow-y: auto;\n    }\n    .st-chip-popover nile-chip {\n      width: 100%;\n    }\n    .st-chip-popover nile-chip::part(base) {\n      border: none !important;\n      box-shadow: none !important;\n      min-height: 32px;\n    }\n    .st-chip-popover nile-chip::part(input) {\n      font-size: var(--nile-font-size-small, 13px);\n    }\n  `;\n  document.head.appendChild(style);\n}\n\n/**\n * Custom editor that uses NileChip (tag input) component.\n * Renders in a floating popover below the cell to avoid expanding row height.\n *\n * Cell value is expected to be `string[]` (array of tag strings).\n */\nexport class NileChipEditor implements CellEditor<string[]> {\n  acceptsInitialKeypress = false;\n\n  private chip?: any;\n  private popover?: HTMLDivElement;\n  private cellContainer?: HTMLElement;\n  private eventListeners: Array<{ element: EventTarget; event: string; handler: EventListener; capture?: boolean }> = [];\n  private trackedValues: string[] = [];\n\n  constructor(private readonly options?: NileChipEditorOptions) {}\n\n  edit(context: CellEditorContext<string[]>): void {\n    if (!context.container) {\n      console.warn('NileChipEditor requires a container element');\n      return;\n    }\n\n    injectChipStyles();\n\n    this.cellContainer = context.container;\n\n    // Create the floating popover\n    this.popover = document.createElement('div');\n    this.popover.className = 'st-chip-popover';\n\n    // Create nile-chip inside the popover\n    this.chip = document.createElement('nile-chip');\n    this.chip.className = 'st-cell-editor st-nile-chip-editor';\n\n    this.setInitialValue(context.value);\n    this.applyOptions();\n    this.popover.appendChild(this.chip);\n\n    // Apply custom max-height if provided\n    if (this.options?.popoverMaxHeight) {\n      this.popover.style.maxHeight = `${this.options.popoverMaxHeight}px`;\n    }\n\n    // Append popover to body and position it\n    document.body.appendChild(this.popover);\n    this.positionPopover();\n\n    this.setupEventListeners(context);\n\n    if (this.options?.autoFocus !== false) {\n      setTimeout(() => {\n        try { this.chip?.focus(); } catch { /* ignore */ }\n      }, 0);\n    }\n  }\n\n  private positionPopover(): void {\n    if (!this.popover || !this.cellContainer) return;\n\n    const rect = this.cellContainer.getBoundingClientRect();\n    const minWidth = this.options?.popoverMinWidth ?? rect.width;\n    const popoverWidth = Math.max(minWidth, rect.width);\n\n    this.popover.style.top = `${rect.bottom + 2}px`;\n    this.popover.style.left = `${rect.left}px`;\n    this.popover.style.width = `${popoverWidth}px`;\n\n    // After rendering, check if it goes off-screen bottom and flip above if needed\n    requestAnimationFrame(() => {\n      if (!this.popover) return;\n      const popRect = this.popover.getBoundingClientRect();\n      if (popRect.bottom > window.innerHeight) {\n        this.popover.style.top = `${rect.top - popRect.height - 2}px`;\n      }\n    });\n  }\n\n  private setInitialValue(value: string[]): void {\n    if (!this.chip) return;\n    if (Array.isArray(value)) {\n      this.trackedValues = [...value];\n      this.chip.value = this.trackedValues;\n    } else if (typeof value === 'string' && value) {\n      this.trackedValues = [value];\n      this.chip.value = this.trackedValues;\n    } else {\n      this.trackedValues = [];\n      this.chip.value = [];\n    }\n  }\n\n  private applyOptions(): void {\n    if (!this.chip || !this.options) return;\n\n    if (this.options.placeholder) {\n      this.chip.placeholder = this.options.placeholder;\n    }\n\n    if (this.options.label) {\n      this.chip.label = this.options.label;\n    }\n\n    if (this.options.helpText) {\n      this.chip.helpText = this.options.helpText;\n    }\n\n    if (this.options.disabled !== undefined) {\n      this.chip.disabled = this.options.disabled;\n    }\n\n    if (this.options.readonly !== undefined) {\n      this.chip.readonly = this.options.readonly;\n    }\n\n    if (this.options.acceptUserInput !== undefined) {\n      this.chip.acceptUserInput = this.options.acceptUserInput;\n    }\n\n    if (this.options.noDuplicates !== undefined) {\n      this.chip.noDuplicates = this.options.noDuplicates;\n    }\n\n    if (this.options.clearable !== undefined) {\n      this.chip.clearable = this.options.clearable;\n    }\n\n    if (this.options.noWrap !== undefined) {\n      this.chip.noWrap = this.options.noWrap;\n    }\n\n    if (this.options.noAutoComplete !== undefined) {\n      this.chip.noAutoComplete = this.options.noAutoComplete;\n    }\n\n    if (this.options.enableVirtualScroll !== undefined) {\n      this.chip.enableVirtualScroll = this.options.enableVirtualScroll;\n    }\n\n    if (this.options.openDropdownOnFocus !== undefined) {\n      this.chip.openDropdownOnFocus = this.options.openDropdownOnFocus;\n    }\n\n    if (this.options.loading !== undefined) {\n      this.chip.loading = this.options.loading;\n    }\n\n    // Visual states\n    if (this.options.warning !== undefined) {\n      this.chip.warning = this.options.warning;\n    }\n    if (this.options.error !== undefined) {\n      this.chip.error = this.options.error;\n    }\n    if (this.options.success !== undefined) {\n      this.chip.success = this.options.success;\n    }\n    if (this.options.errorMessage) {\n      this.chip.errorMessage = this.options.errorMessage;\n    }\n    if (this.options.errorIndexes) {\n      this.chip.errorIndexes = this.options.errorIndexes;\n    }\n\n    // Autocomplete options\n    if (this.options.autoCompleteOptions) {\n      const opts = this.options.autoCompleteOptions;\n      const stringOpts: string[] = opts.map(o => typeof o === 'string' ? o : (o.label ?? o.value));\n      this.chip.autoCompleteOptions = stringOpts;\n    }\n\n    if (this.options.filterFunction) {\n      this.chip.filterFunction = this.options.filterFunction;\n    }\n\n    if (this.options.renderItemFunction) {\n      this.chip.renderItemFunction = this.options.renderItemFunction;\n    }\n  }\n\n  private addListener(element: EventTarget, event: string, handler: EventListener, capture?: boolean): void {\n    element.addEventListener(event, handler, capture);\n    this.eventListeners.push({ element, event, handler, capture });\n  }\n\n  private setupEventListeners(context: CellEditorContext<string[]>): void {\n    if (!this.chip) return;\n\n    // Track chip changes\n    this.addListener(this.chip, 'nile-chip-change', (e: Event) => {\n      const detail = (e as CustomEvent).detail;\n      const newValue: string[] = Array.isArray(detail?.value) ? [...detail.value] : (this.chip?.value ? [...this.chip.value] : []);\n      this.trackedValues = newValue;\n      context.onChange(newValue);\n    });\n\n    // Keyboard handling on the chip element\n    this.addListener(this.chip, 'keydown', (e: Event) => {\n      const keyEvent = e as KeyboardEvent;\n      if (keyEvent.key === 'Enter') {\n        keyEvent.stopPropagation();\n      } else if (keyEvent.key === 'Escape') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        context.onCancel();\n      } else if (keyEvent.key === 'Tab') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        context.onSave(this.getCurrentValue());\n      }\n    });\n\n    // Click-outside: save when clicking anywhere outside the popover\n    let saveTriggered = false;\n    const mousedownHandler = (e: MouseEvent) => {\n      if (saveTriggered) return;\n      if (!this.popover) return;\n\n      const path = e.composedPath();\n      for (const el of path) {\n        if (el === this.popover) return;\n        if (el === this.chip) return;\n        if (el instanceof HTMLElement) {\n          if (el.tagName?.toLowerCase() === 'nile-chip') return;\n          if (el.className && typeof el.className === 'string' && el.className.includes('nile-chip')) return;\n        }\n      }\n\n      saveTriggered = true;\n      context.onSave(this.getCurrentValue());\n    };\n\n    document.addEventListener('mousedown', mousedownHandler, true);\n    (this as any)._documentMousedownHandler = mousedownHandler;\n\n    // Reposition on scroll/resize so popover stays aligned with the cell\n    const reposition = () => this.positionPopover();\n    this.addListener(window, 'resize', reposition);\n    this.addListener(window, 'scroll', reposition, true);\n  }\n\n  destroy(): void {\n    // Remove document mousedown handler\n    if ((this as any)._documentMousedownHandler) {\n      document.removeEventListener('mousedown', (this as any)._documentMousedownHandler, true);\n      delete (this as any)._documentMousedownHandler;\n    }\n\n    // Remove all tracked listeners\n    for (const { element, event, handler, capture } of this.eventListeners) {\n      element.removeEventListener(event, handler, capture);\n    }\n    this.eventListeners = [];\n\n    // Remove the popover from the DOM\n    if (this.popover) {\n      this.popover.remove();\n      this.popover = undefined;\n    }\n\n    this.chip = undefined;\n    this.cellContainer = undefined;\n    this.trackedValues = [];\n  }\n\n  focus(): void {\n    try { this.chip?.focus(); } catch { /* ignore */ }\n  }\n\n  getCurrentValue(): string[] {\n    if (this.trackedValues.length > 0) {\n      return [...this.trackedValues];\n    }\n    if (!this.chip) return [];\n    const val = this.chip.value;\n    return Array.isArray(val) ? [...val] : [];\n  }\n}\n"]}